八大经典排序算法的理解、动图演示和C++方法实现

0. 排序算法概述

所谓排序,就是使一串序列,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。掌握基本排序方法是算法入门的必备基础知识。八种排序如下所示:

看到有文章说计数排序是稳定排序,实际上计数排序是重新赋值的,所以我的理解它应该属于不稳定排序。这里介绍的8种排序算法的基本情况,如下思维导图和表格所示:

八大经典排序算法的理解、动图演示和C++方法实现_第1张图片
排序算法 平均时间复杂度 最好情况 最坏情况 空间复杂度 稳定性
冒泡排序 O ( n 2 ) O(n^2) O(n2) O ( n ) O(n) O(n) O ( n 2 ) O(n^2) O(n2) O ( 1 ) O(1) O(1) 稳定
选择排序 O ( n 2 ) O(n^2) O(n2) O ( n 2 ) O(n^2) O(n2) O ( n 2 ) O(n^2) O(n2) O(1)$ 不稳定
插入排序 O ( n 2 ) O(n^2) O(n2) O ( n ) O(n) O(n) O ( n 2 ) O(n^2) O(n2) O ( n ) O(n) O(n) 稳定
快速排序 O ( n   l o g   n ) O(n\ log\ n) O(n log n) O ( n   l o g   n ) O(n\ log\ n) O(n log n) O ( n 2 ) O(n^2) O(n2) O ( n   l o g   n ) O(n\ log\ n) O(n log n) 不稳定
归并排序 O ( n   l o g   n ) O(n\ log\ n) O(n log n) O ( n   l o g   n ) O(n\ log\ n) O(n log n) O ( n   l o g   n ) O(n\ log\ n) O(n log n) O ( n ) O(n) O(n) 稳定
计数排序 O ( n + k ) O(n + k) O(n+k) O ( n + k ) O(n + k) O(n+k) O ( n + k ) O(n + k) O(n+k) O ( k ) O(k) O(k) 不稳定
希尔排序 O ( n   l o g   n ) O(n\ log\ n) O(n log n) O ( n   l o g 2   n ) O(n\ log^2\ n) O(n log2 n) O ( n   l o g 2   n ) O(n\ log^2\ n) O(n log2 n) O ( 1 ) O(1) O(1) 不稳定
堆排序 O ( n   l o g   n ) O(n\ log\ n) O(n log n) O ( n   l o g   n ) O(n\ log\ n) O(n log n) O ( n   l o g   n ) O(n\ log\ n) O(n log n) O ( 1 ) O(1) O(1) 不稳定

说明:排序算法的稳定性,指的是排序前后相同元素的相对位置不变,则称排序算法是稳定的;否则排序算法是不稳定的。

下面开始介绍各类算法的实现,例程全部是从小到大排序。

1. 冒泡排序

原理:它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。把最小的数浮上来,或者把最大的数据沉下去。
八大经典排序算法的理解、动图演示和C++方法实现_第2张图片

代码实现:

#include
#include
using namespace std;
//这里实现的方式和图示略有不同
void bubbleSort(vector<int>&a){
     
    for(int i = 0; i < a.size(); i++)
        for(int j = i+1;j < a.size(); j++)
        {
     
            if(a[i] > a[j])
                swap(a[i],a[j]);
        }
}

int main()
{
     
    vector<int>a = {
     56, 7, 2, 67, 34, 26, 93, 3};
    cout<<"Before Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    bubbleSort(a);
    cout<<"After Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    return 1;
}

2. 选择排序

原理:选择排序和冒泡很像,它也是比较两个元素,不过它先不交换,等到选取最大或者最小的数据之后再进行交换。

八大经典排序算法的理解、动图演示和C++方法实现_第3张图片
代码实现:

#include
#include
using namespace std;

void selectSort(vector<int>& a){
     
    for(int i = 0; i < a.size(); ++i){
     
        int minIndex = i;//记录最小索引
        for(int j = i; j < a.size(); ++j){
     
            if(a[j] < a[minIndex]) minIndex = j;
        }
        if( minIndex != i){
     
            swap(a[minIndex],a[i]);
        }
    }
}

int main()
{
     
    vector<int>a = {
     56, 7, 2, 67, 34, 26, 93, 3};
    cout<<"Before Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    selectSort(a);
    cout<<"After Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    return 1;
}

3. 插入排序

