一、直接插入排序
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;
}
1546
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
