八大排序算法总结(一)
归并排序
归并算法采用分治策略
1、归并排序的基本思想
将待排序序列R[0…n-1]看成是n个长度为1的有序序列,将相邻的有序表成对归并,得到n/2个长度为2的有序表;将这些有序序列再次归并,得到n/4个长度为4的有序序列;如此反复进行下去,最后得到一个长度为n的有序序列
2、归并排序的算法描述
第一步:申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
第二步:设定两个指针,最初位置分别为两个已经排序序列的起始位置
第三步:比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
重复步骤3直到某一指针超出序列尾,将另一序列剩下的所有元素直接复制到合并序列尾
归并排序其实要做两件事:
(1)“分解”——将序列每次折半划分(递归实现)
(2)“合并”——将划分后的序列段两两合并后排序
如何合并?
在每次合并过程中,都是对两个有序的序列段进行合并,然后排序。
这两个有序序列段分别为 R[low, mid] 和 R[mid+1, high]。
先将他们合并到一个局部的暂存数组R2中,带合并完成后再将R2复制回R中。
我们称 R[low, mid] 第一段,R[mid+1, high] 为第二段。
每次从两个段中取出一个记录进行关键字的比较,将较小者放入R2中,最后将各段中余下的部分直接复制到R2中。
经过这样的过程,R2已经是一个有序的序列,再将其复制回R中,一次合并排序就完成了。
时间复杂度:O(nlogn)
(最好情况和最坏情况都是O(nlogn))
空间复杂度:O(n)
是否稳定: 稳定
#include<stdio.h>
#include<stdlib.h>
/*Merge函数将R[low,mid]和R[mid+1,high]这两排好序的小数组合并处排序大数组R[low,high]*/
void Merge(int *R,int low,int mid, int high)
{
int i = low, j = mid+1, p = 0;
//k指向合并后数组的头
int *R1; //局部变量,暂存数组
R1=(int *)malloc((high-low+1)*sizeof(int));
//分配出一块两个小数组合并后的数组的空间
if(!R1)
{
printf("malloc error!\n");
return; //空间申请失败
}
while(i<=mid && j<=high)
{
if(R[i]<=R[j])
{
R1[p] = R[i];
i++;
}
else
{
R1[p] = R[j];
j++;
}
p++;
}
//然后肯定至少有一个数组是有剩余没排进去的,并且值很大
while(i<=mid) //若第1个子文件非空,则复制剩余记录到R1中
{
R1[p++]=R[i++];
}
while(j<=high) //若第2个子文件非空,则复制剩余记录到R1中
{
R1[p++]=R[j++];
}
for(p=0,i=low;i<=high;p++,i++)
{
R[i]=R1[p]; //归并完成后将结果复制回R[low..high]
}
}
//分治法进行二路归并排序
void MergeSort(int *R, int low, int high)
{
int mid;
if(low<high) //区间长度大于1
{
mid = (low+high)/2;
MergeSort(R,low,mid);
MergeSort(R,mid+1,high);
Merge(R,low,mid,high);
}
}
void main()
{
int a[9]={49,38,65,97,76,13,27,1,19}; //这里对9个元素进行排序
int low=0,high=8; //初始化low和high的值
printf("排序前的序列: ");
for(int i=low;i<=high;i++)
{
printf("%d ",a[i]); //输出测试
}
printf("\n");
MergeSort(a,low,high);
printf("排序后的序列: ");
for( int i=low;i<=high;i++)
{
printf("%d ",a[i]); //输出测试
}
printf("\n");
}
交换排序
- 冒泡排序
算法原理
冒泡排序的原理(以递增序为例)是每次从头开始依次比较相邻的两个元素,如果后面一个元素比前一个要大,说明顺序不对,则将它们交换,本次循环完毕之后再次从头开始扫描,直到某次扫描中没有元素交换,说明每个元素都不比它后面的元素大,至此排序完成。
由于冒泡排序简洁的特点,它通常被用来对于计算机程序设计入门的学生介绍算法的概念。
时间复杂度
若文件的初始状态是排好序的的,一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数 M 均达到最小值(Cmin = n-1、Mmin = 0)
所以,冒泡排序最好的时间复杂度为O(N)。
若初始文件是反序的,需要进行N趟排序。每趟排序要进行 C = N-1次关键字的比较(1≤i≤N-1)和总共(Mmax = (N*(N-1))/2)次的移动(移动次数由乱序对的个数决定,即多少对元素顺序不对,如 1 3 4 2 5 中共有(3,2)、(4,2)两个乱序对),在这种情况下,比较和移动次数均达到最大值
(Cmax =N*(N-1) + Mmax=(N*(N-1))/2 = O(N^2)。
所以,冒泡排序的最坏时间复杂度为O(N^2)
综上,冒泡排序总的平均时间复杂度为O(N^2)。
算法稳定性
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。如果两个相等的元素相邻,那么根据我们的算法。它们之间没有发生交换;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。
单向冒泡排序
void bubble_sort(int *a,int n)
{
int i,j;
int temp = 0;
for(i = 0;i<n-1;i++)
{
for(j = 0;j<n-i-1;j++)
{
if(a[j]>a[j+1]) //每一次运行都把最大的一个数运到尚未排的最后
{
temp = a[j+1];
a[j+1] = a[j];
a[j] = temp;
}
}
}
}
双向冒泡排序
//双向冒泡排序
void double_bubbleswap(int source[],int n)
{
int start = 0,end = n-1;
int i;
while(start<=end)
{
for(i=start;i<end;i++)
{
if(source[i]>source[i+1])
{
int t;
t = source[i];
source[i] = source[i+1];
source[i+1] = t;
}
}
end--;
for(int j=end;j>start;j--)
{
if(source[j]<source[j-1])
{
int k=source[j];
source[j] = source[j-1];
source[j-1] = k;
}
}
start++;
}
}
- 快速排序
基本思想是:从一个数组中随机选出一个数N,通过一趟排序将数组分割成三个部分,1、小于N的区域 2、等于N的区域 3、大于N的区域,然后再按照此方法对小于区的和大于区分别递归进行,从而达到整个数据变成有序数组。
快排的时间复杂度O(N*logN),空间复杂度O(logN) 【因为每次都是随机事件,坏的情况和差的情况,是等概率的,根据数学期望值可以算出时间复杂度和空间复杂度】,不稳定性排序
图解部分源自此网站https://blog.csdn.net/u010452388/article/details/81218540?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param
//快速排序
void quicksort(int a[],int left,int right)
{
int i = left;
int j = right;
int temp = a[i];
if(left>right)
return;
while(i!=j)
{
/*先从右往左,当遇到第一个小于temp的值得时候
跳出循环。a[i]赋值为a[j],这里的a[i]=temp=a[left];*/
while(i<j&&a[j]>temp)
j--;
if(i<j)
a[i] = a[j];
/*在从左往右,当遇到第一个大于temp的时候,跳出循环
a[j]赋值为a[i]*/
while(i<j&&a[i]<=temp)
i++;
if(i<j)
a[j]=a[i];
}
a[i] = temp;
quicksort(a,left,i-1);
quicksort(a,i+1,right);
}
插入排序
- 直接插入排序
直接插入排序基本思想是每一步将一个待排序的记录,插入到前面已经排好序的有序序列中去,直到插完所有元素为止。
直接插入排序算法的运作如下:
假设有一组无序序列 R0, R1, … , RN-1。
(1) 我们先将这个序列中下标为 0 的元素视为元素个数为 1 的有序序列。
(2) 然后,依次把 R1, R2, … , RN-1 插入到这个有序序列中。所以,我们需要一个外部循环,从下标 1 扫描到 N-1 。
(3) 接下来描述插入过程。假设这是要将 Ri 插入到前面有序的序列中。由前面所述,我们可知,插入Ri时,前 i-1 个数肯定已经是有序了。
所以我们需要将Ri 和R0 ~ Ri-1 进行比较,确定要插入的合适位置。这就需要一个内部循环,我们一般是从后往前比较,即从下标 i-1 开始向 0 进行扫描。
当数据正序时,执行效率最好,每次插入都不用移动前面的元素,时间复杂度为O(N)。
当数据反序时,执行效率最差,每次插入都要前面的元素后移,时间复杂度为O(N*2)。
//直接插入排序
void DirectInsertionsort(int A[],int n)
{
int i,j;
int temp;
for(i=1;i<n;i++) //直接插入排序一般认为A[0]是那个最初排好的第一个序列
{
j=i;
temp = A[i];
while(j>0&&temp<A[j-1])//当未达到数组的第一个元素或者待插入元素小于当前元素
{
A[j] = A[j-1]; //就将该元素后移
j--; //下标减一,继续比较
}
A[j]=temp;
}
}
折半插入排序
1、将待排序序列的第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。
2、从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置,在查找元素的适当位置时,采用了折半查找方法。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)
//折半插入排序
void BinaryInsertionsort(Forsort A[],int n)
{
int i,k,r;
Forsort temp;
for(i=1;i<n;i++)
{
temp = A[i];
k = 0;
r = i - 1;
while(k<=r)
{
int m;
m = (k+r)/2;
if(temp.key<A[m].key)
r = m-1;
else
{
k = m+1;
}
}
//找到了插入位置为k
for(r = i;r>k;r--)
{
A[r] = A[r-1];
}
A[k] = temp;
}
}
希尔排序
(可以参考一下这篇博客: 点击蓝色文字)
1.首先根据初始序列的长度,选定一个递减增量序列
t1,t2,t3…tk,其中ti>tj,tk = 1。
根据选定的增量序列元素个数k,对初始序列进行k趟排序。
根据增量序列的值ti,每趟排序会把初始序列划分成若干个元素的子序列,然后对这些子序列使用插入排序,因为这是递减增量序列,所以第一趟的排序,增量值最大,那么划分的子序列数量也就最多,每个子序列的元素也就越少,可以看做是一个“几乎”已经排好序的序列,当增量值越来越小的时候,子序列数量也就越少,每个子序列的元素也就越多,但是,基于前几次的排序,这些子序列虽然元素多,但是已经是一个“几乎”排好序的序列了,当最后一次排序的时候,即增量序列的值为1时,就是对整个无序序列进行排序,这时整个序列已经是一个“几乎”排好序的序列了。
以图为例进行说明,假设给定的初始无序序列如下:
4 5 8 2 3 9 7 1
首先,我们选择一个增量序列,这个增量序列如何选择呢?首先我们得保证第一次的所有子序列元素数量应该至少保证为2个或以上,这样是用插入排序才有意义,如果元素数量为1,也就是增量序列的第一个值为初始序列的长度或者更大,那么这次遍历将“无功而返”,所以至少应该保证子序列元素数量为2或以上,当子序列数量退化到初始序列长度时,希尔排序也退化成了插入排序。事实上,希尔排序的效率依赖于增量序列的选择,好的增量序列可以大大的提高希尔排序的效率,但是增量序列的选择是和初始序列有关系的。
一个好的递减增量序列选取的标准是:第一、递减增量序列最后一个值应该为1;第二、递减增量序列中的值,尤其是相邻的值最好不要互为倍数的关系,如果是互为倍数的关系,那么根据这两个序列值的分组将会有重复的情况,可能会做“无用功”。
该示例中,我们选取的递减增量序列位[3,2,1]。
递减增量序列已经有了,下面开始进行3趟(增量序列长度为3)排序,先取增量序列第一个值3,然后将初始序列分组,如下:
对三组子序列[4,2,7],[5,3,1],[8,9]分别使用插入排序,结果如下:
然后,对该序列再次进行增量序列的分组,这次增量序列的值为2,分组情况如下:
对两组子序列分别使用插入排序,结果如下:
最后,对整个序列做插入排序(增量序列值为1)即可。
从整个过程可以看出,每次的排序,都会将较小的值转移到序列的前边,整个序列的有序性不断的变强,可以使插入排序达到更高的效率。
希尔排序的效率依赖于递减增量序列的选择,时间复杂度最坏的情况是O(nlog2n)。
typedef int Elementtype;
struct forsort
{
Elementtype key;
};
typedef struct forsort Forsort;
void InitForsort(Forsort *FS,int a)
{
FS->key = a;
}
//shell排序的思想是先预选一个数s然后把记录分为S个组,
//所有距离为S的数据分在一个组里面,然后取s2=s>>1;再重复上述过程直到最后si = 1
void Shellsort(Forsort A[],int n,int s)
{
int i,j,k;
Forsort temp;
//分组排序,初始的增量为S,每循环一次增量减半,直到增量为0时结束
for(k = s;k>0;k>>1) // k>>1的意思就是k/=2; 只是这个k>>1的写法会加快运行速度
{
for(i=k;i<n;i++)
{
temp = A[i];
j = i - k;
while(j>=0&&temp.key<A[j].key)
{
A[j+k]=A[j];
j-=k;
}
A[j+k] = temp;
}
}
}
基数排序
基数排序(radix sort)属于“分配式排序”(distribution sort),又称“桶子法”(bucket sort)或binsort,顾名思义,它是透过键值的部份资讯,将要排序的元素分配至某些“桶”中,藉以达到排序的作用,基数排序法是属于稳定性的排序
假设有欲排数据序列如下所示:73 22 93 43 55 14 28 65 39 81首先根据个位数的数值,在遍历数据时将它们各自分配到编号0至9的桶(个位数值与桶号一一对应)中。分配结果(逻辑想象)如下图所示:
分配结束后。接下来将所有桶中所盛数据按照桶号由小到大(桶中由顶至底)依次重新收集串起来,得到如下仍然无序的数据序列:
81 22 73 93 43 14 55 65 28 39
接着,再进行一次分配,这次根据十位数值来分配(原理同上),分配结果(逻辑想象)如下图所示:
//基数排序
#define Max_ 10 //数组个数
#define RADIX_10 10 //整形排序
#define KEYNUM_31 31 //关键字个数,这里为整形位数
//找到num从低到高的第pos位数据
int getnuminpos(int num,int pos)
{
int temp = 1;
for(int i;i<pos-1;i++)
temp *=10;
return (num/temp)%10;
}
//基数排序 pDataArray 无序数组;iDataNum为无序数据个数
void radixsort(int *pDataArray,int iDataNum)
{
int *radixArrays[RADIX_10]; //分别为0~9的序列空间,是个二维数组
for(int i = 0;i<10;i++)
{
radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
radixArrays[i][0] = 0; //index为0处记录这组数据的个数
}
for (int pos = 1; pos <= KEYNUM_31; pos++) //从个位开始到31位
{
for (int i = 0; i < iDataNum; i++) //分配过程
{
int num = GetNumInPos(pDataArray[i], pos);
int index = ++radixArrays[num][0];
radixArrays[num][index] = pDataArray[i];
}
for (int i = 0, j =0; i < RADIX_10; i++) //收集
{
for (int k = 1; k <= radixArrays[i][0]; k++)
pDataArray[j++] = radixArrays[i][k];
radixArrays[i][0] = 0; //复位
}
}
}