1.冒泡排序
void Bubble_Sort(ElementType A[], int N)
{
for(P=N-1;P>=0;P--)
{
flag = 0;
for(i=0;i<P;i++)
{
if(A[i] > A[i+1])
{
Swap(A[i], A[i+1]);
flag = 1;
}
}
if(flag == 0)
break;
}
}
2.插入排序
void Insertion_Sort(ElementType A[], int N)
{
for(p=1;p<N;p++)
{
Tmp = A[p];
for(i=p;i>0&&A[i-1]>Tmp;i--)
A[i] = A[i-1];
A[i] = Tmp;
}
}
3.希尔排序
void Shell_Sort(ElementType A[], int N)
{
for(D=N/2;D>0;D/=2)
{
for(P=D;p<N;p++)
{
Tmp = A[p];
for(i=p;i>=D&&A[i-D]>Tmp;i-=D)
A[i] = A[i-D];
A[i] = Tmp;
}
}
}
/*
D可以取别的数:
Hibbard增量序列:Dk = 2^k-1
Sedgewick增量序列:9x4^i-9x2^i+1
*/
4.堆排序
/*
MaxSort(ElementType A[], int i, int N)
对A数组从i到0结点进行创建堆操作,N为A元素的个数
*/
void Heap_Sort(ElementType A[], int N)
{
for(i=N/2-1;i>=0;i--)
MaxSort(A,i,N);
for(i=N-1;i>0;i--)
{
Swap(&A[0],&A[i]);
MaxSort(A,0,i);
}
}
5.归并排序
递归算法:
void Merge_Sort(ElementType A[],int N)
{
ElementType *TmpA;
TmpA = malloc(N*sizeof(ElementType));
if(TmpA != NULL)
{
MSort(A,TmpA,0,N-1);
free(TmpA);
}
else
ERROR;
}
void MSort(ElementType A[],ElementType TmpA[], int L, int Rend)
{
int center;
if(L<Rend)
{
center = (L+Rend)/2;
Msort(A,TmpA,L,center);
Msort(A,TmpA,center+1,Rend);
Merge(A,TmpA,L,center+1,Rend);
}
}
void Merge(ElementType A[],ElementType TmpA[],int L,int R, int Rend)
{
// L是A左半起始元素,R是右半起始元素,Rend是右边结束
Lend = R-1;
Tmp = L;
NumElements = Rend -L +1;
while(L<=Lend && R<=Rend)
{
if(A[L] <= A[R])
TmpA[Tmp++] = A[L++];
else
TmpA[Tmp++] = A[R++];
}
while(L<=Lend)
TmpA[Tmp++] = A[L++];
while(L<=Rend)
TmpA[Tmp++] = A[R++];
for(i=0;i<NumElements;i++,Rend--)
A[Rend] = TmpA[Rend];
}
非递归算法:
void Merge_Sort(ElementType A[], int N)
{
ElementType *TmpA;
int length = 1;
TmpA = malloc(N*sizeof(ElementType));
if(TmpA!=NULL)
{
while(length<n)
{
Merge_Pass(a, tema, n, length);
length *= 2;
Merge_Pass(tema, a, n, length);
length *= 2;
}
free(TmpA);
}
else
ERROR;
}
void Merge_Pass(ElementType A[], ElementType TmpA[], int N, int length)
{
for(i=0;i<=N-2*length;i+=length*2)
Merge1(A, TmpA, i, i+length, i+2*length-1);
if(i+length<n)
Merge1(A, TmpA, i, i+length, n-1);
else
{
int j;
for(j=i;j<n;j++)
{
TmpA[j] = A[j];
}
}
}
void Merge1(ElementType A[],ElementType TmpA[],int L,int R, int Rend)
{
// L是A左半起始元素,R是右半起始元素,Rend是右边结束
Lend = R-1;
Tmp = L;
while(L<=Lend && R<=Rend)
{
if(A[L] <= A[R])
TmpA[Tmp++] = A[L++];
else
TmpA[Tmp++] = A[R++];
}
while(L<=Lend)
TmpA[Tmp++] = A[L++];
while(L<=Rend)
TmpA[Tmp++] = A[R++];
}
6.快速排序
//当数据规模较小时还不如用插入排序,因为快速排序是递归算法
void Quick_Sort(ElementType A[], int N)
{
QucikSort(A,0,N-1);
}
void QuickSort(ElementType A[], int Left, int Right)
{
int cutoff = 100;
if(cutoff<=Right-Left)
{
pivot = Median3(A,Left,Right);
i = Left;
j = Right - 1;
for( ; ; )
{
while(A[++i] < pivot)
;
while(A[--j] > pivot)
;
if(i < j)
Swap(&A[i], &A[j]);
else
break;
}
Swap( &A[i], &A[Right-1]);
QuickSort(A,Left,i-1);
QuickSort(A,i+1,Right);
}
else
Insertion_Sort(A+Left,Right-Left+1);
}
// 选取头、中、尾的中位数作为主元
ElementType Median3(ElementType A[], int Left, int Right)
{
int Center = (Left + Right)/2;
if(A[Left] > A[Center])
Swap(&A[Left], &A[Center]);
if(A[Left] > A[Right])
Swap(&A[Left], &A[Right]);
if(A[Center] > A[Right])
Swap(&A[Center], &A[Right]);
Swap(&A[Center], &A[Right-1]);
return A[Right-1];
}
7.基数排序
桶排序:N>>M
N=4000个学生,成绩[0,100]即M=101,对学生按成绩排序,构造成绩数组(成绩101个选大小101),T=o(M)
基数排序:M>>N
N=10个整数,每个整数[0,999],对整数排序,构造基数数组(十进制选大小10),根据各位、十位、百位(次位优先)进行排序
表排序
本质:要通过key进行排序,但是元素的“体积”过大,不适合直接swap,定义一个指针table,table的值的顺序就是相应index的元素的顺序。即A[table[0]]…A[ table[i]]就是排好序后的顺序。
如果这样排好序后,非要在物理位置上即非要swap排好序,那么有个结论:N个数字的排列由若干个独立的环组成,如图8个数字,由3个环组成,(eg:红环table[0]=3 -> table[3]=1 -> table[1]=5 -> table[5]=0 形成一个环)
所以swap时只要把环的第一个元素 (A[0]即f) 先拿出来,让后面的元素依次移位并设置table[i] = i,最后拿出来的元素放入空出来的位置(即A[5],此时判断table[0] = 0,满足table[i] = i即一个环结束),再照样处理下个环,最终完成。