八大排序c++可运行精简版，一目了然

来源：互联网发布：的士计价器软件编辑：程序博客网时间：2024/05/06 03:40

http://blog.csdn.net/shen823797837/article/details/11810293

[cpp] view plaincopy
#include <iostream>  
using namespace std;  
  
// 插入排序开始=====================  
void insert_sort(int a[], int n)  
{  
  for (int cur = 1; cur < n; ++cur)  
  {  
    int j = cur - 1;  
    int t = a[cur];  
    while (j >= 0)  
    {  
      if (a[j] > t)  
        a[j+1] = a[j];  
      else  
        break;  
      --j;  
    }  
    a[j+1] = t;  
  }  
}  
// 插入排序结束=====================  
  
  
// 选择排序开始=====================  
void select_sort(int a[], int n)  
{  
  for (int i = 0; i < n - 1; ++i)  
  {  
    int k = i;  
    for (int j = i + 1; j < n; ++j)  
      if (a[j] < a[k])  
        k = j;  
    swap(a[i], a[k]);  
  }  
}  
// 选择排序结束=====================  
  
  
// 冒泡排序开始=====================  
void buble_sort(int a[], int n)  
{  
  for (int k = 1; k <= n - 1; ++k)  
  {  
    int noswap = 1; //表示这一次没有交换  
    for (int j = n - 1; j >= k; --j)  
      if (a[j] < a[j-1])  
      {  
        swap(a[j], a[j-1]);  
        noswap = 0;  
      }  
    if (noswap) break;  
  }  
}  
// 冒泡排序结束=====================  
  
  
// 快速排序开始=====================  
int quick_sort_partion(int a[], int p, int q)  
{  
  int i = p - 1;  
  for (int j = p; j <= q - 1; ++j)  
  {  
    if (a[j] < a[q])  
      swap(a[j], a[++i]);  
  }  
  swap(a[++i], a[q]);  
  return i;  
}  
void quick_sort_helper(int a[], int b, int e)  
{  
  if (b < e)  
  {  
    int mid = quick_sort_partion(a, b, e);  
    quick_sort_helper(a, b, mid - 1);  
    quick_sort_helper(a, mid + 1, e);  
  }  
}  
void quick_sort(int a[], int n)  
{  
  quick_sort_helper(a, 0, n-1);  
}  
// 快速排序结束=====================  
  
  
// 归并排序开始=====================  
void merge_sort_helper(int a[], int copy[], int b, int e)  
{  
  if (b < e)  
  {  
    int mid = (e-b) / 2 + b;  
    merge_sort_helper(copy, a, b, mid);  
    merge_sort_helper(copy, a, mid + 1, e);  
  
    int i = b, j = mid + 1, k = b;  
    while (i <= mid && j <= e)  
    {  
      a[k++] = (copy[i] < copy[j] ? copy[i++] : copy[j++]);  
    }  
    while (i <= mid)  
      a[k++] = copy[i++];  
    while (j <= e)  
      a[k++] = copy[j++];  
  }  
}  
void merge_sort(int a[], int n)  
{  
  int *copy = new int[n];  
  memcpy(copy, a, sizeof(a[0])*n);  
  merge_sort_helper(a, copy, 0, n-1);  
  delete[] copy;  
}  
// 归并排序结束=====================  
  
  
// 堆排序开始=======================  
void heap_sort_adjust(int a[], int n, int i)  
{  
  
  if (i <= n/2 - 1) //判断是否是叶子结点  
  {  
    int left = 2*i+1;  
    int right = 2*i+2;  
    int maxIndex = i;  
    if (a[left] > a[maxIndex])  
      maxIndex = left;  
    if (right < n && a[right] > a[maxIndex])  
      maxIndex = right;  
    swap(a[i], a[maxIndex]);  
    if (i != maxIndex) //一定要判断，否则死循环  
      heap_sort_adjust(a, n, maxIndex);  
  }  
}  
void heap_sort_build(int a[], int n)  
{  
  for (int i = n/2 -1; i >= 0; --i)  
    heap_sort_adjust(a, n, i);  
  
}  
void heap_sort(int a[], int n)  
{  
  heap_sort_build(a, n);  
  for (int i = n-1; i >= 1; --i)  
  {  
    swap(a[i], a[0]);  
    heap_sort_build(a, i);  
  }  
}  
// 堆排序结束=======================  
  
  
// 希尔排序开始=====================  
void shell_sort(int a[], int n)  
{  
  int d[3] = {5, 3, 1};  
  for (int k = 0; k < 3; ++k)  
  {  
    for (int cur = d[k]; cur < n; cur += d[k])  
    {  
      int j = cur - d[k];  
      int t = a[min(cur, n-1)];  
      while (j >= 0)  
      {  
        if (a[j] > t)  
          a[min(j+d[k], n-1)] = a[j];  
        else  
          break;  
        j -= d[k];  
      }  
      a[min(j+d[k], n-1)] = t;  
    }  
  }  
}  
// 希尔排序结束=====================  
  
  
// 基数排序开始=====================  
//L表示关键码的个数  
void radix_sort(int a[], int n, int L)  
{  
  int *bucket = new int[n];  
  int count[10];  
  int power = 1;  
  
  for (int k = 1; k <= L; ++k)  
  {  
    memset(count, 0, sizeof(count[0]) * n);  
    //统计每个桶的右边界  
    for (int i = 0; i < n; ++i) ++count[(a[i]/power)%10];  
    for (int i = 1; i < 10; ++i) count[i] += count[i-1];  
    //装桶,这里从后往前扫描是因为边界值是从右往左递减的  
    for (int i = n-1; i >= 0; --i) bucket[--count[(a[i]/power)%10]] = a[i];  
    //收集  
    memcpy(a, bucket, sizeof(a[0]) * n);  
    power *= 10;  
  }  
  delete bucket;  
}  
// 基数排序结束=====================  

[cpp] view plaincopy
int main()  
{  
  int a[10]={100,19,222,10,37,83,36,344,576,82};  
  radix_sort(a, 10, 3);  
  for (int i = 0; i < 10; ++i)  
    cout << a[i] << " ";  
  cout << endl;  
  return 0;  
}  

最后，贴出几大排序的平均时间复杂度和最坏时间复杂度，以供参考

关于排序的稳定性

稳定的排序有

插入排序：（每次插入都是从后往前，两个数一样的话不会交换位置）

冒泡排序：（每次冒上去的都是最小的，两个数相同不会交换）

归并排序：（如果两个相等的数在同一个区间，显然后面的数不会跑到前面去，如果在不同的区间，后半个区间在归并后显然也是排在后面，可对照上面的代码）

基数排序：（两个数相同，如果从左到右扫描，那么前面的数肯定先被扔进桶内，如果从右往左扫描，那么先将右边的数扔到桶的后面，上面排序过程即是如此）

如果记不住的话，那么鬼插鸡毛，还记得住啊？记住，鬼插鸡毛很稳定哦，其他的都不稳定

鬼：归并排序，插：插入排序，鸡：基数排序，毛：冒泡排序

来，和我一起读，鬼插鸡毛很稳定，鬼插鸡毛很稳定，鬼插鸡毛很稳定……读个99遍

关于时间复杂度，除了快速排序，其他排序的最低时间复杂度和最坏时间复杂度相同，因为逆序的数组每次划分都需要O(i)(i = n, n-1,...)的时间，所以快速排序最坏为O(n^2)

好了，就到这里吧，看不懂的留言，楼主保证秒回~