C++排序算法总结

排序算法复杂度分析

#include <iostream>
#include <vector>

// 冒泡排序
// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
void bubble_sort(int a[], int n) {
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n - i - 1; j++) {
      if (a[j] > a[j + 1]) {
        int tmp = a[j];
        a[j] = a[j + 1];
        a[j + 1] = tmp;
      }
    }
  }
}

// 基于vector实现冒泡排序
void bubble_sort_vec(std::vector<int>& T) {
  for (int i = 0; i < T.size(); i++) {
    for (int j = 0; j < T.size() - i - 1; j++) {
      if (T[j] > T[j + 1]) {
        int tmp = T[j];
        T[j] = T[j + 1];
        T[j + 1] = tmp;
      }
    }
  }
}

// quick sort
// 时间复杂度：O(nlogn)
// 空间复杂度：O(logn)
void quick_sort(int a[], int left, int right) {
  if (left >= right) {
    return;
  }
  int i = left, j = right;
  int base = a[left];
  while (i < j) {
    while (i < j && a[j] >= base) {
      j--;
    }
    if (i < j) {
      a[i++] = a[j];
    }
    while (i < j && a[i] <= base) {
      i++;
    }
    if (i < j) {
      a[j--] = a[i];
    }
  }
  a[i] = base;
  quick_sort(a, left, i - 1);
  quick_sort(a, i + 1, right);
}

// 选择排序
// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
void select_sort(int a[], int n) {
  for (int i = 0; i < n; i++) {
    int min = i;
    for (int j = i + 1; j < n; j++) {
      if (a[j] < a[min]) {
        min = j;
      }
    }
    if (i != min) {
      int tmp = a[i];
      a[i] = a[min];
      a[min] = tmp;
    }
  }
}

// 插入排序
// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
void insert_sort(int a[], int n) {
  for (int i = 1; i < n; i++) {
    int tmp = a[i];
    int j = i - 1;
    while (j >= 0 && a[j] > tmp) {
      a[j + 1] = a[j];
      j--;
    }
    a[j + 1] = tmp;
  }
}

// 二分查找
// 时间复杂度：O(logn)
// 空间复杂度：O(1)
int binary_search(int a[], int n, int key) {
  int left = 0, right = n - 1;
  while (left <= right) {
    int mid = (left + right) / 2;
    if (a[mid] == key) {
      return mid;
    } else if (a[mid] < key) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }
  return -1;
}

// 归并排序
// 时间复杂度：O(nlogn)
// 空间复杂度：O(n)
void merge_sort(int a[], int left, int right) {
  if (left >= right) {
    return;
  }
  int mid = (left + right) / 2;
  merge_sort(a, left, mid);
  merge_sort(a, mid + 1, right);
  int* tmp = new int[right - left + 1];
  int i = left, j = mid + 1, k = 0;
  while (i <= mid && j <= right) {
    if (a[i] < a[j]) {
      tmp[k++] = a[i++];
    } else {
      tmp[k++] = a[j++];
    }
  }
  while (i <= mid) {
    tmp[k++] = a[i++];
  }
  while (j <= right) {
    tmp[k++] = a[j++];
  }
  for (int i = 0; i < k; i++) {
    a[left + i] = tmp[i];
  }
  delete[] tmp;
}

// 调整堆
void adjust_heap(int a[], int i, int n) {
  int tmp = a[i];
  int child = 2 * i + 1;
  while (child < n) {
    if (child + 1 < n && a[child + 1] > a[child]) {
      child++;
    }
    if (tmp > a[child]) {
      break;
    }
    a[i] = a[child];
    i = child;
    child = 2 * i + 1;
  }
  a[i] = tmp;
}

// 堆排序
// 时间复杂度：O(nlogn)
// 空间复杂度：O(1)
void heap_sort(int a[], int n) {
  for (int i = n / 2 - 1; i >= 0; i--) {
    adjust_heap(a, i, n);
  }
  for (int i = n - 1; i > 0; i--) {
    int tmp = a[0];
    a[0] = a[i];
    a[i] = tmp;
    adjust_heap(a, 0, i);
  }
}

