排序算法

Posted 2021-03-26 iszhangjin

一、冒泡排序

　　遍历一个数组，如果发现数组中相邻的两个元素不满足要求时，就调整他们的次序，直达最后没有需要调整时说明数组有序。

1. 算法描述
   　　1.1 比较相邻的元素。如果第一个比第二个大，就交换他们的顺序
   　　1.2 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素会是最大的
           1.3 针对所有元素重复上述步骤
           1.4 当一次遍历后，没有出现交换的情况时，说明排序完成；
2. 算法实现
   

   function bubbleSort(arr = []) {
     arr = [].concat(arr);
     let  len = arr.length,
          flags = false;
     for(let i = 0; i < len - 1; i++) {
          for(let j = 0; j < len - 1 - i; j++) {
              if(arr[j] > arr[j+1]) {
                 let temp = arr[j];
                 arr[j] = arr[j+1];
                 arr[j+1] = temp;
                 flags = true;
              }
          }
          if(flags) {
             flags = false;
          } else {
             break;
          }
     }
     return arr;
   }

3. 复杂度分析
   时间复杂度：O(n²); 空间复杂度：这里新建了一个数组（想写纯函数）为O（n），如果不必须的话 是O（1）

二、选择排序

1. 算法描述
   首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序序列中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到未排序序列中没有元素。
2. 算法实现
   

   function selectSort(arr = []) {
      arr = [].concat(arr);
      let len = arr.length,
           minIndex,
           temp;
      for(let i = 0; i < len; i++) {
          minIndex = i;
          for(let j = i + 1; j < len; j++) {
             if(arr[j] < arr[minIndex]) {
                minIndex = j;
             }
          }
          temp = arr[i];
          arr[i] = arr[minIndex];
          arr[minIndex] = temp
      }
      return arr;
   }

    

3. 复杂度分析
   时间复杂度：O（n²）；空间复杂度：与冒泡一致

三、插入排序

1. 算法思想
   将原序列划分为有序序列和无序序列，刚开始时有序序列只包含序列中的第一个元素。后来一次拿无序序列中的首个元素，按照从后往前的顺序与有序序列中的元素做比较，并移动有序序列元素位置（后移一位），知道找到最终位置
2. 算法实现
   

   function insertSort(arr = []) {
      arr = [].concat(arr);
      let len = arr.length,
           preIndex, current;
      for(let i = 1; i < len; i++) {
         preIndex = i - 1;
         current = arr[i];
         while(preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
         }
         arr[preIndex + 1] = current;
      }
      return arr;
   } 

    

3. 复杂度分析
   时间复杂度：O（n²），当数组有序时为O（n）。空间复杂度O（1）

四、希尔排序

1. 算法描述，插入排序的改进版，会优先比较距离较远的元素
2. 算法实现
   

   function shellSort(arr = []) {
      let len = arr.length;
      for(let gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
          for(let i = gap; i < len; i++) {
              let j = i;
              let current = arr[i];
              while(j - gap >= 0 && current < arr[j - gap]) {
                 arr[j] = arr[j - gap];
                 j = j - gap;
              }
              arr[j] = current;
          }
      }
      return arr;
   }

    

五、归并排序

1. 算法描述
   采用分治法，把长度为n的输入序列分为两个长度为n/2的子序列，对两个子序列分别采用归并排序，将两个排序好的子序列合并成最终的排序序列
2. 算法实现
   

   function mergeSort(arr = []) {
      let len = arr.length;
      if(len < 2) {
          return arr;
      }
      let middle = Math.floor(len / 2),
           left = arr.slice(0, middle),
           right = arr.slice(middle);
      return merge(mergeSort(left), mergeSort(right))
   }
   
   function merge(left, right) {
     let result = [];
   
     while(left.length > 0 && right.length > 0) {
        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.length);
     }
     
     return result;
   }

    

六、快速排序

function quickSort(arr, left, right) {
  let len = arr.length,
       partitionIndex,
       left = typeof left !== ‘number‘ ? 0 : left,
       right = typeof right !== ‘number‘ > len - 1 : right;
  if(left < right) {
     partitionIndex = partition(arr, left, right);
     quickSort(arr, left, partitionIndex - 1);
     quickSort(arr, partitionIndex + 1, right);
  }
  return arr;
}

function partition(arr, left, right) {
   let pivot = left,
       index = pivot + 1;
   for(let i = index; i <= right; i++) {
        if(arr[i] < arr[pivot]) {
             swap(arr, i , index);
             index++;
        }
   }
   swap(arr, pivot, index - 1);
   return index - 1;
}

function swap(arr, i, j) {
  let temp = arr[i];
  arr[i]  = arr[j];
  arr[j] = temp;  
}