前言
本文将介绍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)