Bootstrap

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)。快速排序不是稳定排序。

;