原理:从第二位数据开始, 当前数(第一趟是第二位数)与前面的数依次比较,如果前面的数大于当前数,则将这个数放在当前数的位置上,当前数的下标-1,直到当前数不大于前面的某一个数为止。直到遍历至最后一位元素。

通俗的讲,就是从第二位开始,更小的值往前插入。前面的数据肯定是插入排序已经排列好的,前面的值小于或等于当前值基准值的位置。
八大经典排序算法的理解、动图演示和C++方法实现_第4张图片
代码实现:

#include
#include
using namespace std;

void insertSort(vector<int>&a){
     
    for(int i = 1; i < a.size(); ++i)//从第二位开始
    {
     
        int key = a[i];//记录插入的值
        int j = i-1;
        while( j >= 0 && a[j] > key ) {
     //每次都和基准key比较,最小值往前插
            a[j+1] = a[j];//后移
            j--;
        }
        a[j+1] = key;//插入操作
    }
}

int main()
{
     
    vector<int>a = {
     56, 7, 2, 67, 34, 26, 93, 3};
    cout<<"Before Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    insertSort(a);
    cout<<"After Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    return 1;
}

4. 快速排序

原理:通过一趟排序将序列分成左右两部分,其中左半部分的的值均比右半部分的值小,然后再分别对左右部分的记录进行排序,直到整个序列有序。
八大经典排序算法的理解、动图演示和C++方法实现_第5张图片

代码实现:

#include
#include
using namespace std;
//partition为一趟排序
int partition(vector<int>&a,  int low, int high){
     
    int key = a[low];//获取基准,基准为low,所以一定要从high开始
    while( low < high ){
     
        while(low < high && a[high] >= key) high--;//右边查找
        a[low] = a[high];
        while(low < high && a[low] <= key) low++;//左边查找
        a[high] = a[low];
    }
    a[low] = key;//基准最后插入
    return low;
}

void quickSort(vector<int>&a, int low, int high){
     
    if(low >= high) return;
    int keypos = partition(a, low, high);//一次排序,keypos将数据分成左右两边
    quickSort(a, low, keypos-1);//递归
    quickSort(a, keypos+1, high);
}

int main()
{
     
    vector<int>a = {
     56, 7, 2, 67, 34, 26, 93, 3};
    cout<<"Before Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    quickSort(a,0,a.size() - 1);//分别指向两端的数据。
    cout<<"After Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    return 1;
}

5. 归并排序

归并排序是把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
八大经典排序算法的理解、动图演示和C++方法实现_第6张图片
实现代码:

#include
#include
using namespace std;
void merge(vector<int>&a, int first, int mid, int last){
     
    int temp[last-first+1];
    int copyIndex = last - first;
    int i = mid, j = last;
    while( i>=first && j >= mid+1 ){
     
        if(a[i] > a[j]) temp[copyIndex--] = a[i--];
        else temp[copyIndex--] = a[j--];
    }
    while(i >= first ) temp[copyIndex--] = a[i--];
    while(j >= mid+1) temp[copyIndex--] = a[j--];
    for(int k = first; k <= last; ++k){
     
        a[k] = temp[k-first];
    }
}

void mergeSort(vector<int>&a, int first, int last){
     
    if( first >= last) return;
    int mid = (first + last)/2;
    mergeSort(a, first, mid);
    mergeSort(a, mid+1, last);
    merge(a, first, mid, last);
}
int main()
{
     
    vector<int>a = {
     56, 7, 2, 67, 34, 26, 93, 3};
    cout<<"Before Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    mergeSort(a, 0, a.size() - 1);
    cout<<"After Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    return 1;
}

6. 计数排序

原理:当待排序的数的值都是在一定的范围内的整数时,可以用待排序的数作为计数数组的下标,统计每个数的个数,然后依次输出即可。

算法步骤:

  1. 花O(n)的时间扫描一下整个序列 A,max
  2. 开辟一块新的空间创建新的数组 B,长度为 ( max + 1)
  3. 数组 B 中 index 的元素记录的值是 A 中某元素出现的次数
  4. 最后输出目标整数序列,具体的逻辑是遍历数组 B,输出相应元素以及对应的个数

八大经典排序算法的理解、动图演示和C++方法实现_第7张图片
实现代码:

