1简单插入排序:
void Insert_Sort(ElementType A[], int N) {
for(P=1; P<N; P++) {
Tmp = A[P];//摸下一张牌
for(i=P; i>0 && A[P-1]>Tmp; i--) {
A[i] = A[i-1];//移出空位
}
A[i] = Tmp;//新牌位置
}
}
最好情况:T=O(N)
最坏情况:T=O(
N2
)
2希尔排序
希尔排序又称”缩小增量排序”。定义增量序列
Dm
>
Dm−1
>
…
>
D1
= 1
void ShellSort(ElementType A[], int N) {
int Si, D, P, i;
ElementType Tmp;
int Dedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};//使用Dedgewick增量序列
for(Si=0; Sedgewick[Si]>=N; Si++) ;
for(D=Sedgewick[Si]; D>0; D=Sedgewick[++Si]) {
for(P=D; P<N; P++){
Tmp = A[P];
for(i=P; i>=0 && A[i-D]>Tmp; i-=D) {
A[i] = A[i-D];
}
A[i] = Tmp;
}
}
}
Hibbard增量序列:
Dk
=
2k
-1 相邻元素互质
最坏情况:T=O(
N3/2
)
平均情况:T=O(
N5/4
)
Sedgewick增量序列
{1,5,19,109,
…
}
9x
4i
-9x
2i
+1 或者
4i
-3x
2i
+1
最坏情况:T=O(
N4/3
)
平均情况:T=O(
N7/6
)
3选择排序
基本思路是每一趟在n-i+1个记录中选择最小的记录作为第i
个元素。
void Selection_Sort(ElementType A[], int N) {
for(i=0; i<N; i++) {
MinPosition = ScanForMin(A, i, N-1);
Swip(A[i], A[MinPosition]);
}
}
时间复杂度T(
N2
)
堆排序一种树形选择排序,只需要一个记录大小的存储空间
void Swap(ElementType *a, ElementType *b) {
ElementType t = *a;
*a = *b;
*b = t;
}
void PercDown(ElementType A[], int P, int N) {
int Parent, Child;
ElementType X;
X = A[P];
for(Parent=P; (Parent*2+1)<N; Parent = Child) {
Child = Parent*2+1;
if(((Child!=N-1) && (A[Child]<A[Child+1]))) {
Child+=1;
}
if(X >= A[Child])break;//找到合适位置
eles A[Parent] = A[Child];
}
A[Parent] = X;
}
void HeapSort(ElementType A[], int N) {
int i=1;
for(i=N/2-1; i>=0; i--) {//建立最大堆
PercDown(A, i, N);
}
for(i=N-1; i>0; i--) {
Swap(&A[0], &A[i]);
PercDown(A, 0, i);
}
}
最好情况:T=O(NlogN)
最坏情况:T=O(NlogN)
4快速排序
快排采用分治思想将一个序列分成两个子序列。
void Qsort(ElementType A[], int Left; int Right) {
int Pivot, Low, High;
Pivot = Median3(A, Left, Right);//选取基准
Low = Left; High = Right-1;
while(1) {
while(A[Low++] < Pivot){}
while(A[High--] > Pivot){}
if(Low < High) Swap(&A[Low], &A[High]);
else break;
}
Swap(&A[Low], &A[Right-1]);
Qsort(A, Left, Low-1);
Qsort(A, Low+1, Right);
}
最好情况:T=O(NlogN)
最坏情况:T=O(N2)
5归并排序
void Marge(ElementType A[], ElementType TmpA[], int L, int R, int RightEnd) {
int LeftEnd, NumElements, Tmp;
int i;
LeftEnd = R - 1;
Tmp = L;
NumElements = RightEnd - L - 1;
while(L<=LeftEnd && R<=RightEnd) {
if(A[L] <= A[R]) {
TmpA[Tmp++] = A[L++];
} else {
TmpA[Tmp++] = A[R++];
}
}
while(L <= LeftEnd) {
TmpA[Tmp++] = A[L++];
}
while(R <= RightEnd) {
TmpA[Tmp++] = A[R++];
}
for(i=0; i<NumElements; i++, RightEnd--) {
A[RightEnd] = TmpA[RightEnd];
}
}
void Msort(ElementType A[], ElementType TmpA[], int L, int RightEnd) {
int center;
if(L < RightEnd) {
center = (L+RightEnd)/2;
Msort(A, TmpA, L, Center);
Msort(A, TmpA, Center+1, RightEnd);
Marge(A, TmpA, L, Center+1, RightEnd);
}
}
时间复杂度T( N ) = O( N logN ),需要额外空间O(N)
6基数排序
输入序列:64, 8, 216, 512, 27, 729, 0, 1, 343, 125 。T=O(P(N+B))
//基数排序
#define MaxDigit 4//关键字个数
#define Radix 10//基数
typedef struct Node *PtrToNode;
strut Node{
int key;
PtrToNode next;
};//桶元素节点
struct HeadNode {
PtrToNode head, tail;
};//桶头结点
typedef strut HeadNode Bucket[Radix];
int GetDigit(int X, int D) {
int d, i;
for(i=1; i<=D; i++) {
d = X%Radix;
x /= Raddix;
}
return d;
}
void LSDEadixSort(ElementType A[], int N) {
int D, Di, i;
Bucket B;
PtrToNode tmp, p, List = NULL;
for(i=0; i<Radix; i++) {
B[i].head = B[i].tail = NULL;
}
for(i=0; i<N; i++) {
tmp = (PtrToNode)malloc(sizeof(struct Node));
tmp->key = A[i];
tmp->next = List;
List = tmp;
}
for(D=1; D<=MaxDigit; D++) {
p = List;
while(p) {
Di = GetDigit(p->key, D);//获取当前元素的当前数字
tmp=p; p=p->next;
tmp->next = NULL;
if(B[Di].head == NULL) {
B[Di].head = B[Di].tail = tmp;
} else {
B[Di].tail->next = tmp;
B[Di].tail = tmp;
}
}
List = NULL;
for(Di=Radix-1; Di>=0; Di--) {//将每个桶的元素顺序收集入List
if(B[Di].head) {//整桶插入List表头
B[Di].tail->next = List;
List = B[Di].head;
B[Di].head = B[Di].tail = NULL;//清空桶
}
}
}
for(i=0; i<N; i++) {
tmp = List;
List = List->next;
A[i] = tmp->key;
free(tmp);
}
}
平均时间复杂度O(P(N+B)),空间复杂度O(N+B)