C语言：数组排序（插入排序、选择排序、泡排序、谢尔排序、快速排序、堆排序）

最新推荐文章于 2022-11-17 15:04:56 发布

Katniss-丫

最新推荐文章于 2022-11-17 15:04:56 发布

阅读量1.1k

点赞数 1

分类专栏： C 文章标签： c语言插入排序快速排序堆排序 shell排序

本文链接：https://blog.csdn.net/Katniss_smile/article/details/54316254

版权

C 专栏收录该内容

1 篇文章 1 订阅

订阅专栏

为什么排序？

能够将一个按值任意排列的数据元素序列转换为一个按值有序排列的数据元素序列。
能够提高查找的时间效率。

如何评判排序的性能？

时间性能
排序过程中元素之间的比较次数与元素的移动次数。
空间性能
除了存放参加排序的元素之外，排序过程中所需要的其他辅助空间。
稳定性
对于值相同的两个元素，排序前后的先后次序不变，则称该方法为稳定性排序方法，否则，称为非稳定性排序方法。

排序方法

1. 插入排序

1.1 具体过程

第i趟排序将序列的第i+1个元素到一个大小为i、且已经按值有序的子序列的合适位置，
得到一个大小为i+1、且仍然按值有序的子序列。
（注意，从第2个元素（即下标为1）开始排序）

这里写图片描述

1.2 代码实现

void insertSort(type a[],int n)
{
    int i,j;
    type temp;
    for(i=1;i<n;i++){
        //保存第i个元素
        temp = a[i];
        j = i - 1;
        //确定插入位置
        while(j>=0 && temp<a[j]){
        //从第i-1个元素开始比较，直到第一个小于a[i]的元素，所有元素依次向后移一位
            a[j+1] = a[j];
            j--;
        }
        //插入第i个元素，完成前i+1个元素的排序
        a[j+1] = temp;
    }
}

2. 折中插入排序

2.1 具体过程

在插入排序的基础上，采用折半查找方法确定插入位置。
（注意，可以减少比较次数，但是不能减少移动次数）

这里写图片描述

2.2 代码实现

void bin_insertSort(type a[],int n)
{
    int i,j,low,high,mid;
    type temp;
    for(i=1;i<n;i++){
        temp = a[i];
        low = 0;
        high = i - 1;
        //确定第i个元素插入位置
        while(low<=high){
            mid = (low + high) / 2;
            if(temp<a[mid])
                high = mid - 1;
            else
                low = mid + 1;
        }
        //依次后移
        for(j=i-1;j>=low;j--){
            a[j+1] = a[j];
        //插入元素
        a[low] = temp;
}

3. 选择排序

3.1 具体过程

每一趟排序从序列中未排好序的元素中选择一个值最小的元素，通过元素交换，将其与置于这些未排好序的元素的最前面。

这里写图片描述

3.2 代码实现

void selectSort(type a[],int n)
{
    int i,j;
    type temp;
    for(i=0;i<n-1;i++){
        for(j=i+1;j<n;j++){
            //a[i]保持为当前遇到的最小的未排序的元素
            if(a[i]>a[j]){
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
    }
}

4. 泡排序

4.1 具体过程

第i趟排序对序列的前n-i+1个元素从第一个元素开始依次作如下操作:相邻的两个元素比较大小，若前者大于后者,则两个元素交换位置，否则不交换位置。
如果某趟排序过程中无元素交换位置的动作，则排序结束。

这里写图片描述

4.2 代码实现

void bubbleSort(type a[],int n)
{
    int i,j,flag;
    type temp;
    flag = 1;
    for(i=n-1;i>=0 && flag==1;i--){
    //如果某趟循环中不存在交换的元素，则代表排序已完成，则flag=0
        flag = 0;
        for(j=0;j<i;j++){
            if(a[j]>a[j+1]){
                temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
                flag = 1;
            }
        }
    }
}

5. 谢尔排序

5.1 具体过程

首先确定一个元素的间隔数gap。
将参加排序的元素按照gap分隔成若干个子序列( 即分别把那些位置相隔为gap的元素看作一个子序列)，然后对各个子序列采用某种排序方法进行排序。
此后减小gap值，重复上述过程，直到gap<1。

这里写图片描述

5.2 代码实现

void shellSort(type a[],int n)
{
    int i,j,flag,gap;
    type temp;
    gap = n;
    while(gap>1){
        gap = gap / 2;
        //子序列利用泡排序
        do{
            flag = 0;
            for(i=0;i<n-gap;i++){
                j = i + gap;
                if(a[i]>a[j]){
                    temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    flag = 1;
                }
            }
        }while(flag!=0);
    }       
}

6. 快速排序

6.1 具体过程

从当前参加排序的元素中任选一个元素(通常称之为分界元素)与当前参加排序的那些元素进行比较,凡是小于分界元素的元素都移到分界元素的前面,凡是大于分界元素的元素都移到分界元素的后面,分界元素将当前参加排序的元素分成前后两部分,而分界元素处在排序的最终位置。然后，分别对这两部分重复上述过程,直到排序结束。

这里写图片描述

6.2 代码实现

void quick(type a[],int s,int t)
{
    int i,j;
    type temp;
    if(s<t){
        i = s;
        j = t - 1;
        while(1){
            //从前往后，找到比分界元素大的
            while(a[s]>=a[i] && i<t)
                i++;
            //从后往前，找到比分界元素小的
            while(a[s]<=a[j] && j>s)
                j--;
            //交换
            if(i<j){
                temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
            else
                break;
        }
        //将分界元素放到其对应的位置
        temp = a[s];
        a[s] = a[j];
        a[j] = temp;
        quick(a,s,j);
        quick(a,j+1,t);
    }
}
void quickSort(type a[],int n)
{
    quick(a,0,n);
}

7. 堆排序

7.1 具体过程

第i趟排序将序列的前n-i+1个元素组成的子序列转换为一个堆积，然后将堆积的第一个元素与堆积的最后那个元素交换位置。

这里写图片描述

7.2 代码实现

void heap(type a[],int i,int n)
{
    int j;
    type temp;
    temp = a[i];
    j = 2 * i;
    while(j<n){
        if(j<n-1 && a[j]<a[j+1])
            j++;
        if(temp>=a[j])
            break;
        a[j/2] = a[j];
        j = 2 * j;
    }
    a[j/2] = temp;
}
void heapSort(type a[],int n)
{
    int i;
    type temp;
    for(i=(n-1)/2;i>=0;i--)
        heap(a,i,n);
    for(i=n-1;i>=0;i--){
        temp = a[i];
        a[i] = a[0];
        a[0] = temp;
        heap(a,0,i);
    }
}