#include
#include
using namespace std;
void countSort(vector<int>&a){
     
    int my_max = a[0];
    for(int i = 1; i < a.size(); ++i)
        my_max = max(a[i], my_max);

    int* count = new int[my_max + 1](); //开辟空间,如果不计算min则开辟的空间会很大。
    for(int i = 0; i < a.size(); ++i)//开始计数
        count[a[i]] ++;
    int id = 0;
    //更新原数组
    for(int i = 0; i <= my_max; ++i){
     
        for(int j = 0; j < count[i]; ++j)//个数
            a[id++] = i;
    }
    delete[] count;
}
int main()
{
     
    vector<int>a = {
     56, 7, 2, 67, 34, 26, 93, 3};
    cout<<"Before Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    countSort(a);
    cout<<"After Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    return 1;
}

7. 希尔排序

原理:希尔排序是插入排序改良的算法,是插入排序的一种高效率的实现,也叫缩小增量排序。希尔排序步长从大到小调整,所以步长是关键,最终步长为1,做最后的排序。

步长为1的时候肯定能排出符合的序列。
八大经典排序算法的理解、动图演示和C++方法实现_第8张图片
实现代码:

#include
#include
using namespace std;
void shell_insert(vector<int>&a, int d){
     
    for(int i = d; i < a.size(); i++){
     
        int j = i - d;//子序列进行插入排序
        int key = a[i];
        while( j >= 0 && a[j] > key){
     
            a[j+d] = a[j];
            j -= d;
        }
        if(j != i-d)
            a[j+d] = key;
    }
}
void shellSort(vector<int>&a){
     
    int d = a.size()/2;//步长
    while(d >= 1){
     
        shell_insert(a, d);
        d /= 2;
    }
}

int main()
{
     
    vector<int>a = {
     56, 7, 2, 67, 34, 26, 93, 3};
    cout<<"Before Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    shellSort(a);
    cout<<"After Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    return 1;
}

8. 堆排序

堆排序是指利用堆这种数据结构所设计的一种排序算法。利用了堆的一个总要性质,即子结点的键值或索引总是小于(或者大于)它的父节点。

堆的性质:

  • 堆是一个完全二叉树
  • 堆中某个结点的值总是不大于或不小于其父结点的值;
  • 将根结点最大的堆叫做最大堆或大根堆,根结点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。
  • 一棵深度为k的有n个结点的二叉树,对树中的结点按从上至下、从左到右的顺序进行编号,如果编号为i(1≤i≤n)的结点与满二叉树中编号为i的结点在二叉树中的位置相同,则这棵二叉树称为完全二叉树

原理:从小到大排序,则使用大顶堆,每次取堆顶元素和后面的元素交换,然后对剩下的元素进行大顶堆排序。

大顶堆的构建:


代码实现:

#include
#include
using namespace std;
//当列表第一个是以下标0开始,结点下标为i,左孩子则为2*i+1,右孩子下标则为2*i+2,若下标以1开始,左孩子则为2*i,右孩子则为2*i+1
void heapAdjust(vector<int>&a, int s, int m){
     
    int key = a[s];
    for(int j = 2*s + 1; j <= m; j = 2*j + 1 )//遍历s节点的子节点
    {
     
        if(j < m && a[j] <= a[j+1] ) ++j;
        if( a[j] <= key ) break;
        a[s] = a[j];
        s = j;
    }
    a[s] = key;
}
void heapSort(vector<int>&a){
     
    //初始建堆,从最后一个非叶子节点开始,左半边为非叶子节点,右半边为叶子节点。
    for(int i = a.size()/2-1; i >= 0; --i){
     
        heapAdjust(a, i, a.size()-1);
    }
    //取堆顶,并且调整
    for(int i = a.size()-1; i > 0 ; --i){
     
        swap(a[0],a[i]);//把堆顶元素交换至后面。
        heapAdjust(a, 0, i-1);//对剩下的元素进行大顶堆排序
    }
}

int main()
{
     
    vector<int>a = {
     56, 7, 2, 67, 34, 26, 93, 3};
    cout<<"Before Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    heapSort(a);
    cout<<"After Sort: ";
    for(auto x : a)
        cout<<x<<", ";
    cout<<endl;
    return 1;
}

参考(Java实现):https://www.cnblogs.com/fivestudy/p/10212306.html

你可能感兴趣的:(算法与数据结构,排序算法,C++实现,快速排序,选择排序,冒泡排序)