数据结构之排序（插入排序、交换排序、选择排序、归并排序）

一、插入排序

1、直接插入排序

（1）插入步骤：

（2）算法：

（3）案例：

（4）复杂度：
空间复杂度：O(1)
时间复杂度：O(n^2)

（5）适用性：直接插入排序适用于顺序存储和链式存储的线性表。

2、折半插入排序
（1）思想：先用折半查找找出元素的待插入位置，再统一的移动待插入位置之后的所有元素。

（2）算法：

（3）复杂度：
空间复杂度：O(1)
时间复杂度：O(n^2)

3、希尔排序
（1）基本思想：希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

（2）算法：

（3）案例：

（4）性能分析：
空间复杂度：O(1)
时间复杂度：O(n^2)

二、交换排序

1、冒泡排序
（1）基本思想：
从后往前两两比较相邻元素的值，若为逆序，则交换它们，直到序列比较完；下一趟冒泡时，前一趟确定的最小元素不再参加比较，每趟冒泡的结果是把序列中的最小元素或最大的元素放到了最终位置；经过N-1趟冒泡就能把所有元素排好序。

（2）案例：

（3）算法：

（4）性能分析：
空间复杂度：O(1)
时间复杂度：O(n^2)

2、快速排序
（1）基本思想：
通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
（2）算法：

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;
		A[low]=A[high];
		while(low<high&&A[low]<=pivot) ++low;
		A[high]=A[low];
	}
	A[low]=pivot;
	return low;
}

（3）性能分析：
空间复杂度：O(logn)
时间复杂度：O(nlogn)

三、选择排序

1、简单选择排序
（1）基本思想：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

（2）算法：

（3）性能分析：
空间复杂度：O(1)
时间复杂度：O(n^2)

2、堆排序
（1）堆定义：
满足条件1的是大根堆：每个节点的值都大于或者等于它的左右子节点的值。
满足条件2的是小根堆：每个节点的值都小于或者等于它的左右子节点的值。

大根堆案例：

大根堆的调整过程：

输出堆顶元素87后继续调整：

大根堆的插入：

（2）基本思想：
堆排序的基本思想是：1、将待排序的序列构造成一个大顶堆，根据大顶堆的性质，当前堆的根节点（堆顶）就是序列中最大的元素；2、将堆顶元素和最后一个元素交换，然后将剩下的节点重新构造成一个大顶堆；3、重复步骤2，如此反复，从第一次构建大顶堆开始，每一次构建，我们都能获得一个序列的最大值，然后把它放到大顶堆的尾部。最后，就得到一个有序的序列了。

（3）算法：

建立大根堆算法：

堆排序算法：

（4）性能分析：
空间复杂度：O(1)
时间复杂度：O(nlogn)

四、归并排序

（1）2路归并排序案例：

（2）算法：

ElemType *B=(ElemType)malloc((n+1)*sizeof(ElemType));
merge：将前后相邻的两个有序表归并成为一个有序表。
void merge(ElemType A[],int low,int mid,int high){
	for(int k=low;k<=high;k++){
		B[k]=A[k];
	}
	for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){
		if(B[i]<=B[j])
			A[k]=B[i++];
		else
			A[k]=B[j++];
	}
	while(i<=mid) A[k++]=B[i++];
	while(j<=mid) A[k++]=B[j++];
}

归并：
void mergerSort(ElemType A[],int low,int high){
	if(low<high){
		int mid=(low+high)/2;
		mergeSort(A,low,mid);
		mergeSort(A,mid+1,high);
		merge(A,low,mid,high);
	}
}

（3）性能分析：
空间复杂度：O(n)
时间复杂度：O(nlogn)

五、基数排序

案例：

第一趟排序：

第二趟排序：

第三趟排序：