vue排序算法

 1、冒泡排序

 两两比较待排序的关键字，并交换不满足次序要求的那对数，直到整个表都满足次序要求为止。

bubbleSort = (list) = > {
    let temp = 0; // 用来交换的临时数
    // 要遍历的次数
    for (let i = 0; i < list.length - 1; i++) {
        // 从后向前依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
        for (let j = list.length - 1; j > i; j--) {
            // 比较相邻的元素，如果前面的数大于后面的数，则交换
            if (list[j - 1] > list[j]) {
                temp = list[j - 1];
                list[j - 1] = list[j];
                list[j] = temp;
            }
        }
    }
}

 冒泡排序算法的性能

若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值：Cmin = N - 1。所以，冒泡排序最好时间复杂度为O(N)。
若初始文件是反序的，需要进行 N -1 趟排序。每趟排序要进行 N - i 次关键字的比较(1 ≤ i ≤ N - 1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：
Cmax = N(N-1)/2 = O(N2)
Mmax = 3N(N-1)/2 = O(N2)
冒泡排序的最坏时间复杂度为O(N2)。
因此，冒泡排序的平均时间复杂度为O(N2)。
算法稳定性：相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

2、选择排序

 两两比较待排序的关键字，并交换不满足次序要求的那对数，直到整个表都满足次序要求为止。

function selectSort(nums){
    let n = nums.length;
    let minIndex,temp;
    for(let i=0;i<n-1;i++){
        minIndex = i;
        for(let j=i+1;j<n;j++){
            if(nums[minIndex]>nums[j]){
                minIndex = j;
            }
        }
        temp = nums[i];
        nums[i] = nums[minIndex];
        nums[minIndex] = temp;
    }
    return nums;
}

选择排序算法的性能

需要遍历数组才能找到峰值元素，所以复杂度与原始序列是否有序无关：
Cmax = n + n-1 + n-2 + … + 2 + 1 = n * (n+1) / 2 = O(N2)
冒泡排序的时间复杂度为O(N2)。
因此，冒泡排序的平均时间复杂度为O(N2)。
算法稳定性：无序部分最大元素和有序部分第一个元素相等的时候，可以将无序部分最大元素放在前面，所以选择排序是稳定的。

3、插入排序

将未排序数据，对已排序数据序列从后向前扫描，找到对应的位置并插入。在从后向前扫描的过程中，需要反复的把已排序的元素逐步向后挪位，为新插入元素提供插入的位置。 

 

  function insertSort(arr) { 
     var len =arr.length; 
     for (var i=1;i<len; i++) { 
          var temp=arr[i]; 
          var j=i-1;//默认已排序的元素 
               while (j>=0 && arr[j]>temp) {  //在已排序好的队列中从后向前扫描 
                    arr[j+1]=arr[j]; //已排序的元素大于新元素，将该元素移到一下个位置
                    j--; 
                }
              arr[j+1]=temp;
      } 
     return arr；     
   }

插入排序算法的性能

如果目标是升序排序，那么插入排序有最好情况和最坏情况两种。最好情况是，序列已经是升序排列，那么只需要比较n-1次，当序列是降序排列，那么比较次数是n(n-1)/2,赋值操作是比较次数减去（n-1）次。平均来说，插入算法时间复杂度是O(n^2)，空间复杂度是O（1）。
算法稳定性：无序部分最大元素和有序部分第一个元素相等的时候，可以将无序部分最大元素放在前面，所以插入排序是稳定的。

 

4、快速排序

数组中指定一个元素作为标尺，比它大的放到该元素后面，比它小的放到该元素前面，如此重复直至全部正序排列。它利用了“分治”思想——把一个复杂的问题分成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。

let QuickSort = (arr, low, high) => {
    let temp;
    let i = low;
    let j = high;
    if (low < high) {
        temp = R[low];    //设置枢轴
        while (i !== j) {
            while (j > i && R[j] >= temp) {
                --j;
            }
            if (i < j) {
                R[i] = R[j];
                ++i;
            }
           while(i < j && R[i] < temp) {
                ++i;
            }
            if (i < j) {
                R[j] = R[i];
                --j;
            }
        }
        R[i] = temp;
        QuickSort(R, low, i-1);
        QuickSort(R, i+1, high);
    }
}

快速排序算法的性能

时间复杂度： 快速排序最优的情况就是每一次取到的元素都刚好平分整个数组，根据递归算法的时间复杂度公式：T[n] = aT[n/b] + f(n) ，得到快速排序最优的情况下时间复杂度为：O( nlogn ) ；最差的情况就是每一次取到的元素就是数组中最小/最大的，这种情况其实就是冒泡排序了，所以时间复杂度为O(n2)，平均时间复杂度为O(nlog2n)。快速排序不是稳定排序。