几种排序算法

1.插入排序

  o(n) o(1)稳定

function insertSort(arr){
if(arr.length<=1){
return arr;

}
var index=arr[0];
var res=[];
for(var i=1;i<arr.length;i++){
var num = arr[i];
var j=i-1;
while(i>=0&&num<=arr[j]){
arr[j+1]=arr[j];
j--;

}
arr[j+1]=num;
}
return arr;
}
var arr=[3,2,4,1,5,6];
insertSort(arr);

2.选择排序

o(n) o(1) 稳定

function selSort(arr){
             for (var i = 0; i < arr.length; i++) {
                 var min=arr[i];//以下一次循环的开始节点作为最小节点进行比较
                 for (var j = i+1; j < arr.length; j++) {
                     if(arr[j]<min){//比较len-i次 即比较后面没有排序的数的长度
                         var temp = min;//记录最小的进行交换
                         min = arr[j];
                         arr[j]=temp;
                     }
                 }
                 arr[i]=min;//循环完一次找到最小的赋给此次循环的下标
             }
             return arr;
         }
         var arr=[2,3,6,1,2,5,4];
         selSort(arr);

3.快速排序

o(nlog(n)) o(logn) 不稳定

function quickSort(arr,left,right){
             var index;
             if(arr.length>1){
                 left=typeof left !="Number"?0:left;
                 right=typeof right !="Number"?arr.length-1:right;

                 index=quickCore(arr,left,right);
                 if(left<index-1){
                     quickSort(arr,left,index-1);
                 }
                 if(right>index){
                     quickSort(arr,index+1,right);
                 }
             }
         }
         function quickCore(arr,low,high){
             var pivot = arr[low];
             while(low<high){
                 while(low<high&&arr[high]>pivot){
                     high--;
                 }
                 arr[low]=arr[high];low++;
                 while(low<high&&arr[low]<pivot){
                     low++;
                 }
                 arr[high]=arr[low];high--;
                 
             }
             arr[low] = pivot;
             return high;
         }
         var arr=[2,3,6,1,2,5,4];
         quickSort(arr);

4.归并排序

5.堆排序

建大根堆，从小到大  建堆 交换 调整

//调整函数
function headAdjust(elements, pos, len){
  //将当前节点值进行保存
  var swap = elements[pos];

  //定位到当前节点的左边的子节点
  var child = pos * 2 + 1;

  //递归，直至没有子节点为止
  while(child < len){
    //如果当前节点有右边的子节点，并且右子节点较大的场合，采用右子节点
    //和当前节点进行比较
    if(child + 1 < len && elements[child] < elements[child + 1]){
      child += 1;
    }

    //比较当前节点和最大的子节点，小于则进行值交换，交换后将当前节点定位
    //于子节点上
    if(elements[pos] < elements[child]){
      elements[pos] = elements[child];
      pos = child;
      child = pos * 2 + 1;
    }
    else{
      break;
    }

    elements[pos] = swap;
  }
}

//构建堆
function buildHeap(elements){
  //从最后一个拥有子节点的节点开始，将该节点连同其子节点进行比较，
  //将最大的数交换与该节点,交换后，再依次向前节点进行相同交换处理，
  //直至构建出大顶堆（升序为大顶，降序为小顶）
  for(var i=elements.length/2; i>=0; i--){
    headAdjust(elements, i, elements.length);
  }
}

function sort(elements){
  //构建堆
  buildHeap(elements);

  //从数列的尾部开始进行调整
  for(var i=elements.length-1; i>0; i--){
    //堆顶永远是最大元素，故，将堆顶和尾部元素交换，将
    //最大元素保存于尾部，并且不参与后面的调整
    var swap = elements[i];
    elements[i] = elements[0];
    elements[0] = swap;

    //进行调整，将最大）元素调整至堆顶
    headAdjust(elements, 0, i);
  }
}

var elements = [3, 1, 5, 7, 2, 4, 9, 6, 10, 8];
console.log('before: ' + elements);
sort(elements);
console.log(' after: ' + elements);