十大排序算法(原理及代码实现细节)

本文参考一些书籍啊哈算法，数据结构与算法(清华大学)，以及一些网上的博客

然后动图也是从网上偷来的(^_^),代码实现我尽量用大家容易懂的方式实现

数组居多，然后，桶排序(是别人代码，不过写的不完全正确后面会更新)，都是学习嘛

有误的地方，还望各位指正，希望对你有帮助(其实很灵活的，在运用上)，也不要这样就满足了

多多地运用，会使理解更深的。

按上面的顺序来吧

原理在代码里直接上动图吧

冒泡排序动图演示

冒泡排序代码实现

#include<iostream>
#include<cstdio>
#include<string.h>
using namespace std;
const int N = 1e5 + 10;
int a[N];
//1.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
//当然如果你是降序那就，第一个比第二个小，就交换它们两个；
//2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，
//这样在最后的元素应该会是最大的数；
//3.针对所有的元素重复以上的步骤，除了最后一个；
//重复步骤1~3，直到排序完成。
void Bubble_sort(int* arr, int len)
{
    for(int i = 1;i < len;i++)
        for(int j = 1;j <= len - i;j++)
            if (arr[j] > arr[j + 1])//升序
            {
                int tem = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tem;
            }
}

int main()
{
    int n;
    while (cin >> n)
    {
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        Bubble_sort(a, n);
        cout << "After Bubble_sort:
";
        for (int i = 1; i <= n; i++)
            cout << a[i] << " 
"[i == n];
    }
    return 0;
}

快速排序动图演示

快速排序代码实现

#include<iostream>
#include<cstdio>
using namespace std;
const int N = 1e5 + 10;
int a[N];

//它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，
//其中一部分的所有数据都比另外一部分的所有数据都要小，
//然后再按此方法对这两部分数据分别进行快速排序
//整个排序过程可以递归进行，以此达到整个数据变成有序序列

void quick_sort(int L, int R, int* arr)
{
    if (L >= R) return;
    int MostL = arr[L];
    int i = L, j = R;
    while (i != j)
    {
        //先从最右边找出小于第一个元素的位置
        while (arr[j] >= MostL && i < j)
            --j;

        //然后从最左侧找出大于第一个元素的位置
        while (arr[i] <= MostL && i < j)
            ++i;

        //如果两个哨兵没有相遇交换二者
        if (i < j)
        {
            int tem = arr[i];
            arr[i] = arr[j];
            arr[j] = tem;
        }
    }

    //将第一个元素放在它应该在的位置
    arr[L] = arr[i];
    arr[i] = MostL;

    //对于当前哨兵位置的两侧还未有序，递归调用即可
    quick_sort(L, i - 1, arr);
    quick_sort(i + 1, R, arr);
}

int main()
{
    int n;
    while (cin >> n)
    {
        for (int i = 1; i <= n; i++)
            cin >> a[i];

        quick_sort(1, n, a);
        puts("After quick_sort:");
        for (int i = 1; i <= n; i++)
            cout << a[i] << " 
"[i == n];
    }
    return 0;
}

插入排序动图演示

插入排序代码实现

//插入排序的工作原理是通过构建有序序列，对于未排序数据，
//在已排序序列中从后向前扫描，找到相应位置并插入。
//具体算法描述如下：

//1.从第一个元素开始，该元素可以认为已经被排序；
//2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
//3.如果该元素（已排序）大于新元素，将该元素移到下一位置；
//4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
//5.将新元素插入到该位置后；
//6.重复步骤2~5
//其实有点像我们玩扑克理牌的时候，不过我们可以观察，就不会这么死的步骤了
#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;

int a[N];

void Insertion_sort(int *arr,int len)
{
  for(int i = 1;i < len;i++)
  {
     int Invalue = arr[i+1];//要插入的值
      int curIndex = i;//当前位置
      //找到插入的位置
      while(curIndex >= 1 && arr[curIndex] > Invalue)
      {
          arr[curIndex + 1] = arr[curIndex];
          --curIndex;
      }
      //在后面插入值
      arr[curIndex + 1] = Invalue;
  }
}

