常用排序算法总结与代码实现(C语言)

一、直接插入排序

InsertSort(A)
1.  for i←2 to n do
2.       key ← A[i]
3.       j ←i-1
4.       while(j>0 && A[j]>key) do
5.              A[j+1] ← A[j]
6.              j ←j-1
7.       A[j+1] ← key
8.  return A

最好时间复杂度：O(n) 平均时间复杂度：O(n^2) 最坏时间复杂度:O(n^2) 辅助空间：O(1) 稳定性:稳定

二、冒泡排序

BubbleSort(A)
1.  for i ← 1 to length[A]
2.     do for j ← length[A] to i+1
3.          do  if  A[j] < A[j-1]
4.                 then exchange A[j] <-> A[j-1]

注：具体实现时可加个判断标志flag，如果有一遍没有交换时则直接退出，这样可以在初始数据为有序时在O(n)时间内即可排好。

改动如下：

BubbleSort(A)
1.    for i ← 1 to length[A]
2.    flag ← false
3.     do for j ← length[A] to i+1
4.                do if A[j] > A[j-1]
5.                        then exchange A[j] <-> A[j-1]
6.                         flag ← true
7.    if(!flag)
8.           break;

最好时间复杂度：O(n) 平均时间复杂度：O(n^2) 最坏时间复杂度:O(n^2) 辅助空间：O(1) 稳定性:稳定

三、选择排序

SelectionSort(i)
1.    if i>=n then return 0
2.    else
3.           k ← i
4.           for j ← i+1 to n do
5.              if A[j] < A[k] then
6.                  k ← j
7.           if k!=i  then A[i] <-> A[k]
8.           SelectionSort(i+1)

最好时间复杂度：O(n^2) 平均时间复杂度：O(n^2) 最坏时间复杂度:O(n^2) 辅助空间：O(1) 稳定性:不稳定

四、快速排序

QuickSort(A,p,r)
1.    if p<r
2.           then  q ← Partition(A,p,r)
3.           QuickSort(A,p,q-1)
4.           QuickSort(A,q+1,r)

Partition(A,p,r)
1.    x ← A[r]
2.    i ← p-1
3.    forj ← p to r-1
4.           do if A[j] <= x
5.                  then  i ← i+1
6.                        exchange A[i] <-> A[j]
7.    exchange A[i+1] <-> A[r]
8.    return i+1

注：Partition在选择关键字x时可用随机选择而不是固定选择最后一个A[r]，这样可防止快排遇到有序序列时时间复杂度变高。

例如：key = Random(p,r);

exchange A[key] <->A[r];

x ← A[r];

最好时间复杂度：O(nlogn)平均时间复杂度：O(nlogn)最坏时间复杂度:O(n^2)辅助空间：O(logn) 稳定性:不稳定

五、合并排序

MergeSort(A,p,r)
1.    if p<r then
2.           q← (p+r)/2 //向下取整
3.           MergeSort(A,p,q)
4.           MergeSort(A,q+1,r)
5            Merge(A,p,q,r)

Merge(A,p,q,r)
1.    n1 ← q-p+1
2.    n2 ← r-q
3.    for i ← 1 to n1 do
4.           L[i]← A[p+i-1]
5.    for j ← 1 to n2 do
6.           R[j]← A[q+j]
7.    L[n1+1]← 0xFFFFFF //取无穷大的意思
8.    R[n2+1]← 0xFFFFFF
9.    i← 1
10.   j ← 1
11.   for k ← p to r do
12.          if L[i] <= R[j] do
13.                 A[k]← L[i]
14.                 i← i+1
15.          else
16.                 A[k]← R[j]
17.                 j← j+1

最好时间复杂度：O(nlogn)平均时间复杂度：O(nlogn)最坏时间复杂度:O(nlogn)辅助空间：O(n) 稳定性:稳定

六、堆排序

HeapSort(A)
1.    Build-Max-Heap(A)
2.    for j ← length[A] downto 2
3.           do  exchange A[1] <->A[j]
4.                  heap-Size[A]← heapSize[A] – 1
5.                  Max-Heapify(A,1)

Build-Max-Heap(A)
1.    heap-Size[A]← leagth[A]
2.    for i ← leagth[A]/2 downto 1
3.           do Max-Heapify(A,i)

Max-Heapify(A,i)
1.    l← LEFT(i)   //LEFT(i)代表取i的左孩子的下标2i
2.    r← RIGHT(i)//RIGHT(i)代表取i的右孩子的下标2i+1
3.    if l< heap-size[A] and A[l]>A[i]
4.           then largest ← l
5.    else  largest ← i
6.    if r<heap-size[A] and A[r] >A[largest]
7.           then   largest ← r
8.    if largest != i
9.           then   exchange A[largest] <-> A[i]
10.                 Max-Heapify(A,largest)

