排序算法小结

目录

冒泡排序

选择排序

插入排序

归并排序

快速排序

---

冒泡排序

一句话描述就是较高的往后站。
步骤如下：
1. 从第一个数开始，如果第一个比第二个大，就交换两个，把大的数往后放。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样轮完一遍之后，最大的数必定在最后一位。
3. 再次遍历，重复步骤1，2，但是只遍历到最后一个数的前一个。

//用来互换两个数位置的swap函数
function swap(array,a,b){
    var temp = array[a]
    array[a] = array[b]
    array[b] = temp
}
function bubbleSort(arr) {
var len = arr.length
 for(var i = 0; i < len; i++){
    for(var j = 0; j < len - 1 - i; j++){
         if(arr[j] > arr[j+1]){
          swap(arr,j,j+1)
          }
       }
    }
    return arr
}

时间复杂度：O(n^2)
最好情况：O(n)//正序数组
最差情况：O(n^2)//倒序数组
空间复杂度：O(1)
稳定性：稳定

选择排序

一句话说明就是最矮的到最前面
步骤如下：
1. 将指针指向第一个元素，并标记为最小元素
2. 遍历整个数组，直至遍历完后找到比它小的最小元素，然后交换两者位置。
3. 重复第一步，但是从第二个元素开始遍历，然后重复第二步

  function swap(array, a, b) {
            var temp = array[a]
            array[a] = array[b]
            array[b] = temp
        }

        function selectionSort(arr) {
            var len = arr.length;
            var minIndex, temp;
            for (var i = 0; i < len; i++) {
                minIndex = i;
                for (var j = i + 1; j < len - 1; j++) {
                    if (arr[j] < arr[minIndex]) {
                        minIndex = j
                    }
                }
                //如果数组第一个数是最小的话，就不交换，否则才换
                if (minIndex !== i) {
                    swap(arr, i, minIndex)
                }
            }
            return arr
        }

时间复杂度：O(n^2)
最好情况：O(n^2)
最差情况：O(n^2)
空间复杂度：O(1)
稳定性：不稳定//[5,5,2]

插入排序

一句话说明：摸牌算法
我们拿牌的时候，每拿到一张新牌，就会和手中已有的牌进行比较，大的放右边，小的放在左边。
步骤如下：
1. 从第一个元素开始，这个元素被认为已经被排序
2. 然后拿到下一个元素，在已经排序的元素中从后向前扫描，如果新元素比我们已排的元素小，就把已排元素向后排一位
3. 接着从后往前遍历，知道找到已排序的元素小于或者等于新元素，把新元素插入到该元素后面

     function insertionSort(arr) {
            var len = arr.length,
                key, i, j;
            for (j = 1; j < len; j++) {
                key = arr[j]
                i = j - 1
                while (i >= 0 && arr[i]>key){
                    arr[j] = arr[i]
                    i--
                }
                arr[i+1] = key
            }
            return arr
        }

时间复杂度：O(n^2)
最好情况：O(n)//升序排列
最差情况：O(n^2)//降序排列
空间复杂度：O(1)
稳定性：稳定

归并排序

一句话说明，就是分治，将已有的子序列归并，得到完全有序的序列。
步骤如下：
1. 将长度为n的数组分为两半，然后再将两个子数组再次对半分，不停对半分，直至最小子数组中只有两个数。
2. 然后排序，向上一级再次排序，这样不停归并，直到合起来的最终数组有序

        //递归,分到不能分为止
      function mergeSort(arr){
          var len = arr.length

          if(len < 2){
              return arr
          }
          var middle = Math.floor(len / 2),
                left = arr.slice(0,middle),
                right = arr.slice(middle);
                //arr不变,创建了两个新的数组
            return merge(mergeSort(left),mergeSort(right))
      }
      function merge(left,right){
          var result = [];
          while(left.length && right.length) {
              if(left[0] < right[0]) {
                  result.push(left.shift())
              }
              else{
                  result.push(right.shift())
              }
          }
          while(left.length){
              result.push(left.shift())
          }
          while(right.length){
              result.push(right.shift())
          }
          return result
      }

时间复杂度：O(n log n)
最好情况：O(n log n)
最差情况：O(n log n)
空间复杂度：O(n)
稳定性：稳定

快速排序

一句话说明，自私算法，让每个元素找到自己的位置。

    function quickSort(arr) {
            var len = arr.length;
            if (len < 2) {
                return arr
            }
            var pivotIndex = Math.floor(len / 2);
            var pivot = arr.splice(pivotIndex, 0)
            var left = [],
                right = [];
                for(var i = 0; i < len;i++){
                    if(arr[i] < pivot){
                        left.push(arr[i])
                    }else{
                        right.push(arr[i])
                    }
                }
                return quickSort(left.concat([pivot]),quickSort(right))
        }

时间复杂度：O(n log n)
最好情况：O(n log n)
最差情况：O(n^2)
空间复杂度：O( log n )
稳定性：不稳定

---

参考博客
十大经典排序算法总结（JavaScript描述）
前言
常见排序算法理解与JS实现
阮一峰博客