排序算法总结

最新推荐文章于 2022-01-08 19:26:07 发布

原创最新推荐文章于 2022-01-08 19:26:07 发布 · 487 阅读

0 ·

CC 4.0 BY-SA版权

算法与数据结构专栏收录该内容

7 篇文章

订阅专栏

本文详细介绍了包括插入排序、希尔排序、冒泡排序等在内的十种经典排序算法的基本思想、示例及实现代码，帮助读者深入理解每种算法的特点与应用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

各种排序算法的性能分析：

1. 插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。

直接插入排序示例：

如果碰见一个和插入元素相等的数，那么将插入的元素放在相等元素的后面。相等元素的前后顺序没有改变，所以插入排序是稳定的。

算法实现：

#include <iostream>
using namespace std;

void print(int a[], int n,int i)
{
    cout<<i <<":";
    for(int j= 0; j<8; j++){
        cout<<a[j] <<" ";
    }
    cout<<endl;
}

void InsertSort(int a[], int n)
{
    for(int i = 1; i < n; i ++)
    {
        int x = a[i];
        int j = i-1;
        while( j >= 0 && x < a[j])
        {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = x;

        print(a,n,i);
    }
}

int main()
{
    int a[8] = {3,1,5,7,2,4,9,6};
    InsertSort(a,8);
    print(a,8,8);
}

2. 插入排序—希尔排序（Shell`s Sort）

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序

基本思想：

先将整个待排序列分割成若干个子序列分别进行直接插入排序，待整个序列中的记录”基本有序“时，在对整体记录进行一次直接插入排序。

注意：子序列的构成不是简单地逐段分割，而是将相隔某个增量的记录组成一个子序列。

直接插入排序示例：

算法实现：

#include <iostream>
using namespace std;

void print(int a[], int n ,int i)
{
	cout<<i <<":";
	for(int j= 0; j<8; j++)
    {
		cout<<a[j] <<" ";
	}
	cout<<endl;
}

void ShellInsertSort(int a[], int n, int dk)
{
	for(int i = dk; i <n; ++i)
    {
        int x = a[i];
        int j = i - dk;
        while(j >= 0 && x < a[j])
        {
            a[j + dk] = a[j];
            j -= dk;
        }
        a[j+dk] = x;

		print(a, n,i );
	}
}

void shellSort(int a[], int n)
{
	int dk = n/2;
	while(dk >= 1)
    {
		ShellInsertSort(a, n, dk);
		dk = dk/2;
	}
}

int main()
{
	int a[8] = {3,1,5,7,2,4,9,6};
	shellSort(a,8);
	print(a,8,8);
}

3. 交换排序—冒泡排序（Bubble Sort）

基本思想：

首先将第一个记录的关键字与第二个记录的关键字进行比较，如果为逆序，则将两个记录交换，然后比较第二个记录与第三个记录的关键字。以此类

推，直至第n-1个记录和第n个记录的关键字进行比较为止。上述过程为第一趟冒泡排序，其结果是使得关键字最大的记录被安置到最后一个记录的位置

上。然后进行第二趟冒泡排序，对前n-1个记录进行同样操作，其结果是使得关键字次大的记录被安置到第n-1个位置上。一般地，第 i 趟冒泡排序是从

a[0]到a[n - i]依次比较相邻两个记录的关键字，并在逆序时交换记录，其结果是这 n-i+1 个记录中关键字最大的记录被交换到第 n - i 个位置上。

冒泡排序的示例：

算法的实现：

void bubbleSort(int a[], int n)
{
    for(int i = 0 ; i < n - 1; ++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;
            }
        }
    }
}

4. 交换排序—快速排序（Quick Sort）

基本思想：

1）选择一个基准元素，通常选择第一个元素或者最后一个元素,

2）通过一趟排序将待排序的记录分割成独立的两部分。其中，一部分记录的元素值均比基准元素值小，另一部分记录的元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

快速排序的示例：

（a）一趟排序的过程：

（b）排序的全过程

算法的实现：

int partition(int a[], int low, int high)
{
    int privotKey = a[low];                                 //基准元素
    while(low < high){                                      //从表的两端交替地向中间扫描
        while(low < high  && a[high] >= privotKey) --high;  //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端
        a[low] = a[high];
        while(low < high  && a[low] <= privotKey ) ++low;
        a[high] = a[low];
    }
    a[low] = privotKey;
    return low;
}

void quickSort(int a[], int low, int high){
    if(low < high){
        int privotLoc = partition(a,  low,  high);  //将表一分为二
        quickSort(a, low, privotLoc - 1);           //递归对低子表递归排序
        quickSort(a, privotLoc + 1, high);          //递归对高子表递归排序
    }
}

5. 选择排序—简单选择排序（Simple Selection Sort）

基本思想：

在要排序的一组数中，选出最小(最大)的数与第1个位置的数交换；然后在剩下的数中，选出最小(最大)的数与第2个位置的数交换；依次类推，直到第

n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

简单选择排序的示例：

操作方法：

第1趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第2趟，从第2个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换；

直到整个序列按关键码有序。

算法的实现：

int SelectMinKey(int a[], int n, int i)
{
    int k = i;
    for(int j = i + 1; j < n; ++j) {
        if(a[k] > a[j]) k = j;
    }
    return k;
}
void selectSort(int a[], int n){
    int key, tmp;
    for(int i = 0; i < n - 1; ++i) {
        key = SelectMinKey(a, n, i);    //选择最小的元素
        if(key != i){                   //最小元素与第i位置元素互换
            tmp = a[i];  
            a[i] = a[key]; 
            a[key] = tmp; 
        }
    }
}

6. 选择排序—堆排序（Heap Sort）

基本思想：

堆的定义：具有n个元素的序列 k1, k2, ... , kn，当且仅当满足如下条件时，称之为堆。

(a) 大顶堆序列：（96, 83,27,38,11,09)

(b) 小顶堆序列：（12，36，24，85，47，30，53，91）

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆；将堆顶元素输出，得到n 个元素中最小(最大)的

元素；然后对剩下的n-1个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(次大)的元素；依此类推，直到只有两个节点的堆，并对它们

作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（最后一个元素与堆顶进行交换），堆被破坏

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法（2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法（2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

如图：

对n 个元素初始建堆：

1）n 个结点的完全二叉树，则最后一个结点是第个结点的子树。

2）筛选从第个结点为根的子树开始，使该子树成为堆。

3）之后向前依次对以各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图：无序序列：（49，38，65，97，76，13，27，49）

算法的实现：

void HeapAdjust(int H[],int s, int m)
{
    int tmp  = H[s];
    int child = 2*s+1;                     //2*s+1:左孩子  2*s+2:右孩子
    while (child < m)
    {
        if(child + 1 < m && H[child] < H[child+1] )
        {
            ++child ;
        }


        if(tmp < H[child])                //如果较大的子结点大于父结点
        {
            H[s] = H[child];              //把较大的子结点往上移动，替换它的父结点
            s = child;                    //重新设置s，即待调整的下一个结点的位置
            child = 2*s+1;


        }
        else  break;
    }
    H[s] = tmp;
}


void HeapSort(int H[],int length)
{


    for (int i = length/2-1; i >= 0; --i) //构建初始堆，最后一个非叶子的节点的位置为length/2-1
        HeapAdjust(H, i, length);


    for (int i = length - 1; i > 0; --i)
    {
        int temp = H[i];                  //交换堆顶元素H[0]和堆中最后一个元素
        H[i] = H[0];
        H[0] = temp;
        HeapAdjust(H, 0, i);              //对堆进行调整
    }
}

7. 归并排序（Merge Sort）

基本思想：

归并排序是将两个或两个以上的有序表合成一个新的有序表。即：把待排序序列分为若干个子序列，每个子序列是有序的，然后再把有序子序列合并为整体有序序列。

归并排序示例：

算法实现：

#include <iostream>
using namespace std;

void merge(int arr[], int tmpArray[], int lPos, int rPos, int rightEnd)
{
    int i, leftEnd, NumElements, tmpPos;

    leftEnd = rPos-1;
    tmpPos = lPos;
    NumElements = rightEnd-lPos+1;

    while (lPos<=leftEnd && rPos<=rightEnd)
    {
        if (arr[lPos]<=arr[rPos])
        {
            tmpArray[tmpPos++] = arr[lPos++];
        }
        else
        {
            tmpArray[tmpPos++] = arr[rPos++];
        }
    }

    while (lPos<=leftEnd)
    {
        tmpArray[tmpPos++] = arr[lPos++];
    }

    while (rPos<=rightEnd)
    {
        tmpArray[tmpPos++] = arr[rPos++];
    }

    for (i=0; i<NumElements; i++, rightEnd--)
    {
        arr[rightEnd] = tmpArray[rightEnd];
    }
}

void mSort(int arr[], int tmpArray[], int left, int right)
{
    int center;
    if (left<right) //当left=right时，认为数组已经有序了
    {
        center = (left+right)/2;
        mSort(arr, tmpArray, left, center);
        mSort(arr, tmpArray, center+1, right);
        merge(arr, tmpArray, left, center+1, right);
    }
}
void mergeSort(int arr[], int n)
{
    int* tmpArray = new int[n];
    mSort(arr, tmpArray, 0, n-1);
    delete[] tmpArray;
}

int main()
{
    int arr[10] = {-1, 9, 38, 17, 16, 45, 4, 3, 2, 91};
    mergeSort(arr, 10);
    for (int i=0; i<10; i++) {
        cout << arr[i] << " ";
    }
}