排序类别 平均时间复杂度 最坏时间复杂度 空间复杂度 稳定性
插入排序 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);
}
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
