十大经典排序算法（动图演示）

• 十大经典排序算法（动图演示）
• 判断各种排序算法的稳定性

// 冒泡排序
const bubbleSort=a=>{
    for(let i=0;i<a.length-1;i++){
        for(let j=0;j<a.length-1-i;j++){
            if(a[j]>a[j+1]){
                const tem=a[j];
                a[j]=a[j+1];
                a[j+1]=tem;
            }
        }
    }
    return a;
}

console.log('bubbleSort >>>>',bubbleSort([3,100,2,-1,8]))

// 选择排序
const selectionSort=a=>{
    for(let i=0;i<a.length-1;i++){
        let minIndex=i;
        for(let j=i+1;j<a.length;j++){
            if(a[j]<a[minIndex]){
                minIndex=j;
            }
        }
        const tem=a[i];
        a[i]=a[minIndex];
        a[minIndex]=tem;
    }
    return a;
}

console.log('selectionSort >>>>',selectionSort([3,100,2,-1,8]))

// 插入排序
const insertionSort=a=>{
    for(let i=1;i<a.length;i++){
        const current=a[i];
        let prevIndex=i-1;
        while(prevIndex>=0 && current<a[prevIndex]){
            a[prevIndex+1]=a[prevIndex];
		    prevIndex--;
        }
        a[prevIndex+1]=current;
    }
    return a;
}

console.log('insertionSort >>>>',insertionSort([3,100,2,-1,8]))

// 快速排序
const quickSort=a=>{
    if(a.length<2) return a;
    const privot=a[0];
    let smaller=[];
    let larger=[];
    for(let i=1;i<a.length;i++){
        if(a[i]<=privot){
            smaller.push(a[i]);
        }
        else larger.push(a[i]);
    }
    return [...quickSort(smaller),privot,...quickSort(larger)];
}

console.log('quickSort >>>>',quickSort([3,100,100,2,-1,8,8]))

// 归并排序
const mergeSort=a=>{
    if(a.length<2) return a;
    const mid=~~(a.length/2);
    const left=a.slice(0,mid);
    const right=a.slice(mid);
    return merge(mergeSort(left),mergeSort(right));
}

const merge=(left,right)=>{
    let res=[];
    while(left.length&&right.length){
      if(left[0]<right[0]){
        res.push(left[0]);
        left.shift();
      }
      else{
        res.push(right[0]);
        right.shift();
      }
    }
    while(left.length){
      res.push(left.shift())
    }
    while(right.length){
      res.push(right.shift())
    }
    return res;
}

console.log('mergeSort >>>>',mergeSort([3,100,100,2,-1,8,8]))

// 希尔排序
const shellSort = (a) => {
  for (let gap = ~~(a.length / 2); gap > 0; gap = ~~(gap / 2)) {
    for (let i = gap; i < a.length; i++) {
      const current = a[i];
      let prevIndex = i - gap;
      while (prevIndex >= 0 && current < a[prevIndex]) {
        a[prevIndex + gap] = a[prevIndex];
        prevIndex -= gap;
      }
      a[prevIndex + gap] = current;
    }
  }
  return a;
};

console.log("shellSort >>>>", shellSort([3, 100, 2, -1, 8]));

// 堆排序
const heapSort=function(arr){
    const maxHeap=function(arr,start,end){
    let parent=start;
    let son=parent*2+1;
    while(son<=end){
        if(son+1<=end&&arr[son+1]>arr[son]) son++;
        if(arr[son]>arr[parent]){
            const temp=arr[son];
            arr[son]=arr[parent];
            arr[parent]=temp;
            parent=son;
            son=parent*2+1;
            }
            else{
                return;
            }
        }
    }
    for(let i=~~(arr.length/2-1);i>=0;i--){
        maxHeap(arr,i,arr.length-1);
    }
    for(let i=arr.length-1;i>0;i--){
        const temp=arr[0];
        arr[0]=arr[i];
        arr[i]=temp;
        maxHeap(arr,0,i-1);
    } 
    return arr;  
}

console.log(heapSort([1,5,3,2,7,3,6]))