JavaScript实现八大内部排序算法

注：基数排序中：r是关键字的基数，d是长度，n是关键字的个数

1.插入排序

基本思想：在序号i之前的元素(0到i-1)已经排好序，本趟需要找到i对应的元素x (此时即arr[i]) 的正确位置k,在寻找位置k的过程中与序号i-1到0的元素依次进行比较。如果x小于比较元素，则比较元素向后移动一位；否则，结束移位，将x插入当前位置k

 function insertSort(arr) {
   for (let i = 1; i < arr.length; i++) {
     // 将待插入元素提取出来
     let temp = arr[i]
     let j
     for (j = i - 1; j >= 0; j--) {
       if (arr[j] > temp) {
         // 插入元素小于比较元素，比较元素则向后移动一位
         arr[j + 1] = arr[j]
       } else {
         // 否则，结束移位
         break
       }
     }
     //将插入元素插入正确位置
     arr[j + 1] = temp
   }
   return arr
 }
 console.log(insertSort([7, 3, 4, 5, 10, 7, 8, 2]))

 

1.1插入排序的优化：二分排序

与插入排序思想差不多，但是二分排序是在插入第i个元素时，对前面的0~i-1元素进行折半，先跟它们中间的元素进行比较。如果小，那么对前半进行折半；如果打，那么对后半进行折半。依次进行，直到left>right。然后再把第i个元素前一位与目标位置之间的所有元素向后移动一位，再将目标元素放入正确位置上。

 function binarySort(arr) {
   for (let i = 0; i < arr.length; i++) {
     let temp = arr[i]
     let left = 0
     let right = i - 1
     let mid
     while (left <= right) {
       mid = Math.floor((left + right) / 2)
       if (arr[mid] > temp) {
         right = mid - 1
       } else {
         left = mid + 1
       }
     }
     for (let j = i - 1; j >= left; j--) {
       arr[j + 1] = arr[j]
     }
     if (left !== i) {
       arr[left] = temp
     }
   }
   return arr
 }
 console.log(binarySort([7, 3, 4, 5, 10, 7, 8, 2]))

2.希尔排序

基本思想：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

 function shellSort(arr) {
   let d = arr.length
   while (true) {
     d = Math.floor(d / 2)
     for (let x = 0; x < d; x++) {
       for (let i = x + d; i < arr.length; i = i + d) {
         let temp = arr[i]
         let j
         for (j = i - d; j >= 0 && arr[j] > temp; j = j - d) {
           arr[j + d] = arr[j]
         }
         arr[j + d] = temp
       }
     }
     if (d == 1) {
       break
     }
   }
   return arr
 }
 console.log(shellSort([7, 3, 4, 5, 10, 7, 8, 2]))

3.直接选择排序

基本思想：每次选择待排序的元素中最小的值，放置在序列的首位

 function directSelectSort(arr) {
   for (let i = 0; i < arr.length; i++) {
     let min = arr[i]
     let index = i
     for (let j = i + 1; j < arr.length; j++) {
       if (arr[j] < min) {
         // 找到最小值，并标注最小值索引，方便后续与元素arr[i]交换位置
         min = arr[j]
         index = j
       }
     }
     arr[index] = arr[i]
     arr[i] = min
   }
   return arr
 }
 console.log(directSelectSort([7, 3, 4, 5, 10, 7, 8, 2]))

4.堆排序

堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单

用大根堆排序的基本思想

① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区

② 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。……

直到无序区只有一个元素为止。

 let len

 function buildMaxHeap(arr) {
   //建立大根堆
   len = arr.length
   for (let i = Math.floor(len / 2); i >= 0; i--) {
     heapify(arr, i)
   }
 }

 function heapify(arr, i) {
   //堆调整
   let left = 2 * i + 1,
     right = 2 * i + 2,
     largest = i

   if (left < len && arr[left] > arr[largest]) {
     largest = left
   }

   if (right < len && arr[right] > arr[largest]) {
     largest = right
   }

   if (largest !== i) {
     // 解构赋值，交换变量
     ;[arr[i], arr[largest]] = [arr[largest], arr[i]]
     heapify(arr, largest)
   }
 }

 function heapSort(arr) {
   buildMaxHeap(arr)

   for (let i = arr.length - 1; i > 0; i--) {
     ;[arr[0], arr[i]] = [arr[i], arr[0]]
     len--
     heapify(arr, 0)
   }
   return arr
 }

 console.log(heapSort([7, 3, 4, 5, 10, 7, 8, 2]))

