经典排序算法

稳定排序

（一）冒泡排序（Bubble Sort）

• 核心思想： 比较相邻的两个数，左边元素大于右边时，交换两个数的位置，反之，保持原样，适用于排序小列表。
• 时间复杂度： O(n^2)
• 空间复杂度： O(1)
• 算法描述： 这是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

private static void sort(int[] array) {
   
// 最后一次交换的下标
    int lastSwapIndex = 0;
// 如果后面的部分元素是有序的，但是还会继续比较，定义一个无序数组的边界，每次比较到此为止
    int arrBoundary = array.length - 1;

        for (int i = 0; i < array.length - 1; i++) {
            // 增加判断位，有序标记，每一轮的初始是true
            boolean flag = true;
            for (int j = 0; j < arrBoundary; j++) {
                // 找最小数，如果前一位比后一位大，则交换位置
                if (array[j] > array[j + 1]) {
                //可以用异或的操作交换两个元素，不需要创建第三个变量，减少内存开销。
                   array[j + 1] ^= array[j];
   				   array[j] ^= array[j + 1];
    			   array[j + 1] ^= array[j];
                    // 有元素交换，所以不是有序，标记变为false
                    flag = false;
                    // 最后一次交换元素的位置
                    lastSwapIndex = j;
                }             
            }
            // 把最后一次交换元素的位置赋值给无序数组的边界
            arrBoundary = lastSwapIndex;
            // 说明上面内层for循环中，没有交换任何元素，直接跳出外层循环
            if (flag) {
                break;
            }
        }
    }

（二）插入排序（Insertion Sort）

• 核心思想： 插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
• 时间复杂度： O(n^2)
• 空间复杂度： O(1)
• 算法分析： 插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

let temp;
let arrays = [1, 5, 3, 2, 6, 9, 8, 4, 1, 2, 3, 6, 5, 4, 7, 8, 5, 1, 2, 3, 6, 4, 8]
let str = ''
for (let i = 1; i < 10000; i++) {
  arrays.push(Math.floor(Math.random() * 10000))
}
console.log(new Date().getTime());
//外层循环控制需要排序的趟数(从1开始因为将第0位看成了有序数据)
for (let i = 1; i < arrays.length; i++) {
  temp = arrays[i];
  //如果前一位(已排序的数据)比当前数据要大，那么就进入循环比较[参考第二趟排序]
  while (i >= 1 && arrays[i - 1] > temp) {
    //往后退一个位置，让当前数据与之前前位进行比较
    arrays[i] = arrays[i - 1];
    //不断往前，直到退出循环
    i--;
  }
  //退出了循环说明找到了合适的位置了，将当前数据插入合适的位置中
  arrays[i] = temp;
}
console.log(new Date().getTime());

