八大排序2021/5/15

1.选择排序

•  简单选择
• 堆排序

2.插入排序

•   简单插入排序
• 希尔排序 

3.交换排序

•   冒泡排序
• 快速排序 

4.归并排序

5.基数排序 

 

 

代码

• 简单选择排序

void  SimpleSelectionSort(ElementType A[],int N){
	int i,j,min;
	foe(i=1;i<N;i++){
		min=i;
		for(j=i+1;j<N;j++)
			if(A[j]<A[min])
				min=j;
		swap(&A[i],&A[min]);
	}
} 

 

• 堆排序

void PercDown(ElementType A[],int p,int N){
	ElementType X;
	int Parent,Child;
	
	X=A[p];
	for(Parent=p;(Parent*2+1)<N;Parent=Child){
		Child=Parent*2+1;
		if((Child!=N-1)&&A[Child+1]>A[Child])
			Child++;
		if(X>=A[Child]) break;
		else A[Parent]=A[Child];
	} 
	A[Parent]=X;
	
} 

void HeapSort(ElementType A[],int N){
	int i;
	
	for(i=N/2-1;i>=0;i--)	//建立最大堆 
		PercDown(A,i,N);
		
		
	for(i=N-1;i>0;i--){		//删除最大堆顶 
		swap(&A[0],&A[i]);	//把最大堆顶点（是最大值）与堆的最后一个点交换 （N-1是最后一个元素） 
		PercDowm(A,0,i);	//重新变成最大堆 
	}
}

 

•  简单插入排序

 

void InsertionSort(ElementType A[],int N){
	int i,P;
	ElementType Tmp;
	for(P=1;P<N;P++){
		Tmp=A[i];
		for(i=P;i>0&&A[i-1]>A[i];i--)
			A[i]=A[i-1];
		A[i]=Tmp;
	}
}

• 希尔排序

void ShellSort(ElementType A[],int N){
	int Si,D,P,i;
	ElementType Tmp;
	int Sedgewick[]={929,465,31,5,3,1};
	
	for(Si=0;Sedgewick[Si]>=N;Si++);		//增量不能大于N
	
	for(D=Sedgewick[Si];D>0;D=Sedgewick[++Si]) {	//增量大于0 
		for(P=D;P<N;P++){	//从A[D]到后边的每一个元素都要循环一便 
			Tmp=A[P];
			for(i=P;i>=D&&A[i-D]>Tmp;i-=D)	//比较与i相差D个位置的元素 
				A[i]=A[i-D];
			A[i]=Tmp;
		}
	}
}

 

•  冒泡排序

void BubbleSort(ElementType A[],int N){
	int P,i;
	bool falg;
	for(P=N-1;i>=0;i--){
		flag=false;
		for(i=0;i<P;i++){
			if(A[i]>A[i+1]){
				swap(&A[i],&A[i+1]);
			}
			flag=true;
		}
	}
}

 

•  快速排序

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]);
	
	//此时的情况为A[Left]>=A[Center]>=A[Right]
	
	swap(&A[Center],&A[Right-1]);	//交换了基准和倒数第二个元素，因为倒数第一个已经不用再考虑他的情况了
	//此后只需要考虑A[Left+1]和A[Right-2]之间的情况
	return A[Right-1];	//返回基准 
}

void Qsort(ElementType A[], int Left, int Right){
	int Cutoff,Low,High,Pivot;	//Cutoff是自己定的一个数，当序列元素大于他时，才进行快速排序
	if(Cutoff<=Right-Left)		//应该为Right-Left+1才表示序列元素的个数？
	{
		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);
	 } 
	 else InsertionSort(A+Left,Right-Left+1);	// 
	
}

void QuickSort(ElementType A[],int N){
	Qsort(A, 0 ,N-1);
}

•  归并排序

//方法是把一个数组中元素分而治之，然后合并两端有序的序列（用递归的思想） 
void Merge(ElementType A[],ElementType TmpA[], int L, int R,int RightEnd){
	int LeftEnd,tmp,NumElements,i;
	tmp=L;
	NumElements=RightEnd-L+1;
	LeftEnd=R-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);
		Merge(A,TmpA,L,Center+1,RightEnd);
	}
	
}

void MergeSort(ElementType A[],int N){
	ElementType* TmpA;
	TmpA=(ElementType*)malloc(N*sizeof(ElementType));
	if(TmpA!=NULL){
		Msort(A,TmpA,0,N-1);
		free(TmpA);
	}
	else printf("空间不足\n");
	
	
}

• 基数排序

//1.初始化每个桶为空链表
//2.将原始序列逆序存入链表
//3.根据每一位进行排序
	//1.把链表的每一个数，根据基数放入相应的桶
	//2.把桶里的元素收集为链表
//4.把最后排好序的链表倒进数组中
#define MaxDight 4
#define Radix 10

typedef struct Node PtrToNode;
struct Node{	//桶元素 
	int key;
	PtrToNode next;
}; 

struct HeadNode{	//桶 
	PtrToNode head,tail;
};
typedef struct HeadNode Bucket[Radix];

int GetDigit(int x,int D){	//取x的第D为元素 
	int d,i;
	for(i=1;i<=D;i++){
		d=x%Radix;
		x/=Radix ;
	} 
	return d;
}


void LSDradixSort(ElementType A[],int N){
	int D,Di,i;
	Bucket B;
	PtrToNode p,tmp,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<MaxDight;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=p;
				B[Di].tail=p;
			}
		}
		
		List=NULL;
		for(Di=Radix;Di>=0;Di++){
			if(B[Di].head){
				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); 
	}
}