int main()
{
    int n;
    while(cin >> n)
    {
        for(int i = 1;i <= n;i++)
            cin >> a[i];
        Insertion_sort(a,n);
        puts("After Insertion_sort:");
        for(int i = 1;i <= n;i++)
            cout << a[i] << " 
"[i == n];
    }
    return 0;
}

希尔排序动图演示

希尔排序代码实现

#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int a[N];

void shell_sort(int *arr,int len)
{
    if(arr == NULL || len <= 0)
    return;
    int cnt = 1;
    for(int gap = len >> 1;gap > 0;gap >>= 1)
    {
        if(gap == 2) gap++;
        cout << "gap = " << gap << endl;
        for(int i = gap + 1;i <= len;i++)
        {
            cout << "i = " << i << endl;
            int tem = arr[i];
            int j = i - gap;
            while(arr[j] > tem && j >= 1)
            {
                cout << "j = " << j << endl;
                arr[j+gap] = arr[j];
                j -= gap;
            }
            arr[j+gap] = tem;
        }
//        cout << cnt++ << ":
";
//        for(int i = 1;i <= len;i++)
//            cout << arr[i] << " 
"[i == len];
    }
}
//10
//49 38 65 97 76 13 27 49 55 04
int main()
{
    int n;
    while(cin >> n)
    {
        for(int i = 1;i <= n;i++)
        cin >> a[i];
        shell_sort(a,n);

        puts("After shell_sort:");
        for(int i = 1;i <= n;i++)
        cout << a[i] << " 
"[i == n];
    }
    return 0;
}

选择排序动态图演示

选择排序代码实现

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N];
//选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理
//首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
//然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
//以此类推，直到所有元素均排序完毕。
void Selection_sort(int *arr,int len)
{
    for(int i = 1;i < len;i++)
    {
        int Minindex = i;
        for(int j = i + 1;j <= len;j++)
        if(arr[j] < arr[Minindex])
        {
            Minindex = j;
        }
        int tem = arr[Minindex];
        arr[Minindex] = arr[i];
        arr[i] = tem;
    }
}

int main()
{
    int n;
    while(cin >> n)
    {
        for(int i = 1;i <= n;i++)
            cin >> a[i];
        Selection_sort(a,n);
        puts("After Selection_sort:");
        for(int i = 1;i <= n;i++)
            cout << a[i] << " 
"[i == n];
    }
    return 0;
}

堆排序动图演示

堆排序代码实现

//堆排序,是指利用堆这种数据结构所设计的一种排序算法。
//堆是一个近似完全二叉树的结构，并同时满足堆积的性质：
//即子结点的键值或索引总是小于（或者大于）它的父节点。
//
//步骤：
//在最小堆的数据结构中，堆中的最小值总是位于根节点
//在优先队列中使用堆的话堆中的最小值位于根节点 堆中定义以下几种操作：
//最小堆调整：将堆的末端子节点作调整，使得子节点永远大于父节点
//创建最小堆：将堆中的所有数据重新排序
//
//堆排序：移除位在第一个数据的根节点，并做最大堆调整的递归运算
//其实说白了就是一种有某种性质的数据结构
//然后你做什么改动，都必须通过调整来维护该性质

#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int h[N];
int n;

void Swap(int x,int y)
{
    int tem = h[x];
    h[x] = h[y];
    h[y] = tem;
}

//传入一个向下调整的结点编号i
void shiftdown(int i)
{
    int t,flag = 0;//t用于记录较大值结点编号，flag用于标记是否需要下调整
    //当i有儿子，且需要调整是进行下面的操作
    while(i*2 <= n && !flag )
    {
        if(h[i] < h[i*2])//和左儿子比较
        t = 2*i;
        else t = i;
        //如果有右儿子再比较
        if(i*2 + 1 <= n)
        {
            if(h[t] < h[i*2 + 1])
                t = 2*i + 1;
        }

        if(i != t)
        {
            Swap(t,i);
            i = t;
        }
        else flag = 1;
    }
}

//传入需要向上调整的结点i
//void shiftup(int i)
//{
//    int flag = 0;
//    if(i == 1) return;
//    while(i != 1 && flag == 0)
//    {
//        if(h[i] < h[i/2])
//            Swap(i,i/2);
//        else flag = 1;
//        i = i/2;//更新结点
//    }
//}

