常用排序算法记录（C++实现）

排序过程中，对尚未确定最终位置的元素进行一遍处理，叫做“一趟”

内部排序的比较

插入排序

思想： 如果自己前面的元素比自己大，那么开始比较更前面的元素，放在合适的位置。

void insertSort(int a[],int n){

  int i, j;
  for(i = 1; i < n; ++i){
    if(a[i] < a[i - 1]){
      int temp = a[i];
      // 依次查看前面是不是还有比自己大的元素
      for(j = i - 1; j >= 0 && a[j] > temp; --j){
        a[j + 1] = a[j];
      } // for
      a[j + 1] = temp;
    } // if
  } // for

}

void insertBinarySort(int a[],int n){

  int i, j;
  for(i = 1; i < n; ++i){
    if(a[i] < a[i - 1]){
      int temp = i;
      int low = 0;
      int high = i - 1;

      // 二分查找
      while(low <= high){
        int mid = (high - low) / 2 + low;
        // 为了保证插入排序稳定性,在相等时候low = mid + 1
        if(a[mid] == temp || a[mid] < temp){
          low = mid + 1;
        }else{
          high = mid - 1;
        } // else
      } // while

      for(j = i - 1; j >= low; --j){
        a[j + 1] = a[j];
      }
      a[low] = temp;
    }
  }

}

希尔排序

思想： 设定间隔d，将间隔为d的元素分为一小组，然后每次进行组内排序，并且递减d的值

冒泡排序

思想： 依次比较相邻的两个元素，如果逆序，则将他们交换交换

快速排序

思想： 采用“分治”的策略，选定一个元素为枢轴，然后所有比枢轴大的在右边，比枢轴小的在左边。

注：408原题中说，对所有尚未确定最终位置的所有元素进行一遍处理称为“一趟”排序，因此一次“划分”一趟排序。一次划分可以确定一个元素的最终位置，而一趟排序也许可以确定多个元素的最终位置。

#include <cstdio>
#include <algorithm>

int a[10];

using namespace std;

int getMid(int start, int end){

  int mid = start + (end - start) / 2;
  int Sum = a[start] + a[mid] + a[end];
  int Max = max(max(a[start], a[mid]), a[end - 1]);
  int Min = min(min(a[start], a[mid]), a[end - 1]);
  int Mid = Sum - Max - Min;
  if(Mid == a[start])
    return start;
  else if(Mid == a[mid])
    return mid;
  else
    return end - 1;

}

int partition(int start, int end){

  int pos = getMid(start, end);

  int key = a[pos];
  swap(a[pos], a[end - 1]);
  int i = start, j = end - 1;

  while(i < j){
    // 两个指针轮流遍历
    for(; i < j; ++i){
      if(a[i] > key){
        a[j] = a[i];
        break;
      } // if
    } // for

    for(; i < j; --j){
      if(a[j] < key){
        a[i] = a[j];
        break;
      } // if
    } // for
  } // while

  a[i] = key;

  return i;

}

void quickSort(int start, int end){

  if(start + 1 < end){
    int pos = partition(start, end);
    quickSort(start, pos);
    quickSort(pos + 1, end);
  }

}

int main(){

  int n;
  scanf("%d", &n);
  for(int i = 0; i < n; ++i)
    scanf("%d", a + i);
  quickSort(0, n);
  for(int i = 0; i < n; ++i)
    printf("%d%c", a[i], " \n"[i == n - 1]);
  return 0;

}

简单选择排序

思想： 每次找出待排序元素中最小的一个，与第一个交换

void selectSort(int a[], int n){

  for(int i = 0; i < n - 1; ++i){
    int min = i;
    for(int j = i + 1; j < n; ++j){
      if(a[j] < a[min]){
        min = j;
      }
      if(min != i){
        swap(a[i], a[min]);
      }
    } // for
  }

}

堆排序

堆的数组形式即是该二叉树的 $bfs$ 序列

建堆

依次取数组 $⌊ n / 2 ⌋$ （n为数组元素个数）处及之前的元素，检查其是否满足堆的要求。如果不满足，将它和更符合要求的子结点互换，不断调整。

$⌊ n / 2 ⌋$ （n为数组元素个数）处及之前的元素在树上表现为非叶子结点，越靠右下的非叶子结点越先调整。

排序

思想： 先建立堆，然后取堆顶元素与最后一个待排序元素进行交换，再调整堆，重复此过程，直到进行完 $n - 1$ 趟停止（相当于不断从优先队列中取元素）

时间复杂度： $O(n) + O(n \log_{2} n)$

空间复杂度： $O(1)$

是不稳定排序

归并排序

思想： 采用“分治的方法”，将待排序数组细分成各个只有两个元素的数组，然后不断进行有序合并以完成排序

公式：

对于2路归并排序中，待排序元素为 $n$ 个，则需要进行 $⌈ \log_{2} n ⌉$ 趟归并排序

对于 $N$ 个元素进行 $k$ 路归并排序时，排序的趟数 $m$ 满足 $k^{m} = N$ ，从而 $m = \log_{k} N$ ，又因为 $m$ 是整数，所以 $m = ⌈ \log_{k} N ⌉$

void myMerge(int a[], int left, int right){

  int mid = left + (right - left) / 2;
  int nl = mid - left, nr = right - mid;
  int l[nl], r[nr];
  for(int i = 0; i < nl; ++i)
    l[i] = a[left + i];
  for(int i = 0; i < nr; ++i)
    r[i] = a[mid + i];

  int k = left, i = 0, j = 0;
  while(i < nl && j < nr && k < right){
    if(l[i] <= r[j]){
      a[k] = l[i];
      ++i, ++k;
    }else{
      a[k] = r[j];
      ++j, ++k;
    } // else
  } // while

  while(i < nl && k < right){
    a[k] = l[i];
    (void) (++i), ++k;
  } // while
  while(j < nr && k < right){
    a[k] = r[j];
    (void) (++j), ++k;
  } // while

}

void mergeSort(int *a, int left, int right){

  if(left + 1 < right){
    int mid = left + (right - left) / 2;
    mergeSort(a, left, mid);
    mergeSort(a, mid, right);
    myMerge(a, left, right);
  }
}