排序算法复习

1. 插入排序

1.1 直接插入排序

算法思想：每次将一个待排序的记录按其关键字大小插入到前面已经排好序的子序列中，直到全部记录插入完成。

原理：三步走
1)查找出L[i]在L[1…i-1]中的插入位置k
2)将L[k…i-1]中的所有元素全部后移一个位置
3)将L[i]复制到L[k]

void InsertSort(ElemType A[],int n){
	int i,j;
	for(i=2;i<=n;i++){//依次将A[2]~A[n]插入前面的已排序序列
		if(A[i].key<A[i-1].key){
			A[0]=A[i];//A[0]只作为哨兵，不存放元素，数组从A[1]开始
				
			for(j=i-1;A[0].key<A[j].key;--j)//从后往前查找插入位置
				A[j+1]=A[j];//向后挪位
			A[j+1]=A[0];
		}
	}
}

哨兵的作用
带哨兵的插入排序中的哨兵元素有两个作用：
1、暂时存放待插入的元素
2、防止数组下标越界，当待插入的元素小于已排序的子数组中的最小元素时，j=-1,越界，而采用哨兵，arr[0]<arr[j],当j=0时，就结束循环，不会出现越界（for循环只有一次判断，提高了效率）。

1.2 折半插入排序

对比直接插排：折半插排确定待插入的位置后再统一地向后移动元素

void InsertSort(ElemType A[],int n){
	int i,j，low,high,mid;
	for(i=2;i<=n;i++){
		A[0]=A[i];
		low=1;high=i-1;//设置折半查找的范围
		while(low<=high){
			mid=(low+high)/2;
			if(A[mid].key>A[0].key)
				high=mid-1;
			else low=mid+1;
		}
		
		for(j=i-1;j>=high+1;--j)
			A[j+1]=A[j];
		A[high+1]=A[0];
	}
}

1.3 希尔排序

算法思想：将待排序的表分割成若干形如L[i,i+d,i+2d,i+3d…i+kd]的特殊子表，分别进行插入排序，最后一个增量为1，对全体记录进行一次直接插排

void Shellsort(ElemType A[],int n){
//前后记录位置的增量是dk，不是1
//A[0]只是暂存单元，不是哨兵，当j<=0时，插入位置已到
	for(dk=n/2;dk>=1;dk=dk/2)
		for(i=dk+1;i<=n;++i)//在这里使用插入排序
			if(A[i].key<A[i-dk].key){
				A[0]=A[i];
				for(j=i-dk;j>0&&A[0].key<A[j].key;j-=dk)
					A[j+dk]=A[j];
				A[j+dk]=A[0];
			}
}

2. 交换排序

2.1 冒泡排序

原理：将最小的元素交换到待排序列的第一个位置，下一趟冒泡时，前一趟确定的最小元素不再参与比较，每趟冒泡的结果是把当前序列中的最小元素放到了序列的最终位置

//将A中的元素从小到大排列
void BubbleSort(ElemType A[],int n){
	for(i=0;i<n-1;i++){
		flag=false;
		for(j=n-1;j>i;j--)
			if(A[j-1].key>A[j].key){
				swap(A[j-1],A[j]);
				flag=true;
			}
		if(flag==false)
			return;
	}
}

2.2 快速排序

原理：基于分治的思想，在待排序表中任取一个元素pivot作为基准，通过一趟排序将待排序表划分为独立的两部分L[1…k-1]和L[k+1…n],前者全部小于基准元素pivot，后者全部大于基准元素，最终基准元素放在了L[k]处。而后分别递归地对两个子表重复上述过程，直至每部分内只有一个元素或空为止。

void QuickSort(ElemType A[],int low,int high){
	if(low<high){
		int pivotpos=Partition(A,low,high);
		QuickSort(A,low,pivotpos-1);
		QuickSort(A,pivotpos+1,high);
	}
}

int Partition(ElemType A[],int low,int high){
	ElemType pivot=A[low];//以当前表中第一个元素作为基准元素
	while(low<high){
		while(low<high&&A[high]>=pivot)	
			--high;//找到第一个比pivot小的元素
		A[low]=A[high];
		while(low<high&&A[low]<=pivot)	
			++low;//找到第一个比pivot大的元素
		A[high]=A[low];
	}
	A[low]=pivot;
	return low;
}

下文是对快速排序另一种划分算法的图解，采用分治的算法，前后找到对应元素交换位置，感觉更加清晰一点。

https://www.cnblogs.com/KuJo/p/8544775.html

3. 选择排序

3.1简单选择排序

原理：第i趟排序从L[i…n]中选择关键字最小的元素与L[i]交换，经过n-1趟即可排完

void SelectSort(ElemType A[],int n){
//A[]从0开始存放元素
	for(i=0;i<n-1;i++){
		min=i;
		for(j=i+1;j<n;j++)
			if(A[j]<A[min])	min=j;
		if(min!=i)	swap(A[i],A[min]);
	}
}			

3.2 堆排序

堆的定义：n个关键字序列L[1…n]称为堆，当且仅当该序列满足：
L(i)≤L(2i)且L(i)≤L(2i+1) 或 L(i)≥L(2i)且L(i)≥L(2i+1)

堆排序的原理：首先将存放在L[1…n]建成初始堆，以大顶堆为例，堆顶元素就是最大值，输出堆顶元素后，通常将堆底元素送入堆顶，此时根节点不满足大顶堆的性质，然后将堆顶元素向下调整使其继续保持大顶堆的性质，再输出堆顶元素，如此重复，直到堆中只剩下最后一个元素。

4. 归并排序与基数排序

基数排序：采用多关键字排序思想，借助分配和收集两种操作对单逻辑关键字进行排序