//建立最大堆，之后最大元素是h[1]
void creatHeap()
{
    //完全二叉树有n/2个非叶结点
    for(int i = n/2;i >= 1;i--)
        shiftdown(i);
}

//int deleteMin()
//{
//    int t = h[1];
//    h[1] = h[n];
//    n--;
//    shiftdown(1);
//    return t;
//}
/*
从小到大排序的时候不建立最小堆而建立最大堆。最大堆建立好后，
最大的元素在h[ 1]。因为我们的需求是从小到大排序，
希望最大的放在最后。因此我们将h[1]和h[n]交换，
此时h[ n]就是数组中的最大的元素。请注意，交换后还需将h[1]向下调整以保持堆的特性。
OK现在最大的元素已经归位，需要将堆的大小减1即n--，然后再将h[ 1]和h[ n]交换
并将h[ 1]向下调整。如此反复，直到堆的大小变成1为止。此时数组h中的数就已经是排序好的了
*/
void heap_sort()
{
    while(n > 1)
    {
        Swap(1,n);
        n--;
        shiftdown(1);
    }
}
int main()
{
    int i,num;

    while(cin >> num)
    {
         for(int i = 1;i <= num;i++)
        cin >> h[i];
    n = num;
    creatHeap();
    heap_sort();

    for(int i = 1;i <= num;i++)
        cout << h[i] << " 
"[i == num];
    }
    return 0;
}

归并排序动图演示(二路归并)

归并排序代码实现

#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
//该算法的主要思想是对于两个已经有序的数组进行合并是简单的
//只需要对两个数组元素大小比较即可
//那么刚开始只需二分数组，分出来的两个小数组又递归地
//进行排序，然后有序的两个小数组就可以合并为一个大数组
//分治+二分

int a[N],t[N];

void Merge_sort(int *arr,int *T,int l,int r)
{
    //如果只有一个元素就不需要进行二分了
    if(r - l >= 1)
    {
        int m = l + (r - l)/2;

        //二分递归
        Merge_sort(arr,T,l,m);
        Merge_sort(arr,T,m+1,r);

        int i = l,j = m + 1;
        int nst = l;

        //合并两个有序的小数组
        while(i <= m || j <= r)
            if(j > r || (i <= m && arr[i] < arr[j]))
                T[nst++] = arr[i++];
            else T[nst++] = arr[j++];

        for(nst = l;nst <= r;nst++)
            arr[nst] = T[nst];
    }
}

int main(){

    int n;
    while(cin >> n)
    {
        for(int i = 1;i <= n;i++)
            cin >> a[i];
        Merge_sort(a,t,1,n);
        puts("After Merge_sort:");
        for(int i = 1;i <= n;i++)
            cout << a[i] << " 
"[i == n];
    }
    return 0;
}

计数排序动图演示

计数排序代码实现

#include<iostream>
#include<string.h>
#include<cstdio>
using namespace std;

const int N = 1e5 + 10;
int a[N],b[N];

//这个算法的局限性，最大最小值之差太大就不行了，因为数组不可能开的很大
void Count_sort(int n, int* A,int *B,int l,int r)
{
    int d = (r - l);
    for (int i = 0; i <= d; i++)
        b[i] = 0;

    for (int i = 1; i <= n; i++)
        b[a[i] - l]++;
}

int main()
{
    int n;
    while (cin >> n)
    {
        int r = -1e6,l = 1e6;
        for (int i = 1; i <= n; i++)
        {
            cin >> a[i];
            if (a[i] > r)
                r = a[i];
            if(a[i] < l)
                l = a[i];
        }
        int d = r - l;
        Count_sort(n, a, b, l, r);

        puts("After Count_sort:");
        for (int i = 0; i <= d; i++)
            for (int j = 1; j <= b[i]; j++)
                cout << i + l << " ";
        puts("");
    }
    return 0;
}

桶排序

桶排序代码实现

