排序算法

选择排序(简单选择排序)

主要思想：

1. 假设smallest=0最小，遍历i+1到size()-1, 如果发现有比i更小的,smallest更新记录
2. 每次都要swap
   不稳定，若一次j循环中，遇到2两次，2’与2‘’都为最小，那么根据动画所显示的，先标记2‘准备swap(array, i,2’)，但后面又标记2’‘，最终swap(array, i,2’‘), 2’与2’‘的相对位置发生了变化，不稳定。
   

交换排序(冒泡排序)

主要思路：
稳定的
相邻两两交换；

交换排序(快速排序)

1. 选定Pivot中心轴(任意的，程序默认选arry[0])
2. 一个L左下标，一个R右下标
3. L,left左下标不停地从左往右移动，扫描每个数字，一旦发现比中心轴pivot大的数字，那么就把该数字放到中心轴的右边去
4. 同理right右下标不停地从右往左移动，扫描每个数字，一旦发现比中心轴pivot小的数字，那么就把该数字放到中心轴的左边去，程序一开始从右下标访问，出现这种情况，L的指向R指向的元素(arr[L]=arr[R]，会担心原来这个地方的L元素岂不是被覆盖了，不是这个位置上是pivot被tmp保存)
   (3与4的写法是对称的，按照4.的写法来写3.就可，因为4.写在前面)
5. 最终left和right会在某个位置重合，重合就把中心轴数字pivot放在这个位置
6. (左右子序递归)这样得到了Pivot中心轴左右两个子序列，分别对左右子序列重复前三步操作
   直到长度为1的时候便完成了快速排序
   参考

#include <vector>
using namespace std;
// 快速排序
void Quicksort(vector<int> &arry, int L, int R)
{
  if (L >= R)
    return;
  int left = L, right = R;
  // 以pivot作为中轴
  int pivot = arry[left];

  while (left < right)
  {
    // 1.1右指针指向的值大于=pivot, right--
    while (left < right && arry[right] >= pivot)
    {
      right--;
    }
    // 1.2右指针指向的值小于pivot, 该值放到left指针处
    // 先从右边扫描，然后发现小于pivot交换值，顺其自然
    if (left < right)
    {
      arry[left] = arry[right];
    }

    // 2.1左指针指向的值小于=pivot, left++
    while (left < right && arry[left] <= pivot)
    {
      left++;
    }
    // 2.2左指针指向的值大于pivot, 该值放到right指针处
    if (left < right)
    {
      arry[right] = arry[left];
    }

    // L和R会在序列的某个位置相遇：重合，再把pivot的值放在重合的位置
    if (left >= right)
    {
      arry[left] = pivot;
    }
  }
  // 经过上面一个快排，pivot左边的子序列<=pivot, pivot右边的子序列>=pivot
  // 至于左右子序列，可能现在是无序的

  Quicksort(arry, L, right - 1); // 此时right=pivot-> [0, pivot-1] 中轴左边
  Quicksort(arry, right + 1, R); // [pivot+1, R] 中轴右边
}

int main()
{

  vector<int> arr = {5, 2, 3, 4, 6};
  Quicksort(arr, 0, arr.size() - 1);

  return 0;
}

归并排序

参考图解算法
参考灯神

• 归并：
  把两个有序的子序列进行合并，记住子数组1和子数组2是有序的
  但是因为我们起始的数组并不是有序的，所以一开始我们就是需要将左右的子序列进行分治：
• 分治：
  在我们的归并排序中，首先把数组不断分割直到长度为1，这样每个数字都是有序的，这样每个数字就可以两两归并了，直到成为一个数组
  

归并的过程

1. 创建左右两个left right数组
   

// 归并
void merge(vector<int> &arr, int L, int M, int R)
{
  int LEFT_SIZE = M - L;      // 左边子串的长度
  int RIGHT_SIZE = R - M + 1; // 右边子串的长度
  int left[LEFT_SIZE];        // 需要新开辟数组空间
  int right[RIGHT_SIZE];

  int i, j, k;

  // 1.Fill in the left sub array 把数组arr的数分别填到左右子串
  for (i = L; i < M; i++)
  {
    left[i - L] = arr[i];
  }
  // 1.Fill in the right sub array 把数组arr的数分别填到左右子串
  for (j = M; i <= R; i++)
  {
    right[i - M] = arr[i];
  }
}

2. 左右两个left right数组进行合并
   

