O(n^2)以及O(nlogn)时间复杂度的排序算法

O(n^2)的算法

都是做的升序。

简单选择排序

思路：每次选择还未排序的区间的最小值和未排序区间的第一个值交换。

 function selectSort(arr){
     for(let i = 0; i < arr.length; i++){
         let minIdx = i;
         for(let j = i; j < arr.length; j++){
             if(arr[j] < arr[minIdx]){
                 minIdx = j;
             }
         }
         let tmp = arr[i];
         arr[i] = arr[minIdx];
         arr[minIdx] = tmp;
     }
     return arr;
 }

插入排序（insertion sort）

思路：当前位置的值与前面排好序的区间从后往前对比，找到适合的插入位置并插入。

适用于：近乎有序的排序，在几乎有序的情况下，它的速度会比n(logn)的算法还要快,可以接近O(n)，插入排序要优于选择排序

 function insertSort(arr){
     let tmp;
     for(let i = 0; i < arr.length; i++){
         for(let j = i - 1; j >= 0; j--){
         if(j === 0){
             if(arr[i] < arr[j]){
                 // 在顺序表中，应该使用副本复制当前的值，采用赋值去修改数组，而不是删除和插入，因为在顺序表中删除和插入的时间复杂度是n
                 tmp = arr.splice(i,1)[0];
                 arr.splice(j,0,tmp);
             }
         }else if(arr[i] < arr[j] && arr[i] >= arr[j - 1]){
                 tmp = arr.splice(i,1)[0];
                 arr.splice(j,0,tmp);
             }
         }
         // 做一个当前函数是否有序的判断
         if(isSort(arr)){
             return arr;
         }
     }
     return arr;
 }

冒泡排序

O(nlogn)的算法

归并排序

优化：在待排区间的长度小于100时，可以用插入排序

 // 自下而上的归并算法，自上而下需要用到递归
 function mergeSort(arr){
     let arrSort = [],n = arr.length，count = 0;
     for(let size = 1; size <= n; size += size){ // size表示当前有序区间的长度
         for(let i = 0; i < n; i += size*2){
             // 将[i...i+size-1]和[i+size...i+size*2-1]的两个区间融合成一个有序的并添加到arrSort后面
             arrSort = arrSort.concat(orderMerge(arr.slice(i,i+size),arr.slice(i+size,((i+size*2) > n? n : (i+size*2)))));
         }
         arr = arrSort.slice(0);
         arrSort.length = 0;
     }
     return {arr,count};
     // orderMerger 函数主要是讲有序的两个表融合成一个有序表
     function orderMerge(arr1,arr2){
         let arr = [];
         let idx1 = 0, idx2 = 0;
         while(idx1 < arr1.length && idx2 < arr2.length){
             if(arr1[idx1] <= arr2[idx2]){
                 arr.push(arr1[idx1++]);
             }else{
                // 当arr1[index1] > arr2[idx2]的时候就是一个逆序对
                 arr.push(arr2[idx2++]);
                 count++;
             }
         }
         if(idx1 === arr1.length){
             arr = arr.concat(arr2.slice(idx2));
         }else{
             arr = arr.concat(arr1.slice(idx1));
         }
         return arr;
     }
 }

快速排序

思想：选择待排序的区间中第一个p数作为参照，大于p的放在p的后面，小于p的放前面。最后将p放在两个区间的中间，递归下去。

缺点:: 1 在排近乎有序的数组的时候，时间复杂度趋近于O(n^2)

2 再相同数值很多的数组中，时间复杂度趋近于O(n^2)

解决方案： 优化缺点1：随机选择参照数p或者待排数组中间的数作为参照数

优化缺点2-1 ：从待排数组两边进行遍历，从左向右遇到>=p的值停顿，在从右向左遇到<=p的值停顿，将两个数交换并i++，j--，知道i == j为止

