初级算法 - 快速排序

效率高于冒泡排序和选择排序。

初始数组：{ 27,1,11,200,31,4,58,78,23,47,9,10000};

第一轮QuickSort的排序见，

27,1,11,200,31,4,58,78,23,47,9,10000

9,1,11,200,31,4,58,78,23,47,27,10000

9,1,11,27,31,4,58,78,23,47,200,10000

9,1,11,23,31,4,58,78,27,47,200,10000

9,1,11,23,27,4,58,78,31,47,200,10000

9,1,11,23,4,27,58,78,31,47,200,10000

中间值是27，可以看出27左边的数值都比它小，右边都比它大。

然后再此分组，简称"分而治之"

详细代码：

#include <iostream>

void swap(int* a, int* b);
void QuickSort(int* num, int low, int high);

int main()
{
    int a[] = { 27,1,11,200,31,4,58,78,23,47,9,10000};
    int low = 0, high = sizeof(a)/sizeof(int);
    
    QuickSort(a, low, high-1);

    for (int i = 0; i < high; i++)
    {
        std::cout << a[i] << " ";
    }

    return 0;
}


void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void QuickSort(int* num, int low, int high)
{
    int i = low,j = high;
    int* b = num;
    int key = b[low];

    while (low >= high)
    {
        return;
    }

    while (low < high)
    {
        while (low < high && key <= b[high])
        {
            high--;
        }
        if (key > b[high])
        {
            swap(&b[low], &b[high]);
            low++;
        }
        while (low < high && key > b[low])
        {
            low++;
        }
        if (key < b[low])
        {
            swap(&b[low], &b[high]);
            high--;
        }    

        for (int k = 0; k < 12; k++)
        {
            std::cout << b[k] << " ";
        }
        std::cout << std::endl;
    }
    QuickSort(b, i, low - 1);
    QuickSort(b, low + 1, j);
}

 

---

 

C++

#include <iostream>  
#include <vector>  
#include <algorithm>

void QuickSort(std::vector<int>& num, int low, int high);

int main()
{
  std::vector<int> a = { 27,1,11,200,31,24,58,78,23,47,9,10000 };
  int size = a.size();

  QuickSort(a, 0, size - 1);

  for (int i = 0; i < size; i++)
  {
    std::cout << a[i] << " ";
  }

  return 0;
}

void QuickSort(std::vector<int>& num, int low, int high) {
  if (low >= high) {
    return;
  }

  int i = low, j = high;
  int key = num[low];

  while (i <= j) {
    while (i <= j && num[i] <= key) {
      i++;
    }
    while (i <= j && num[j] > key) {
      j--;
    }
    if (i < j) {
      std::swap(num[i], num[j]);
    }
  }
  std::swap(num[low], num[j]);

  QuickSort(num, low, j - 1);
  QuickSort(num, j + 1, high);
}

 归并排序：

#include <iostream>
#include <vector>

using namespace std;

class Solution {
 public:
  void merge(vector<int>& nums, int left, int mid, int right) {
    int size1 = mid - left + 1;
    int size2 = right - mid;
    vector<int> array_1(size1), array_2(size2);

    for (int i = 0; i < size1; i++) {
      array_1[i] = nums[left + i];
    }
    for (int j = 0; j < size2; j++) {
      array_2[j] = nums[mid + 1 + j];
    }

    int i = 0, j = 0, k = left;
    while (i < size1 && j < size2) {
      if (array_1[i] <= array_2[j]) {
        nums[k++] = array_1[i++];
      } else {
        nums[k++] = array_2[j++];
      }
    }

    while (i < size1) {
      nums[k++] = array_1[i++];
    }
    while (j < size2) {
      nums[k++] = array_2[j++];
    }
  }

  void merge_sort(vector<int>& nums, int L, int R) {
    // 或者 L >= R 直接返回
    // 因为如果 L 等于 R，则意味着区间内只有一个元素，它已经是排序好的，无需进行合并操作
    if (L < R) {
      int M = L + (R - L) / 2;  // 防止整数溢出
      merge_sort(nums, L, M);
      merge_sort(nums, M + 1, R);
      merge(nums, L, M, R);  // 注意这里的mid是M，不是M+1
    }
  }

  vector<int> sortArray(vector<int>& nums) {
    merge_sort(nums, 0, nums.size() - 1);
    return nums;
  }
};