void InsertSortArray() {
  for (int i = 1; i < n; i++) //循环从第二个数组元素开始，因为arr[0]作为最初已排序部分 
  {
    int temp = arr[i]; //temp标记为未排序第一个元素 
    int j = i - 1;
    while (j >= 0 && arr[j] > temp) /*将temp与已排序元素从小到大比较，寻找temp应插入的位置*/ {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = temp;
  }
}

（三）归并排序（Merge Sort）

• 核心思想：

1. 把长度为n的输入序列分成两个长度为n/2的子序列；
2. 对这两个子序列分别采用归并排序；
3. 将两个排序好的子序列合并成一个最终的排序序列。

• 时间复杂度： O(nlog2n)
• 空间复杂度： O(1)
• 算法分析： 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。它是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。

void MergeSort(int low, int high) {
  if (low >= high) return; //每个子列表中剩下一个元素时停止 
  else int mid = (low + high) / 2; /*将列表划分成相等的两个子列表,若有奇数个元素，则在左边子列表大于右侧子列表*/
  MergeSort(low, mid); //子列表进一步划分 
  MergeSort(mid + 1, high);
  int[] B = new int[high - low + 1]; //新建一个数组，用于存放归并的元素 
  for (int i = low, j = mid + 1, k = low; i <= mid && j <= high; k++) /*两个子列表进行排序归并，直到两个子列表中的一个结束*/ {
    if (arr[i] <= arr[j];) {
      B[k] = arr[i];
      I++;
    } else {
      B[k] = arr[j];
      j++;
    }
  }
  for (; j <= high; j++, k++) //如果第二个子列表中仍然有元素，则追加到新列表 
    B[k] = arr[j];
  for (; i <= mid; i++, k++) //如果在第一个子列表中仍然有元素，则追加到新列表中 
    B[k] = arr[i];
  for (int z = 0; z < high - low + 1; z++) //将排序的数组B的 所有元素复制到原始数组arr中 
    arr[z] = B[z];
}

不稳定排序

（一）希尔（壳）排序（Shell Sort）

• 核心思想： 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1。
2. 按增量序列个数k，对序列进行k 趟排序。
3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

• 时间复杂度： O(n^2)
• 空间复杂度： O(1)
• 算法分析： 是第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

void ShellSortArray() {
  for (int incr = 3; incr < 0; incr--) //增量递减，以增量3，2，1为例 
  {
    for (int L = 0; L < (n - 1) / incr; L++) //重复分成的每个子列表 
    {
      for (int i = L + incr; i < n; i += incr) //对每个子列表应用插入排序 
      {
        int temp = arr[i];
        int j = i - incr;
        while (j >= 0 && arr[j] > temp) {
          arr[j + incr] = arr[j];
          j -= incr;
        }
        arr[j + incr] = temp;
      }
    }
  }
}

（二）选择排序（Selection Sort）

• 核心思想： 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
• 时间复杂度： O(n^2)
• 空间复杂度： O(1)
• 算法分析： 表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法。

void SelectSortArray() {
  int min_index;
  for (int i = 0; i < n - 1; i++) {
    min_index = i;
    for (int j = i + 1; j < n; j++) //每次扫描选择最小项 
      if (arr[j] < arr[min_index]) min_index = j;
    if (min_index != i) //找到最小项交换，即将这一项移到列表中的正确位置 
    {
      arr[min_index] ^= arr[i];
      arr[i] ^= arr[min_index];
      arr[min_index] ^= arr[i];
    }
  }
}

（三）堆排序（Heap Sort）

• 核心思想： 堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
• 时间复杂度： O(nlog2n)
• 空间复杂度： O(1)

var len;    // 因为声明的多个函数都需要数据长度，所以把len设置成为全局变量
 
function buildMaxHeap(arr) {   // 建立大顶堆
    len = arr.length;
    for(var i = Math.floor(len/2); i >= 0; i--) {
        heapify(arr, i);
    }
}
 
function heapify(arr, i) {     // 堆调整
    var left = 2 * i + 1,
        right = 2 * i + 2,
        largest = i;
 
    if(left < len && arr[left] > arr[largest]) {
        largest = left;
    }
 
    if(right < len && arr[right] > arr[largest]) {
        largest = right;
    }
 
    if(largest != i) {
        swap(arr, i, largest);
        heapify(arr, largest);
    }
}
 
function swap(arr, i, j) {
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}
 
function heapSort(arr) {
    buildMaxHeap(arr);
 
    for(var i = arr.length - 1; i > 0; i--) {
        swap(arr, 0, i);
        len--;
        heapify(arr, 0);
    }
    return arr;
}

（四）快速排序（Quick Sort）

• 核心思想： 通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
• 时间复杂度： O(nlog2n)
• 空间复杂度： O(1)

int Partition(int[] arr, int low, int high) {
  int pivot = arr[low]; //采用子序列的第一个元素作为枢纽元素 
  while (low < high) {
    //从后往前栽后半部分中寻找第一个小于枢纽元素的元素 
    while (low < high && arr[high] >= pivot) {
      --high;
    }
    //将这个比枢纽元素小的元素交换到前半部分 
    swap(arr[low], arr[high]);
    //从前往后在前半部分中寻找第一个大于枢纽元素的元素 
    while (low < high && arr[low] <= pivot) {
      ++low;
    }
    swap(arr[low], arr[high]); //将这个枢纽元素大的元素交换到后半部分 
  }
  return low; //返回枢纽元素所在的位置 
}
void QuickSort(int[] a, int low, int high) {
  if (low < high) {
    int n = Partition(a, low, high);
    QuickSort(a, low, n);
    QuickSort(a, n + 1, high);
  }
}