c/c++实现进阶排序

前言

本文将介绍5种排序算法

具体的内容有：

归并排序

堆排序

基数排序

计数排序

快速排序

具体内容详见下文。

一、归并排序

归并排序是一种基于归并操作（将两个有序数组合并为一个有序数组）的排序算法，采用了分治的思想，将需要排序的序列先不断分割为若干个子序列，直到每个子序列的长度都为1，此时可以认为每个子序列都是有序的。再将所有子序列合并，从而成为有序数组，即先“分”，再“治”。

代码实现

void Merge(int sourceArr[],int tempArr[], int startIndex, int midIndex, int endIndex){
    int i = startIndex, j=midIndex+1, k = startIndex;
    while(i!=midIndex+1 && j!=endIndex+1) {
        if(sourceArr[i] > sourceArr[j])
            tempArr[k++] = sourceArr[j++];
        else
            tempArr[k++] = sourceArr[i++];
    }
    while(i != midIndex+1)
        tempArr[k++] = sourceArr[i++];
    while(j != endIndex+1)
        tempArr[k++] = sourceArr[j++];
    for(i=startIndex; i<=endIndex; i++)
        sourceArr[i] = tempArr[i];
}

void MergeSort(int sourceArr[], int tempArr[], int startIndex, int endIndex) {
    int midIndex;
    if(startIndex < endIndex) {
        midIndex = startIndex + (endIndex-startIndex) / 2;//避免溢出int
        MergeSort(sourceArr, tempArr, startIndex, midIndex);
        MergeSort(sourceArr, tempArr, midIndex+1, endIndex);
        Merge(sourceArr, tempArr, startIndex, midIndex, endIndex);
    }
}

复杂度

时间复杂度 O（nlogn）

空间复杂度 O（n）

二、堆排序

堆排序是对选择排序的一种改进算法。在了解堆排序之前首先要理解堆这种数据结构。

堆可以看作是一颗完全二叉树，其中对于每个节点，都大于等于其子节点的称为大顶堆，同理，每个节点都小于等于其子节点的称为小顶堆。

本文中采用模拟法利用数组模拟完全二叉树，对于每个节点，可以通过下标计算出其根节点与左右子节点的下标。计算公式如下

将建好的堆使用递归方法进行调整，每次将堆顶的数据与最后一位数据进行交换，并将其移出堆，不断重复以上过程，即可以将数组调整为有序。

按照实际需要，可以自由选择大顶堆（升序）或小顶堆（降序）。

代码实现

void Swap(int* p1, int* p2) {
    int tmp;
    tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}

void heapify(int arr[],int n,int i)
{
    int maxn=i;
    int lc=i*2+1;
    int rc=i*2+2;
    if(lc<n && arr[maxn]<arr[lc])
    {
        maxn=lc;
    }
    if(rc<n && arr[maxn]<arr[rc])
    {
        maxn=rc;
    }
    if(maxn!=i)
    {
        Swap(&arr[maxn],&arr[i]);
        heapify(arr,n,maxn);
    }
}

void heapsort(int arr[],int n)
{
    for(int i=n/2-1;i>=0;i--)
    {
        heapify(arr,n,i);
    }
    for(int i=n-1;i>0;i--)
    {
        Swap(&arr[i],&arr[0]);
        heapify(arr,i,0);
    }
}

复杂度

时间复杂度 O(nlogn)

空间复杂度 O(1)

三、计数排序

计数排序是一种非比较排序算法，采取了用空间换时间的思想，在处理密集数据时明显快于比较算法。

计数排序的基本思路为将读取到的数据直接作为下标，将对应的数据直接进行加一操作，即记录该数据的出现次数。为了防止空间浪费的情况出现，可以将空间范围定为数据的最大值与最小值的范围，在每次读入数据减去最小值的结果作为下标。

计数排序的局限性为，仅能用于整型排序。

代码实现

void CountSort(int* a, int n)
{
    int max = a[0];
    int min = a[0];
    for (int i = 0; i < n; ++i)//找最大值和最小值
    {
        if (a[i] > max)
        {
            max = a[i];
        }

        if (a[i] < min)
        {
            min = a[i];
        }
    }

    int range = max - min + 1;//范围
    int* tmp = (int*)calloc(range, sizeof(int));//开辟空间
    if (tmp==NULL){
        perror("calloc error");
    return;
    }

    for (int i = 0; i < n; ++i)//统计数组a每个元素出现的次数
    {
    tmp[a[i]-min]++;
    }
    int j = 0;
    for (int i=0;i<range;++i)
    {
        while (tmp[i]) {
            a[j++] = i + min;//把元素的反映射至数组a
            tmp[i]--;
        }
    }
    free(tmp);//释放空间
    tmp = NULL;
}

复杂度

时间复杂度 O(n+k)

空间复杂度 O(k)

其中k为数据的最大值与最小值之差

四、基数排序

基数排序是桶排序的改进算法，它的基本思想是：将每个数的按照位数切割比较。

具体做法为将数据从最低位（个位）开始，到最高位结束（数位不够的补充前导零），依次排序，排序完成后的数列即为有序数组。 首先，需要建立10个临时容器（每个数位有0~9共10种情况），然后对每个数位进行分割放入容器，再判断下一位数位。

基数排序的局限性为：

代码实现

const int N=1000;
int node[10][N];

void redixsort(int arr[],int len)
{
    int flg=0;
    for(int i=0;i<len;i++)
    {
        if(arr[i]==0)
        {
            flg++;
        }
    }
    for(int k=10;k<10000;k*=10)
    {
        for(int i=0;i<len;i++)
        {

            int temp=(arr[i]%k)/(k/10);
            int j=0;
            while(node[temp][j])
            {
                j++;
            }
            node[temp][j]=arr[i];
        }
        int x=0;
        for(int i=0;i<10;i++)
        {
            for(int j=0;j<len && node[i][j]!=0;j++)
            {
                arr[x]=node[i][j];
                node[i][j]=0;
                x++;
            }
        }
    }
}

复杂度

时间复杂度 O(d*(n+r))

空间复杂度 O(d*(n+r))

其中d为最大位数，r为数位的取值范围（一般为10）

五、快速排序

快速排序是对冒泡排序的改进算法，思路是在序列中找到一个分界值，将比分界值小的移动至一侧，大于或等于分界值的移动至另一侧，以分界值为界将数组分为左右两个子序列，使用递归方式继续处理子序列，直至子序列的长度为1时，可以认为该序列已经有序。

代码实现

int partition(int arr[], int i, int j)
{
	int x = arr[i];
	while(i<j)
	{
		while(i<j && arr[j]>x)
		{
			j--;
		}
		if(i<j)
		{
			arr[i] =arr[j];
			i++;
		}
		while(i<j && arr[i]<x)
		{
			i++;
		}
		if(i<j)
		{
			arr[j] = arr[i];
			j--;
		}
	}
	arr[i] = x;
	return i;
}

void quicksort(int arr[], int i, int j)
{
	if(i<j)
	{
		int index = partition(arr, i, j);
		quicksort(arr, index+1, j);
		quicksort(arr, i, index-1);
	}
} 

复杂度

时间复杂度 O(n^2) ~ O(nlogn)

空间复杂度 O(1)