// 2. 左右两个left right数组进行合并
  i = 0;
  j = 0;
  k = L; // 定义指向左右子串以及要归并到的大数组的指针

  // 当左右指针不越界时
  while (i < LEFT_SIZE && j < RIGHT_SIZE)
  {
    // 因左边子串指针指向的元素小于右边的指针指向的
    // 左边的元素填到大数组
    // 左边指针前进，大数组指针前进
    if (left[i] < right[j])
    {
      // 可以说是对arr[]中的值全都重新覆盖
      arr[k] = left[i];
      i++;
      k++;
    }
    // 若右边子串指针指向的元素更小
    // 执行相同操作
    else
    {
      arr[k] = right[j];
      j++;
      k++;
    }

分治的过程

那如果是左右两个无序的子串呢？，因此用归并前先要保证左右子串有序，需要用到分治：先砍成一个个数字，这不就是有序子串了吗，然后就可以调用归并了merge()

// 分治
void mergeSort(vector<int> &arr, int L, int R)
{
  // base case:分治到不能再分
  if (L == R)
  {
    return;
  }

  // 首先把这个长的数组，砍成两半
  int M = (L + R) / 2;
  // 二分分治
  // 继续把左边这一半分治
  mergeSort(arr, L, M);
  // 继续把右边这一半分治
  mergeSort(arr, M + 1, R);

  // 把左右有序子串，归并
  merge(arr, L, M + 1, R); // 这里的M要和merge()中的M对应，merge()函数中M是上取整,所以这里M+1
}

整体代码如下：

#include <vector>
#include <iostream>

using namespace std;
// 归并排序

// 归并
void merge(vector<int> &arr, int L, int M, int R)
{
  int LEFT_SIZE = M - L;      // 左边子串的长度
  int RIGHT_SIZE = R - M + 1; // 右边子串的长度
  int left[LEFT_SIZE];        // 需要新开辟数组空间
  int right[RIGHT_SIZE];

  int i, j, k;

  // 1.Fill in the left sub array 把数组arr的数分别填到左右子串
  for (i = L; i < M; i++)
  {
    left[i - L] = arr[i];
  }
  // 1.Fill in the right sub array 把数组arr的数分别填到左右子串
  for (j = M; i <= R; i++)
  {
    right[i - M] = arr[i];
  }

  // 2. 左右两个left right数组进行合并
  i = 0;
  j = 0;
  k = L; // 定义指向左右子串以及要归并到的大数组的指针

  // 当左右指针不越界时
  while (i < LEFT_SIZE && j < RIGHT_SIZE)
  {
    // 因左边子串指针指向的元素小于右边的指针指向的
    // 左边的元素填到大数组
    // 左边指针前进，大数组指针前进
    if (left[i] < right[j])
    {
      // 可以说是对arr[]中的值全都重新覆盖
      arr[k] = left[i];
      i++;
      k++;
    }
    // 若右边子串指针指向的元素更小
    // 执行相同操作
    else
    {
      arr[k] = right[j];
      j++;
      k++;
    }
  }

  // 经过上一个循环，左右子串有一方指针先到达数组尾哨兵处，另一边的数组直接添加到大数组末尾
  // 若j先到达尾哨兵
  while (i < LEFT_SIZE)
  {
    arr[k] = left[i];
    i++;
    k++;
  }

  // 若i先到达尾哨兵
  while (j < LEFT_SIZE)
  {
    arr[k] = right[j];
    j++;
    k++;
  }
}

// 分治
void mergeSort(vector<int> &arr, int L, int R)
{
  // base case:分治到不能再分
  if (L == R)
  {
    return;
  }

  // 首先把这个长的数组，砍成两半
  int M = (L + R) / 2;
  // 二分分治
  // 继续把左边这一半分治
  mergeSort(arr, L, M);
  // 继续把右边这一半分治
  mergeSort(arr, M + 1, R);

  // 把左右有序子串，归并
  merge(arr, L, M + 1, R); // 这里的M要和merge()中的M对应，merge()函数中M是上取整,所以这里+1
}

int main()
{

  // 验证归并
  /*
  vector<int> arr = {2, 8, 9, 10, 4, 5, 6, 7};
  int L = 0;
  int R = 7;
  int M = 4; // 上取整
  merge(arr, L, M, R);
  */

  // 验证归并排序：左右两个子串不是有序，先分治
  vector<int> arr = {2, 9, 8, 10, 4, 6, 5, 7};
  int L = 0;
  int R = 7;
  int M = 4; // 上取整
  mergeSort(arr, L, R);

  return 0;
}

函数中分治和归并的递归调用：递归树如下所示