// 桶排序
// 时间复杂度：O(n)
// 空间复杂度：O(n)
void bucket_sort(int a[], int n) {
  int max = a[0];
  int min = a[0];
  for (int i = 1; i < n; i++) {
    if (a[i] > max) {
      max = a[i];
    }
    if (a[i] < min) {
      min = a[i];
    }
  }
  int bucket_size = max - min + 1;
  int* bucket = new int[bucket_size];
  for (int i = 0; i < bucket_size; i++) {
    bucket[i] = 0;
  }
  for (int i = 0; i < n; i++) {
    bucket[a[i] - min]++;
  }
  int k = 0;
  for (int i = 0; i < bucket_size; i++) {
    for (int j = 0; j < bucket[i]; j++) {
      a[k++] = i + min;
    }
  }
  delete[] bucket;
}

// shell排序
// 时间复杂度：O(n^1.3)
// 空间复杂度：O(1)
void shell_sort(int a[], int n) {
  int gap = n / 2;
  while (gap > 0) {
    for (int i = gap; i < n; i++) {
      int tmp = a[i];
      int j = i - gap;
      while (j >= 0 && a[j] > tmp) {
        a[j + gap] = a[j];
        j -= gap;
      }
      a[j + gap] = tmp;
    }
    gap /= 2;
  }
}

// 基数排序
// 时间复杂度：O(n*k)
// 空间复杂度：O(n)
void radix_sort(int a[], int n) {
  int max = a[0];
  for (int i = 1; i < n; i++) {
    if (a[i] > max) {
      max = a[i];
    }
  }
  int exp = 1;
  while (max / exp > 0) {
    int* bucket = new int[10];
    for (int i = 0; i < 10; i++) {
      bucket[i] = 0;
    }
    for (int i = 0; i < n; i++) {
      bucket[a[i] / exp % 10]++;
    }
    for (int i = 1; i < 10; i++) {
      bucket[i] += bucket[i - 1];
    }
    int* tmp = new int[n];
    for (int i = n - 1; i >= 0; i--) {
      tmp[--bucket[a[i] / exp % 10]] = a[i];
    }
    for (int i = 0; i < n; i++) {
      a[i] = tmp[i];
    }
    delete[] bucket;
    delete[] tmp;
    exp *= 10;
  }
}

// 计数排序
// 时间复杂度：O(n+k)
// 空间复杂度：O(n+k)
void counting_sort(int a[], int n) {
  int max = a[0];
  for (int i = 1; i < n; i++) {
    if (a[i] > max) {
      max = a[i];
    }
  }
  int* bucket = new int[max + 1];
  for (int i = 0; i <= max; i++) {
    bucket[i] = 0;
  }
  for (int i = 0; i < n; i++) {
    bucket[a[i]]++;
  }
  for (int i = 1; i <= max; i++) {
    bucket[i] += bucket[i - 1];
  }
  int* tmp = new int[n];
  for (int i = n - 1; i >= 0; i--) {
    tmp[--bucket[a[i]]] = a[i];
  }
  for (int i = 0; i < n; i++) {
    a[i] = tmp[i];
  }
  delete[] bucket;
  delete[] tmp;
}

// 打印数组
void print_array(int a[], int n) {
  for (int i = 0; i < n; i++) {
    std::cout << a[i] << " ";
  }
  std::cout << std::endl;
}

int main() {
  int a[] = {101, 202, 31, 14, 85, 56, 27, 18, 99, 10010};
  std::vector<int> b(a, a + sizeof(a) / sizeof(int));
  std::vector<int> arr{104, 1052, 4103, 454, 45, 46, 45447,808, 979445, 144210};
  // bubble_sort(a, 10);
  // radix_sort(a, 10);
  // bucket_sort(a, 10);
  // quick_sort(a, 0, 9);
  // select_sort(a, 10);
  // insert_sort(a, 10);
  // merge_sort(a, 0, 9);
  // heap_sort(a, 10);
  // shell_sort(a, 10);
  // counting_sort(a, 10);
  
  bubble_sort_vec(arr);
  for(auto v : arr) {
    std::cout << v << " ";
  }
  // print_array(a, 10);
  return 0;
}

在所有的排序算法中，除计数排序、桶排序、基数排序为非比较排序，其余的均为比较排序。关于其余相关的详细细节，不做过多介绍。相关的链接赋予下方。
Ljnoit总结：https://blog.csdn.net/Ljnoit/article/details/105593537