排序类别 平均时间复杂度 最坏时间复杂度 空间复杂度 稳定性
插入排序 O(n^2) / 1 √
希尔排序 O(nlogn) O(n^s) 1<s<2 1 ×
冒泡排序 O(n^2) / 1 √
选择排序 O(n^2) / 1 ×
快速排序 O(nlogn) O(n^2) O(logn) ×
堆排序 O(nlogn) / 1 ×
归并排序 O(nlogn) / O(n) √
排序算法总结(1)——冒泡排序
冒泡排序(属于交换排序) 时间复杂度为: O(n^2)
(1)第一种冒泡排序法:
void BubbleSort(int s[],int n)
{
int i,j,temp;
for(i=0 ; i<n-1 ; i++)
{
for(j=0 ; j<n-i-1 ; j++) /* 按照从小到大的顺序排列 */
{
if(s[j] > s[j+1])
{
temp=s[j];
s[j]=s[j+1];
s[j+1]=temp;
}
}
}
}
(2)第二种冒泡排序法:
void BubbleSort(int s[],int n)
{
int i,j,temp;
for(i=0 ; i<n-1 ; i++)
{
for(j=i+1 ; j<n ; j++) /* 按照从小到大的顺序排列 */
{
if(s[i] > s[j])
{
temp=s[i];
s[i]=s[j];
s[j]=temp;
}
}
}
}
以上两种都是一般的以交换为主要操作的冒泡排序,执行次数为:
(n-1)+(n-2)+(n-3)+……+3+2+1 = (n-1)*n/2 = (n^2 - n)/2
即时间复杂度为: O(n^2)
已排好序的冒泡排序
//对n个元素的序列进行冒泡排序时,最少的比较次数是:(n-1)。
#include <stdio.h>
void main()
{
int i , j ;
int a[10] = {9,8,7,6,5,4,3,2,1,0};
int len = sizeof(a)/sizeof(a[0]);
int iCount = 0 ; //每一趟的交换次数
int sCount = 0 ; //总共的交换次数
int nCount = 0 ; //总共的比较次数
int temp ;
for (i = 0 ; i < len-1 ; i++)
{
iCount = 0 ;
for (j = 0 ; j < len - i -1 ; j++)
{
if (a[j+1] > a[j])
{
temp = a[j+1];
a[j+1] = a[j];
a[j] = temp ;
iCount++ ;
}
nCount++ ;
}
if (iCount == 0)
{
break ;
}
sCount = sCount + iCount ;
}
for (i = 0 ; i < len ; i++)
{
printf("%d ",a[i]);
}
printf("\n");
printf("总共的比较次数:%d\n",nCount);
printf("总共的交换次数:%d\n",sCount);
}
#include <stdio.h>
void main()
{
int i , j ;
int a[10] = {4,8,5,6,7,4,2,2,1,0};
int len = sizeof(a)/sizeof(a[0]);
int iCount = 0 ; //每一趟的交换次数
int sCount = 0 ; //总共的交换次数
int nCount = 0 ; //总共的比较次数
int temp ;
for (i = 0 ; i < len-1 ; i++)
{
iCount = 0 ;
for (j = i+1 ; j < len ; j++)
{
if (a[j] < a[i])
{
temp = a[j];
a[j] = a[i];
a[i] = temp ;
iCount++ ;
}
nCount++ ;
}
if (iCount == 0)
{
break ;
}
sCount = sCount + iCount ;
}
for (i = 0 ; i < len ; i++)
{
printf("%d ",a[i]);
}
printf("\n");
printf("总共的比较次数:%d\n",nCount);
printf("总共的交换次数:%d\n",sCount);
}
排序算法总结(2)——选择排序
每趟先从s[i]+1~s[n-1]找出最大元素或者最小元素,与s[i]进行比较、交换;
总的比较次数为: n(n-1)/2,即时间复杂度为: O(n^2)。
void SelectSort(int s[],int n)
{
int i,j,kmin,temp;
for(i=0;i<n-1;++i)
{
kmin=i;
for(j=i+1;j<n;++j)
{
if(s[j]<s[kmin])
{
kmin=j;
}
}
if(kmin!=i)
{
temp=s[i];
s[i]=s[kmin];
s[kmin]=temp;
}
}
}
以上为简单的选择排序,后面还会有树形选择排序,堆排序——另一种选择排序。
排序算法总结(3)——插入排序
(一)直接插入排序
①第一种直接插入排序 时间复杂度: O(n^2)
void InsertionSort(int input[],int len) /* 按照升序排列 */
{
int i,j,temp;
for (i = 1; i < len; i++)
{
temp = input[i]; /* 操作当前元素,先保存在其它变量中 */
for (j = i - 1;j>-1&&input[j] > temp ; j--) //从当前元素的上一个元素开始查找合适的位置
{
input[j + 1] = input[j]; /* 一边找一边移动元素 */
input[j] = temp;
}
}
}
②第二种直接插入排序 时间复杂度: O(n^2)
void InsertSort(int s[],int n)
{
int key=0,i,j;
if(s[1]<s[0])
{
key=s[1];
s[1]=s[0];
s[0]=key;
}
for(i=2;i<n;i++)
{
if(s[i]<s[i-1])
{
key=s[i];
for(j=i-1;j>-1&&key<s[j];--j)
{
s[j+1]=s[j];
}
s[j+1]=key; /* 比上一种好一些,执行的操作少 */
}
}
}
(二)带哨兵的直接插入排序 时间复杂度: O(n^2)
/* 带哨兵的直接插入排序,数组的第一个元素不用于存储有效数据
* 将input[0]作为哨兵,可以避免判定input[j]时,数组是否越界
* 因为在j--的过程中,当j减小到0时,变成了input[0]与input[0]
* 自身进行比较,很明显这个时候说明位置i之前的数字都比input[i]小
* 位置i上的数字不需要移动,直接进入下一轮的插入比较。
*/
void InsertionSortWithPiquet(int input[],int len)
{
int i,j;
/* 保证数组input第一元素的存储数据无效,从第二个数据开始与它前面的元素比较 */
for (i = 2; i < len; i++)
{
input[0] = input[i];
for (j = i - 1; input[j] > input[0] ; j--)
{
input[j + 1] = input[j];
input[j] = input[0]; /* input[j]一直都是排序的元素中最大的那一个 */
}
}
}
(三)折半插入(二分插入)排序 时间复杂度: O(n^2)
void HalfInsertSort(int a[], int len)
{
int i, j,temp;
int low, high, mid;
for (i=1; i<len; i++)
{
temp = a[i];/* 保存当前元素 */
low = 0;
high = i-1;
while (low <= high) /* 在a[low...high]中折半查找有序插入的位置 */
{
mid = (low + high) / 2; /* 找到中间元素 */
/* 如果中间元素比当前元素大,当前元素要插入到中间元素的左侧 */
if (a[mid] > temp)
{
high = mid-1;
}
else /* 如果中间元素比当前元素小,当前元素要插入到中间元素的右侧 */
{
low = mid+1;
}
} /* 找到当前元素的位置,在low和high之间 */
for (j=i-1; j>high; j--)/* 元素后移 */
{
a[j+1] = a[j];
} /* j == high */
a[high+1] = temp; /* 插入到high后 */
}
}
(四)希尔排序(ShellSort) 时间复杂度: O(nlogn)
希尔排序(Shell Sort)是插入排序的一种。是针对直接插入排序算法的改进。该方法又称缩小增量排序,因DL.Shell于1959年提出而得名。
该方法实质上是一种分组插入方法。
void sort(int v[],int n)
{
int gap,i,j,temp;
/*设置排序的步长,步长gap每次减半(也可以步长gap每次减2: gap -= 2),直到减到1 */
for(gap=n/2;gap>0;gap /= 2)
{
for(i=gap;i<n;i++) /* 定位到每一个元素 */
{
/* 比较相距gap远的两个元素的大小,根据排序方向决定如何调换 */
for(j=i-gap;(j >= 0) && (v[j] > v[j+gap]);j -= gap )
{
temp=v[j];
v[j]=v[j+gap];
v[j+gap]=temp;
}
}
}
}
后面还有 2-路插入排序、表插入排序。。
排序算法总结(4)——快速排序
平均时间复杂度: O(nlogn) 最坏时间复杂度: O(n^2)
①第一种快速排序(QuickSort) (属于交换排序)
快速排序时对冒泡排序的一种改进。由C.A.R.Hoare在1962年提出。它的长基本思想是:
通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据要要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
int part(int s[],int low,int high)
{
int i = low, j = high , key = s[i] , temp ;
while (i < j)
{
while(i<j&&s[j]>=key)
{
--j;
}
if (i < j)
{
temp = s[i] ;
s[i] = s[j] ;
s[j] = temp ;
}
while (i<j&&s[i]<=key)
{
++i;
}
if (i < j)
{
temp = s[i] ;
s[i] = s[j] ;
s[j] = temp ;
}
}
return (i);
}
void QuickSort(int s[],int low,int high)
{
if(low<high)
{
int pi=part(s,low,high);
QuickSort(s,low,pi-1);
QuickSort(s,pi+1,high);
}
}
②第二种快速排序
/*
- 首先选一个中间值,第一个元素data[low],然后从该元素的
- 最右侧开始找到比它小的元素,把该元素复制到它中间值原来
- 的位置(data[low]=data[high]),然后从该元素的最左侧
- 开始找到比它大的元素,把该元素复制到上边刚刚找到
- 的那个元素的位置(data[high]=data[low]),最后将
- 这个刚空出来的位置装入中间值(data[low]=mid),
- 这样一来比mid大的都会跑到mid的右侧,
- 小于mid的会在左侧,最后一行,返回的low是
- 中间元素的位置,左右分别递归就可以排好序了。
*/
int Partition(int data[],int low,int high)
{
int mid=data[low];
while(low < high)
{
/* 从high的位置开始往low的方向找,找到比data[low]小的元素,存到data[low]中 */
while((low < high) && (data[high] >= mid)) { --high; }
if (low < high)
{
data[low]=data[high];
}
/* 从low的位置开始往high的方向找,找到比data[high]大的元素,存在data[high]中 */
while((low < high) && (data[low] < mid)) { ++low; }
if (low < high)
{
data[high]=data[low];
}
}
data[low] = mid; /* 在新的low位置 存上原来的data[low]的数据 */
return low; /* 递归时,把它做为右侧元素的low */
}
/* n 个元素被分成三段(组):
- 左段left,右段right和中段middle。中段仅包含一个元素。
- 左段中各元素都小于等于中段元素,右段中各元素都大于等于
- 中段元素。因此left和right中的元素可以独立排序,
- 并且不必对left和right的排序结果进行
- 合并。使用快速排序方法对a[0:n-1]
- 排序,从a[0:n-1]中选择一个元素作为middle,该元素为支点,
- 把余下的元素分割 为两段left和right,使得left中的
- 元素都小于等于支点,而right中的元素都大于
- 等于支点,递归地使用快速排序方法对left
- 进行排序,递归地使用快速排序方法对right进行排序,
- 所得结果为left+middle+right
- /
void Quick_sort(int data[],int low,int high)
{
int mid;
if(low<high)
{
mid=Partition(data,low,high);
Quick_sort(data,low,mid-1); /* 递归调用 */
Quick_sort(data,mid+1,high);
}
}
排序算法总结(5)——堆排序
时间复杂度: O(nlogn)
/********************************************************************
- 堆的定义: n 个元素的序列 {k1,k2,…,kn}当且仅当满足下列关系时,称为堆:
- ki<=k2i ki<=k2i+1 (i=1,2,…,n/2)
- 或
- ki>=k2i ki>=k2i+1 (i=1,2,…,n/2)
- 堆排序思路:
- 建立在树形选择排序基础上;
- 将待排序列建成堆(初始堆生成)后,序列的第一个元素(堆顶元素)就一定是序列中 的最大元素;
- 将其与序列的最后一个元素交换,将序列长度减一;
- 再将序列建成堆(堆调整)后,堆顶元素仍是序列中的最大元素,再次将其与序列最后 一个元素交换并缩短序列长度;
- 反复此过程,直至序列长度为一,所得序列即为排序后结果。
***********************************************************************/
void HeapAdjust(int data[],int root,int m) /* 排列成堆的形式 */
{
int j,rc;
rc = data[root]; /* 保存处理元素 */
for(j = 2*root ; j <= m ; j = 2*j) /* 处理父亲元素 */
{
if(j < m && data[j] < data[j+1]) ++j; /* 取较大的孩子结点 */
if(rc > data[j]) break;
/* 父结点比较大的孩子结点大则互换 ,保证父结点比所有子结点都大(父结点存储在前面)*/
data[root] = data[j];
root = j;
}
data[root] = rc; /* 相当于data[j]=rc */
}
void Heap_sort(int data[],int len) /* 堆排序函数 */
{
int i , temp;
for(i = len/2 ; i > 0 ; --i)
{
HeapAdjust(data,i,len); /* 处理后,data[i]是这个数组后半部分的最大值 */
}
for(i = len ; i > 0 ; --i)/* 把根元素(剩下元素中最大)放到结尾 ,下一次只要排剩下的数就可以啦*/
{
temp = data[1];
data[1] = data[i];
data[i] = temp;
HeapAdjust(data,1,i-1);
}
}
在实现时,数组下标从零开始,所以做了如下相应的改变。
void HeapAdjust(int data[],int root,int m) /* 排列成堆的形式 */
{
int j,rc;
rc = data[root]; /* 保存处理元素 */
for(j = 2*root+1 ; j <= m ; j = 2*j+1) /* 处理父亲元素 */
{
if(j < m && data[j] < data[j+1]) /* 取较大的孩子结点 */
{
++j;
}
if(rc > data[j])
{
break;
}
data[root] = data[j];
root = j;
}
data[root] = rc; /* 相当于data[j]=rc */
}
void Heap_sort(int data[],int len) /* 堆排序函数 */
{
int i , temp;
for(i = (len-1)/2 ; i >= 0 ; --i)
{
HeapAdjust(data,i,len-1); /* 处理后,data[i]是这个数组后半部分的最大值 */
}
for(i = len-1 ; i >= 0 ; --i)
{
temp = data[0];
data[0] = data[i];
data[i] = temp;
HeapAdjust(data,0,i-1);
}
}
void main()
{
int len = sizeof(a)/sizeof(a[0]) ;
Heap_sort(a,len);
}