排序算法分类 |
空间复杂度: |
注:
1 归并排序可以通过手摇算法将空间复杂度降到O(1),但是时间复杂度会提高。
2 基数排序时间复杂度为O(N*M),其中N为数据个数,M为数据位数。
时间复杂度记忆:
- 冒泡、选择、直接 排序需要两个for循环,每次只关注一个元素,平均时间复杂度为O(n2)O(n2)(一遍找元素O(n)O(n),一遍找位置O(n)O(n))
- 快速、归并、希尔、堆基于二分思想,log以2为底,平均时间复杂度为O(nlogn)O(nlogn)(一遍找元素O(n)O(n),一遍找位置O(logn)O(logn))
稳定性记忆-“快希选堆”(快牺牲稳定性) - 排序算法的稳定性:排序前后相同元素的相对位置不变,则称排序算法是稳定的;否则排序算法是不稳定的。
原理理解 |
1 冒泡排序
(1.1)过程
冒泡排序从小到大排序:一开始交换的区间为0N-1,将第1个数和第2个数进行比较,前面大于后面,交换两个数,否则不交换。再比较第2个数和第三个数,前面大于后面,交换两个数否则不交换。依次进行,最大的数会放在数组最后的位置。然后将范围变为0N-2,数组第二大的数会放在数组倒数第二的位置。依次进行整个交换过程,最后范围只剩一个数时数组即为有序。
(1.2)排序动图
(1.3) 核心代码(函数)
//array[]为待排序数组,n为数组长度
void BubbleSort(int array[], int n)
{
int i, j, k;
for(i=0; i<n-1; i++)
for(j=0; j<n-1-i; j++)
{
if(array[j]>array[j+1])
{
k=array[j];
array[j]=array[j+1];
array[j+1]=k;
}
}
}
2 选择排序
(2.1) 过程
选择排序从小到大排序:一开始从0n-1区间上选择一个最小值,将其放在位置0上,然后在1n-1范围上选取最小值放在位置1上。重复过程直到剩下最后一个元素,数组即为有序。
(2.2)排序动图
(2.3) 核心代码(函数)
//array[]为待排序数组,n为数组长度
void selectSort(int array[], int n)
{
int i, j ,min ,k;
for( i=0; i<n-1; i++)
{
min=i; //每趟排序最小值先等于第一个数,遍历剩下的数
for( j=i+1; j<n; j++) //从i下一个数开始检查
{
if(array[min]>array[j])
{
min=j;
}
}
if(min!=i)
{
k=array[min];
array[min]=array[i];
array[i]=k;
}
}
}
3 插入排序
(3.1) 过程
插入排序从小到大排序:首先位置1上的数和位置0上的数进行比较,如果位置1上的数大于位置0上的数,将位置0上的数向后移一位,将1插入到0位置,否则不处理。位置k上的数和之前的数依次进行比较,如果位置K上的数更大,将之前的数向后移位,最后将位置k上的数插入不满足条件点,反之不处理。
(3.2) 排序动图
(3.3)核心代码:
//array[]为待排序数组,n为数组长度
void insertSort(int array[], int n)
{
int i,j,temp;
for( i=1;i<n;i++)
{
if(array[i]<array[i-1])
{
temp=array[i];
for( j=i;array[j-1]>temp;j--)
{
array[j]=array[j-1];
}
array[j]=temp;
}
}
}
4 归并排序
(4.1) 过程
归并排序从小到大排序:首先让数组中的每一个数单独成为长度为1的区间,然后两两一组有序合并,得到长度为2的有序区间,依次进行,直到合成整个区间。
(4.2) 排序动图
(4.3)核心代码:递归实现
实现归并,并把数据都放在list1里面
void merging(int *list1, int list1_size, int *list2, int list2_size)
{
int i=0, j=0, k=0, m=0;
int temp[MAXSIZE];
while(i < list1_size && j < list2_size)
{
if(list1[i]<list2[j])
{
temp[k++] = list1[i++];
}
else
{
temp[k++] = list2[j++];
}
}
while(i<list1_size)
{
temp[k++] = list1[i++];
}
while(j<list2_size)
{
temp[k++] = list2[j++];
}
for(m=0; m < (list1_size+list2_size); m++)
{
list1[m]=temp[m];
}
}
//如果有剩下的,那么说明就是它是比前面的数组都大的,直接加入就可以了
void mergeSort(int array[], int n)
{
if(n>1)
{
int *list1 = array;
int list1_size = n/2;
int *list2 = array + n/2;
int list2_size = n-list1_size;
mergeSort(list1, list1_size);
mergeSort(list2, list2_size);
merging(list1, list1_size, list2, list2_size);
}
}
//归并排序复杂度分析:一趟归并需要将待排序列中的所有记录
//扫描一遍,因此耗费时间为O(n),而由完全二叉树的深度可知,
//整个归并排序需要进行[log2n],因此,总的时间复杂度为
//O(nlogn),而且这是归并排序算法中平均的时间性能
//空间复杂度:由于归并过程中需要与原始记录序列同样数量级的
//存储空间去存放归并结果及递归深度为log2N的栈空间,因此空间
//复杂度为O(n+logN)
//也就是说,归并排序是一种比较占内存,但却效率高且稳定的算法
(4.4)核心代码:迭代实现
void MergeSort(int k[],int n)
{
int i,next,left_min,left_max,right_min,right_max;
//动态申请一个与原来数组一样大小的空间用来存储
int *temp = (int *)malloc(n * sizeof(int));
//逐级上升,第一次比较2个,第二次比较4个,第三次比较8个。。。
for(i=1; i<n; i*=2)
{
//每次都从0开始,数组的头元素开始
for(left_min=0; left_min<n-i; left_min = right_max)
{
right_min = left_max = left_min + i;
right_max = left_max + i;
//右边的下标最大值只能为n
if(right_max>n)
{
right_max = n;
}
//next是用来标志temp数组下标的,由于每次数据都有返回到K,
//故每次开始得重新置零
next = 0;
//如果左边的数据还没达到分割线且右边的数组没到达分割线,开始循环
while(left_min<left_max&&right_min<right_max)
{
if(k[left_min] < k[right_min])
{
temp[next++] = k[left_min++];
}
else
{
temp[next++] = k[right_min++];
}
}
//上面循环结束的条件有两个,如果是左边的游标尚未到达,那么需要把
//数组接回去,可能会有疑问,那如果右边的没到达呢,其实模拟一下就可以
//知道,如果右边没到达,那么说明右边的数据比较大,这时也就不用移动位置了
while(left_min < left_max)
{
//如果left_min小于left_max,说明现在左边的数据比较大
//直接把它们接到数组的min之前就行
k[--right_min] = k[--left_max];
}
while(next>0)
{
//把排好序的那部分数组返回该k
k[--right_min] = temp[--next];
}
}
}
}
//非递归的方法,避免了递归时深度为log2N的栈空间,
//空间只是用到归并临时申请的跟原来数组一样大小的空间,并且在时间性能上也有一定的提升,
//因此,使用归并排序是,尽量考虑用非递归的方法。
5 快速排序
(5.1) 过程
快速排序从小到大排序:在数组中随机选一个数(默认数组首个元素),数组中小于等于此数的放在左边,大于此数的放在右边,再对数组两边递归调用快速排序,重复这个过程。
(5.2)排序动图
(5.3)核心代码(函数)
//接口调整
void adjust_quicksort(int k[],int n)
{
quicksort(k,0,n-1);
}
void quicksort(int a[], int left, int right)
{
int i,j,t,temp;
if(left>right) //(递归过程先写结束条件)
return;
temp=a[left]; //temp中存的就是基准数
i=left;
j=right;
while(i!=j)
{
//顺序很重要,要先从右边开始找(最后交换基准时换过去的数要保证比基准小,因为基准
//选取数组第一个数,在小数堆中)
while(a[j]>=temp && i<j)
j--;
//再找右边的
while(a[i]<=temp && i<j)
i++;
//交换两个数在数组中的位置
if(i<j)
{
t=a[i];
a[i]=a[j];
a[j]=t;
}
}
//最终将基准数归位 (之前已经temp=a[left]过了,交换只需要再进行两步)
a[left]=a[i];
a[i]=temp;
quicksort(left,i-1);//继续处理左边的,这里是一个递归的过程
quicksort(i+1,right);//继续处理右边的 ,这里是一个递归的过程
}
6 堆排序
(6.1) 过程
堆排序从小到大排序:首先将数组元素建成大小为n的大顶堆,堆顶(数组第一个元素)是所有元素中的最大值,将堆顶元素和数组最后一个元素进行交换,再将除了最后一个数的n-1个元素建立成大顶堆,再将最大元素和数组倒数第二个元素进行交换,重复直至堆大小减为1。
注:完全二叉树
假设二叉树深度为n,除了第n层外,n-1层节点都有两个孩子,第n层节点连续从左到右。如下图
(6.2)排序动图
(6.3)核心代码:
void heapSort(int array[], int n)
{
int i;
for (i=n/2;i>0;i--)
{
HeapAdjust(array,i,n);//从下向上,从右向左调整
}
for( i=n;i>1;i--)
{
swap(array, 1, i);
HeapAdjust(array, 1, i-1);//从上到下,从左向右调整
}
}
void HeapAdjust(int array[], int s, int n )
{
int i,temp;
temp = array[s];
for(i=2*s;i<=n;i*=2)
{
if(i<n&&array[i]<array[i+1])
{
i++;
}
if(temp>=array[i])
{
break;
}
array[s]=array[i];
s=i;
}
array[s]=temp;
}
void swap(int array[], int i, int j)
{
int temp;
temp=array[i];
array[i]=array[j];
array[j]=temp;
}
7 希尔排序
(7.1) 过程
希尔排序是插入排序改良的算法,希尔排序步长从大到小调整,第一次循环后面元素逐个和前面元素按间隔步长进行比较并交换,直至步长为1,步长选择是关键。
(7.2)排序动图
(7.3 )核心代码:
//下面是插入排序
void InsertSort( int array[], int n)
{
int i,j,temp;
for( i=0;i<n;i++ )
{
if(array[i]<array[i-1])
{
temp=array[i];
for( j=i-1;array[j]>temp;j--)
{
array[j+1]=array[j];
}
array[j+1]=temp;
}
}
}
//在插入排序基础上修改得到希尔排序
void SheelSort( int array[], int n)
{
int i,j,temp;
int gap=n; //~~~~~~~~~~~~~~~~~~~~~
do{
gap=gap/3+1; //~~~~~~~~~~~~~~~~~~
for( i=gap;i<n;i++ )
{
if(array[i]<array[i-gap])
{
temp=array[i];
for( j=i-gap;array[j]>temp;j-=gap)
{
array[j+gap]=array[j];
}
array[j+gap]=temp;
}
}
}while(gap>1); //~~~~~~~~~~~~~~~~~~~~~~
}
8 桶排序(基数排序和基数排序的思想)
(8.1) 过程
桶排序是计数排序的变种,把计数排序中相邻的m个”小桶”放到一个”大桶”中,在分完桶后,对每个桶进行排序(一般用快排),然后合并成最后的结果。
(8.2)图解
(8.3) 核心代码:
#include <stdio.h>
int main()
{
int a[11],i,j,t;
for(i=0;i<=10;i++)
a[i]=0; //初始化为0
for(i=1;i<=5;i++) //循环读入5个数
{
scanf("%d",&t); //把每一个数读到变量t中
a[t]++; //进行计数(核心行)
}
for(i=0;i<=10;i++) //依次判断a[0]~a[10]
for(j=1;j<=a[i];j++) //出现了几次就打印几次
printf("%d ",i);
getchar();getchar();
//这里的getchar();用来暂停程序,以便查看程序输出的内容
//也可以用system("pause");等来代替
return 0;
}