5.冒泡排序

基本思想：每次比较两相邻的数,当发现它们的排序与排序要求相反时，就将它们互换。这样小的数往下沉，大的数往上冒

 function bubbleSort(arr) {
   for (let i = 0; i < arr.length; i++) {
     // 因为每次比较时都已经有i个元素沉下去了，所以j<arr.length-1-i
     for (let j = 0; j < arr.length - 1 - i; j++) {
       if (arr[j] > arr[j + 1]) {
         // 这里采用了解构赋值。如果一般做法，借助临时变量，则辅助空间是O(1)
         ;[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
       }
     }
   }
   return arr
 }
 console.log(bubbleSort([7, 3, 4, 5, 10, 7, 8, 2]))

6.快速排序

基本思想：选择一个基准元素(通常选择第一个元素)，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有元素都比基准元素小，另外一部分的所有元素大于或等于基准元素大。同样方法依次分割；整个排序过程可以递归进行。

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

   let pivot = Math.floor((arr.length -1)/2);
   let val = arr[pivot], less = [], more = [];

   arr.splice(pivot, 1);
   arr.forEach(function(e,i,a){
     e < val ? less.push(e) : more.push(e);
   });

   return (quicksort(less)).concat([val],quicksort(more))
 }
 console.log(quicksort([7, 3, 4, 5, 10, 7, 8, 2]))

7.归并排序

基本思想:将待排序序列分为若干个子序列，每个子序列是有序的，然后将有序子序列合并为整体有序序列。

 function merge(left, right) {
   let result = []
   while (left.length > 0 && right.length > 0) {
     if (left[0] < right[0]) {
       /*shift()方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。*/
       result.push(left.shift())
     } else {
       result.push(right.shift())
     }
   }
   return result.concat(left).concat(right)
 }
 function mergeSort(arr) {
   if (arr.length == 1) {
     return arr
   }
   let middle = Math.floor(arr.length / 2),
     left = arr.slice(0, middle),
     right = arr.slice(middle)
   return merge(mergeSort(left), mergeSort(right))
 }
 console.log(mergeSort([7, 3, 4, 5, 10, 7, 8, 2]))

8.基数排序

基本思想：将所有待比较元素（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从个位开始，进行排序；然后十位，进行排序；以此进行！这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

基数排序两种方法：

MSD 从高位开始进行排序

LSD 从低位开始进行排序

 // LSD Radix Sort
 // helper function to get the last nth digit of a number
 var getDigit = function(num,nth){
   // get last nth digit of a number
   var ret = 0;
   while(nth--){
     ret = num % 10
     num = Math.floor((num - ret) / 10)
   }
   return ret
 }

 // radixSort
 function radixSort(arr){
   var max = Math.floor(Math.log10(Math.max.apply(Math,arr))),
       // get the length of digits of the max value in this array
       digitBuckets = [],
       idx = 0;

   for(var i = 0;i<max+1;i++){

     // rebuild the digit buckets according to this digit
     digitBuckets = []
     for(var j = 0;j<arr.length;j++){
       var digit = getDigit(arr[j],i+1);

       digitBuckets[digit] = digitBuckets[digit] || [];
       digitBuckets[digit].push(arr[j]);
     }

     // rebuild the arr according to this digit
     idx = 0
     for(var t = 0; t< digitBuckets.length;t++){
       if(digitBuckets[t] && digitBuckets[t].length > 0){
         for(j = 0;j<digitBuckets[t].length;j++){
           arr[idx++] = digitBuckets[t][j];
         }
       }
     }
   }
   return arr
 }
 console.log(radixSort([7, 3, 4, 5, 10, 7, 8, 2]))

注：网上有很多javascript实现的基数排序代码时错误的

当搜索一些问题时，尽量使用英文进行搜索！