优化缺点2-2：三路快速排序，有三个数组，一个数组存放小于p的值，一个存放大于p的值，一个存放等于p的值。

 function quickSort(arr){
     // 终止条件：当数组长度小于等于1是返回该数组
     if(arr.length <= 1){
         return arr;
     }
     // 定义leftSort、rightSort存放小于和大于p的数
     let leftSort = [], rightSort =[], midSort = [], odd = 0;
     // 遍历arr，将大于p的放在rightSort中，小于p的放在leftSort中
     //优化缺点1：选择中间的数做参照并把该数从原数组中删除
     let idx = Math.floor(arr.length/2);
     let p = arr.splice(idx,1)[0];
     for(let i = 0; i < arr.length; i++){
         if(arr[i] > p){
             rightSort.push(arr[i]);
         }else if(arr[i] < p){
             leftSort.push(arr[i]);
         }else{
             // 优化缺点2
             if(odd){
                 leftSort.push(arr[i]);
                   odd = 1;
             }else{
                 rightSort.push(arr[i]);
                 odd = 0;
             }
         }
     }
     // 递归leftSort、rightSort
     leftSort = quickSort(leftSort);
     rightSort = quickSort(rightSort);
     // 将leftSort、midSort、rightSort合并成一个数组并返回。
     arr = leftSort.concat(p,rightSort)
     return arr;
 }

 //优化缺点2-2
 function quickSort(arr){
     if(arr.length <= 1){
         return arr;
     }
     let leftSort = [], rightSort =[], midSort = [];
     let idx = Math.floor(arr.length/2);
     let p = arr[idx]; // 可以不用删除了
     for(let i = 0; i < arr.length; i++){
         if(arr[i] > p){
             rightSort.push(arr[i]);
         }else if(arr[i] < p){
             leftSort.push(arr[i]);
         }else{
             midSort.push(arr[i]);
         }
     }
     arr = quickSort(leftSort).concat(midSort,quickSort(rightSort))
     return arr;
 }

扩展

Merge Sort的思路求逆序对的个数

mergeSort第21行

Qiuck Sort求数组中第n大的数

 function theNumberN(arr,n){

     let p,idx,
         leftSort = [],
            midSort = [],
         rightSort = [];
     while(arr.length > 1){
         idx = Math.floor(arr.length/2);
         p = arr[idx];
         for(let i = 0; i < arr.length; i++){
             if(arr[i] < p){
                 leftSort.push(arr[i]);
             }else if(arr[i] > p){
                 rightSort.push(arr[i]);
             }else{
                 midSort.push(arr[i]);
             }
         }
         if(leftSort.length >= n){
             arr = leftSort.slice(0);
         }

         else if(leftSort.length+midSort.length >= n){

             return midSort[0];
         }

         else{

             arr = rightSort.slice(0);
             n = n - leftSort.length - midSort.length;
         }
             leftSort.length = midSort.length = rightSort.length = 0;

     }
     return arr[0];

 }

或者使用递归

 function theNumberN(arr,n){
     if(arr.length <= 1){
         return arr[0];
     }
     // 选一个基点p
     let p,
         leftSort = [],
         midSort = [],
         rightSort = [];
     // 小于p放leftSort，等于p放midSort，大于放rightSort
         p = arr[Math.floor(arr.length/2)];
         for(let i = 0; i < arr.length; i++){
         if(arr[i] < p){
             leftSort.push(arr[i]);
         }else if(arr[i] > p){
             rightSort.push(arr[i]);
         }else{
             midSort.push(arr[i]);
         }
     }
     // 如果leftSort.length>n则抛弃midSort和rightSort再找leftSort中第n大的数
     if(leftSort.length >= n){
         return theNumberN(leftSort,n);
     }
     // 否则判断leftSort.length+midSort.length>n则抛弃leftSort和rightSort，在midSort中找第n-leftSort.length大的数
     else if(leftSort.length+midSort.length >= n){
         // theNumberN(midSort,n - leftSort.length);
         return midSort[0];
     }
     // 否则抛弃leftSort和midSort，在rightSort中找第n-leftSort.length-midSort.length大的数
     else{
         return theNumberN(rightSort,n - leftSort.length - midSort.length);
     }
 }