最好时间复杂度：O(nlogn)平均时间复杂度：O(nlogn)最坏时间复杂度:O(nlogn)辅助空间：O(1) 稳定性:不稳定

七、排序算法的C语言实现

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX 10
int L[MAX];
int R[MAX];

void Print(int a[]){

int i;

for(i=0;i<MAX;i++){
printf("%d ",a[i]);
}

printf("\n");
}

void Swap(int *a,int *b){
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}

/*--直接插入排序--*/
void InsertSort(int a[]){

int i,j,tmp;
for(i=1;i<MAX;i++){
tmp=a[i];
j=i-1;
while(j>=0 && a[j] >tmp){
a[j+1] = a[j];
j--;
}
a[j+1] = tmp;
}
}

/*--冒泡排序--*/
void BubbleSort(int a[]){
int i,j;
bool flag;

for(i=0;i< MAX-1;i++){
flag =false;

for(j=MAX-1;j>i;j--){
if(a[j] < a[j-1]){
Swap(&a[j],&a[j-1]);
flag = true;
}
}

if(!flag){
return;
}
}
}

/*--简单选择排序--*/
void SelectSort(int a[]){
int i,j,tmp;
int min,flag=0;

for(i=0;i<MAX-1;i++){
min=a[i];
flag=i;
for(j=i+1;j<MAX;j++){
if(a[j] < min){
flag = j;
min = a[j];
}
}

if(flag != i){
tmp=a[flag];
a[flag] = a[i];
a[i]=tmp;
}
}
}

/*--快速排序--*/
int Partition(int a[],int p,int r){

int key;
int i,j;

key = p+rand()%(r-p+1);
Swap(&a[key],&a[r]);

key = a[r];
i=p-1;
for(j=p;j<r;j++){
if(a[j] <= key){
i++;
Swap(&a[i],&a[j]);
}
}
i++;
Swap(&a[i],&a[r]);

return i;

}

void QuickSort(int a[],int p,int r){
int q;
if(p<r){
q=Partition(a,p,r);
QuickSort(a,p,q-1);
QuickSort(a,q+1,r);
}
}

/*--合并排序--*/
void Merge(int a[],int low,int mid,int high){

int i,j,k;

int lenL = mid - low +1;
int lenR = high -mid;

for(i=0;i<lenL;i++){
L[i] = a[low+i];
}
for(j=0;j<lenR;j++){
R[j] = a[mid+j+1];
}

L[i] = 0xFFFFFFF;
R[j] = 0xFFFFFFF;

i=0;
j=0;
for(k=low;k<=high;k++){
if(L[i] <= R[j]){
a[k] = L[i];
i++;
}else{
a[k] = R[j];
j++;
}
}

}
void MergeSort(int a[],int low,int high){
int mid;

if(low < high){
mid = (low+high)/2;
MergeSort(a,low,mid);
MergeSort(a,mid+1,high);
Merge(a,low,mid,high);
}
}

/*--堆排序--*/
void Max_Heapify(int a[],int start,int length){

int largest,l,r;

l = start*2;
r = l+1;
if(l<=length && a[l] > a[start]){
largest = l;
}else{
largest = start;
}
if(r<=length && a[r]>a[largest]){
largest = r;
}
if(largest != start){
Swap(&a[largest],&a[start]);
Max_Heapify(a,largest,length);
}
}

void HeapSort(int a[],int length){
int i;

//build-max-heap
for(i=length/2;i>=0;i--){
Max_Heapify(a,i,length);
}

//sort
for(i=length;i>0;i--){
Swap(&a[i],&a[0]);
Max_Heapify(a,0,i-1);
}
}

int main(){

int a[MAX];
int num,counter;

srand(time(NULL));

for(counter=0;counter<MAX;counter++){
a[counter]=rand()%100;
}

printf("原始数据顺序为:\n");
Print(a);

printf("1为InsertSort，2为BubbleSort，3为SelectSort\n");
printf("4为QuickSort，5为MergeSort，6为HeapSort\n");

scanf("%d",&num);

switch(num){

case 1:
InsertSort(a);
printf("InsertSort的排序结果为:\n");
break;
case 2:
BubbleSort(a);
printf("BubbleSort的排序结果为:\n");
break;
case 3:
SelectSort(a);
printf("SelectSort的排序结果为:\n");
break;
case 4:
QuickSort(a,0,MAX-1);
printf("QuickSort的排序结果为:\n");
break;
case 5:
MergeSort(a,0,MAX-1);
printf("MergeSort的排序结果为:\n");
break;
case 6:
HeapSort(a,MAX-1);
printf("HeapSort的排序结果为:\n");
break;
}

Print(a);
return 0;

}