排序小結

 

兩路快排：

function partion(arr, low, high){
   var idx = low;
   var pivot = arr[low];
   while(low<high){
      while(low<high && arr[high]>= pivot){ high--; }
      while(low<high && arr[low] <= pivot) { low++; }
      if(low<high){
         var temp = arr[high];
         arr[high] = arr[low];
         arr[low] = temp;
      }
   }
   if(low == high){
     arr[idx] = arr[low];
     arr[low] = pivot;
   }
   return low;
}

function quicksort1(arr, low, high){
  if(low < high ){
     var pivot = partion(arr, low, high);
     quicksort(arr, low, pivot-1);
     quicksort(arr, pivot+1, high);
  }
}

function quicksort2(arr, low, high){
   var stack = [];
   if(low<high){
     var mid = partion(arr, low, high);
     if(low< mid -1){
       stack.push(low);
       stack.push(mid-1);
     }
     if(mid+1< high){
       stack.push(mid+1);
       stack.push(high);
     }
   }

    while(stack.length > 0){
      var higher = stack.pop();
      var lower = stack.pop();
      var midder = partion(arr, lower, higher);
      if(lower < midder -1){
         stack.push(lower);
         stack.push(midder -1);
      }
      if(midder+1 < higher){
         stack.push(midder + 1);
         stack.push(higher);
      }
    }

}

var arr = [3,6,2,9,4,7];
quicksort1(arr, 0, arr.length -1);
quicksort2(arr, 0, arr.length -1);

 

冒泡排序：優化後的

function Bubblesort(arr){
  var len = arr.length;
  for(var i=0;i< len-1; i++){ //表明要排序多少次
    for(var j=0;j< len-i-1;j++){ //每次的起始和截止位置
      if(arr[j] > arr[j+1]){
         var tem = arr[j];
         arr[j] = arr[j+1];
         arr[j+1] = tem;
      }  
    }
  }
}

選擇排序：

function Selection(arr){
   for(var i=0;i< arr.length-1; i++){ //表明要排序多少次
     for(var j=i+1; j<arr.length; j++){ //起始和截止位置
        if(arr[i] > arr[j]){
           var temp = arr[i];
           arr[i] = arr[j];
           arr[j] = temp;
        }
     }
   }
}

插入排序：通常的插入排序

對於每一個未排序數，在已排序序列中從後向前掃描找到相應位置並插入。默認arr[0]爲開始。

function InsertSort(arr){
   for(var i=1;i< arr.length;i++){ //須要對arr.length-1個數進行排序，級進行這麼屢次
     var item = arr[i]; //記錄待排序數數值和下標
     var pos = i;
     while(i>0 && item< arr[i-1]){ //找應該插在哪一個位置
        i--;
     }
     //位置已肯定，即從i位置日後移動
     for(var k=pos; k>i; k--){
       arr[k] = arr[k-1];
     }
     arr[k] = item;
   }
}

存在缺陷：我在查找應該插入哪一個位置的時候只是單純的去找位置，找到後才移動，能夠更爲優化，即在查找的時候若不是就移動一個

function InsertSort(arr){
   for(var i=1;i< arr.length;i++){
     var item = arr[i];
     var pos = i;
     while(i>0 && item< arr[i-1]){
        arr[i] = arr[i-1];
        i--;
     }
     arr[i] = item;
   }
}

希爾排序：分組插入排序（高級插入排序）

第一次排序：將數組按增量劃分爲多個列，裝在一個表中，對列分別進行插入排序，以後再合併爲一個數組
第二次排序：將數組按另外一個增量劃分多個列，同上

function shellSort(arr){
var gap = Math.floor(arr.length/2); 
while(gap>0){
  for(var i=gap; i<arr.length; i++){
     var temp = arr[i];
     while(i>=gap && temp < arr[i-gap]){
       arr[i] = arr[i-gap];
       i -= gap;
     }
     arr[i] = temp;
  }
  gap = Math.floor(gap/2);
  console.log(gap)
 }
}

 歸併排序：

有點問題：

function dev(arr){
  if(arr.length <=1) return arr;
  var mid = Math.floor(arr.length/2);
  var leftarr = dev(arr.slice(0, mid));
  var rightarr = dev(arr.slice(mid));
  return merge(leftarr, rightarr);
}

function merge(leftarr, rightarr){ 
  var l,r = 0;
  var result = [];
  while(l<leftarr.length && r< rightarr.length){
    if(leftarr[l] < rightarr[r]){
      result.push(leftarr[l]);
      l++
    }else{
      result.push(rightarr[r]);
      r++;
    }
  }
  for(var i=l; i< leftarr.length; i++){
     result.push(leftarr[i]);
  }
  for(var i=r; i< rightarr.length; i++){
     result.push(rightarr[i]);
  }
  return result;
}

二分排序：

function binarySearch(value,arr,startIndex,endIndex) {
    if(!value|| !(arr instanceof Array)) return;
    var    midIndex= Math.floor((startIndex + endIndex)/2),
        midval = arr[midIndex];
    
    if(midval === value){
        return midIndex;
    }else if (midval > value) {
       return binarySearch(value, arr, startIndex, midIndex - 1);
    }else {
       return binarySearch(value, arr, midIndex + 1, endIndex);
    }
}