//算法描述：
//首先它是建立在计数排序的基础上
//你需要知道数列里的最大最小值
//然后自己定义桶的个数(有些人直接分为10个桶)，然后每个桶对应一个区间
//把每个数放到对应的区间
//每个桶内部可以用其他排序算法来排，
//每个桶排序好之后，由于桶之间保存的数字大小区间不一样
//最后合并所有桶就得到有序序列了
//这份代码是别人写的，我本来想用一个二位数组写的，
//不过用链表写也不错，我是理解了他的了，还加了一些注释
//而且这个写法没有离散化，导致输入的数据不可以是负数
//而且桶内的排序相当于插入排序是n^2的复杂度，是不对的，总的复杂度
//居然是n^2，我表示这个不是真的桶排序
#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int a[N];

typedef struct node {
    int key;
    struct node* next;
}KeyNode;

void bucket_sort(int keys[], int size, int bucket_size)
{
    KeyNode** bucket_table = (KeyNode**)malloc(bucket_size * sizeof(KeyNode*));

    for (int i = 0; i < bucket_size; i++) {    //初始化每个桶
        bucket_table[i] = (KeyNode*)malloc(sizeof(KeyNode));
        bucket_table[i]->key = 0;
        bucket_table[i]->next = NULL;
    }

    for (int i = 0; i < size; i++) {
        KeyNode* node = (KeyNode*)malloc(sizeof(KeyNode));
        node->key = keys[i];
        node->next = NULL;

        int index = keys[i] / 10;//给数据分类的方法（关系到排序速度，很重要）
        KeyNode* p = bucket_table[index];
        if (p->key == 0) {
            p->next = node;
            p->key++;
        }
        else {
            while (p->next != NULL && p->next->key <= node->key) {
            //新来的就找到自己的位置
            //这里选择类插入排序的方式，其实是不对的，因为这样的方式相当与每个桶内又是
            //n^2复杂度
                p = p->next;
            }
            node->next = p->next;
            p->next = node;
            (bucket_table[index]->key)++;//这个桶当前数据量加一
        }
    }

    KeyNode* k = NULL;
    //遍历每个桶
    for (int i = 0; i < bucket_size; i++) {
        for (k = bucket_table[i]->next; k != NULL; k = k->next) {
            printf("%d ", k->key);
        }
    }
}

int main()
{
    int n;
    while(cin >> n)
    {
        for(int i = 0;i < n;i++)
        cin >> a[i];
        puts("After bucket_sort:");
        bucket_sort(a, n, 10);
    }
    return 0;
}

基数排序动态图演示

基数排序代码实现

#include<bits/stdc++.h>
using namespace std;
int a[100];
int n, ma;
void work(int cur) {
    int b[10] = { 0 };
    int c[100];
    for (int i = 0; i < n; i++)
        b[(a[i] / cur) % 10]++;

    for (int i = 1; i < 10; i++)
        b[i] += b[i - 1];//前缀和，b[i]表示当前位小于等于i的数字有多少个

//   下面这个地方尤为关键为啥从n - 1开始，而不是从0开始
//   因为是从最低位开始调整位置的，前面已经在低位排好了，如果从0开始
//   如果当前位两个数字为0，那么他们的相对位置应该不变
//   从0开始就反了，顺序错了

    for (int i = n - 1; i >= 0; i--)
    {
        //精髓所在
        c[b[(a[i] / cur) % 10] - 1] = a[i];
        b[(a[i] / cur) % 10]--;
    }

    //复制一份给原始数据
    for (int i = 0; i < n; i++)
        a[i] = c[i];
}

void radix_sort() {
    //1代表各位的比较，10代表十位的比较，依此类推
    for (int i = 1; ma / i > 0; i *= 10)
        work(i);
}

int main() {

    while (cin >> n) {
        ma = 0;
        for (int i = 0; i < n; i++) {
            cin >> a[i];
            if(a[i] > ma) ma = a[i];
        }
        puts("before sort");
        for (int i = 0; i < n; i++)
            cout << a[i] << ' ';
        puts("");
        radix_sort();
        puts("after radix_sort");
        for (int i = 0; i < n; i++)
            cout << a[i] << ' ';
        puts("");
    }
    return 0;
}

最后各排序算法对比