数据结构之排序

排序

• 前言
• 一、常见排序概念及算法思路
• 二、常见排序代码实现
  • 1.插入排序
  • 2.选择排序
  • 3.交换排序
  • 4.快速排序
• 总结

 

---

前言

排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

我们这里说说八大排序就是内部排序。

 

  

    当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、常见排序及算法思路

八大排序，三大查找是《数据结构》当中非常基础的知识点，在这里为了复习总结了一下常见的八种排序算法。
常见的八大排序算法，他们之间关系

如下：

它们的性能比较：

直接插入排序：

单趟排序：把待排序的记录按其关键码值的大小逐个插入到一
个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

假设把这个五插入到这个有序数组我们是从右向左，我们要做的是依次比大小。 如果比它大，就往后移一位，如果比它小，就插在它的后面。当插入的是0和前面一样到和1比完后前边没数时就插入到它的前边。

多趟排序：多趟排序是假设“|”前边是待插数组‘|’后一位数是待插数实行多次单趟排序。

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与
array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

直接插入排序的特性总结：
1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定

希尔插入排序：

基本思想：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。先预排序，在直接插入排序。我们把一组数据分成以gap为间距的若干组再进行组内排序，gap一般首先选数组长的一般，然后再取一半的一半进行组内排序，当gap为1是便是直接插入排序。

这个数组初始gap为5 进行组内排序，排序完后再进行第二趟排序gap减半，当gap=1时进行直接插入排序。

希尔排序的特性总结：
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就
会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度： O(N^1.3—N^2）
4. 稳定性：不稳定

选择排序：

1，从待排序序列中，找到关键字最小的元素；

2，如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；

3，从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束。因此我们可以发现，简单选择排序也是通过两层循环实现

   第一层循环：依次遍历序列当中的每一个元素

   第二层循环：将遍历得到的当前元素依次与余下的元素进行比较，符合最小元素的条件，则交换。

直接选择排序的特性总结：

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

交换排序：

 

将序列当中的左右元素，依次比较，保证右边的元素始终大于左边的元素；
（ 第一轮结束后，序列最后一个元素一定是当前序列的最大值；）

对序列当中剩下的n-1个元素再次执行步骤1。

对于长度为n的序列，一共需要执行n-1轮比较
（利用while循环可以减少执行次数）

冒泡排序的特性总结：
1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定

快速排序：

1. hoare版本

单趟排序

、

我们选最后一位为key用begin和end分别从前和后比较如果begin比key大，end比key小两个就交换位置最后key和begin交换位置这样就形成了左比key小，右边比key大的数组。

多趟排序是经过一次单趟排序后，然后左边再选一个数为进行key单趟排序，右边相同，最后就把数组就分成一个个数了。

挖坑法

单趟排序

      给一个例子：

• 从序列当中选择一个基准数(key)
  在这里我们选择序列当中第一个数最为基准数
• 将序列当中的所有数依次遍历，比基准数大的位于其右侧，比基准数小的位于其左侧
• 重复步骤1.2，直到所有子集当中只有一个元素为止。
  用伪代码描述如下：
  1．i =L; j = R; 将基准数挖出形成第一个坑a[i]。
  2．j--由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中。
  3．i++由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中。
  4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中

 

二、常见排序代码实现

代码如下（示例）：

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
// 插入排序
void InsertSort(int* a, int n) {
	assert(a);
	for (int i = 0; i < n-1; i++) {
		int end = i;
		int temp = a[end + 1];
		while (end >= 0) {
			if (temp < a[end]) {
				a[end + 1] = a[end];
				end--;
			}
			else {
				break;
			}
		}
		a[end + 1] = temp;
	}
}
// 希尔排序
void shellsort(int* a, int n) {
	int gap=n;
	while (gap > 1) {
		gap = gap / 3+1;
		for (int i = 0; i < n - gap; i++) {
			int end = i;
			int temp = a[end + gap];
			while (end >= 0) {
				if (a[end] > temp) {
					a[end + gap] = a[end];
					end -= gap;
				}
				else { break; }
				a[end + gap] = temp;
			}
		}
	}
}
void swap(int* p1, int* p2) {

	int temo = *p1;
	*p1 = *p2;
	*p2 = temo;
}
// 选择排序
void SelectSort(int* a, int n) {
	assert(a);
	int begin=0, end=n-1;
	
	while (begin < end) {
		int min, max;
		min = max = begin;
		for (int i = begin + 1; i <= end; i++) {
			if (a[min] > a[i]) {
				 min =i;
			}
			if (a[max] < a[i]) {
				  max=i;
			}
		}
		swap(&a[begin], &a[min]);
		if (begin == end) {
			max = min;
		}
		swap(&a[max], &a[end]);
		++begin;
		--end;
	}
}

// 堆排序
void AdjustDwon(int* a, int n, int root)
{
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}

		if (a[child] > a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	// 排升序，建大堆还是小堆?
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDwon(a, n, i);
	}

	int end = n - 1;
	while (end > 0)
	{
		swap(&a[0], &a[end]);
		AdjustDwon(a, end, 0);
		--end;
	}
}

// O(N^2)
void BubbleSort(int* a, int n)
{
	int end = n;
	while (end > 0)
	{
		int exchange = 0;
		for (int i = 1; i < end; ++i)
		{
			if (a[i - 1] > a[i])
			{
				swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}

		if (exchange == 0)
		{
			break;
		}

		--end;
	}
}
// 快速排序递归实现
// 快速排序hoare版本
int GetMidIndex(int* a, int begin, int end) {
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid]){
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] > a[end])
			return begin;
		else
			return end;
}

	else {
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}
int PartSort1(int* a, int left, int right) {
	int mid=GetMidIndex(a, left, right);
	swap(&a[mid], &a[right]);
	int key = right;
	while (left <right) {
		while(left <right&&a[left] <=a[key]) {
			++left;
		}
		while (left <right&&a[right] >=a[key]) {
		
			--right;
		}
		swap(&a[left], &a[right]);	
	}
	swap(&a[left], &a[key]);
	return left;
}
// 快速排序挖坑法
int PartSort2(int* a, int left, int right) {
	int mid = GetMidIndex(a, left, right);
	swap(&a[mid], &a[right]);
	int key = a[right];
	while (left < right) {
	
		while (left < right && a[left] <= key) {
			++left;
		
		}
		a[right] = a[left];
		while (left < right && a[right] >= key) {
			--right;
		}
		a[left] = a[right];
	}
	a[left] = key;
	return left;
}
// 快速排序前后指针法
int PartSort3(int* a, int left, int right) {\
	int mid = GetMidIndex(a, left, right);
	swap(&a[mid], &a[right]);
	int key = right;
	int cur = left;
	int prev = left - 1;
	while (cur < right) {
	
		if (a[cur]<a[key]&&++prev !=cur) {
			
			swap(&a[prev], &a[cur]);
		}
		++cur;
	}
	swap(&a[++prev], &a[cur]);
	return prev;
	
}
void QuickSort(int* a, int left, int right) {
	assert(a);
	if (left > right) {
		return;
	}
	int div = PartSort3(a, left, right);
	QuickSort(a, left, div-1);
	QuickSort(a, div + 1, right);


}
// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right);
 归并排序递归实现
void MergeSort(int* a, int n);
void ShellSort(int* a, int n);
void _MergeSort(int* a, int left, int right, int* tmp) {
	if (left >= right)
		return;
	int mid = (left + right) / 2;
		_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);
	//归并[left, mid] [mid+1, right]有序，
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int index = begin1;
	while (begin1 <= end1 && begin2 <= end2)
		if (a[begin1] < a[begin2])
			tmp[index++] = a[begin1++];
		else
			tmp[index++] = a[begin2++];
	while (begin1 <= end1)
		tmp[index++] = a[begin1++];
	while (begin2 <= end2)
		tmp[index++] = a[begin2++];
	for (int i = left; i <= right; ++i)
		a[i] = tmp[i];
}
void MergeSort(int* a,int n){
		assert(a);
	int* tmp =(int*) malloc(sizeof(int) * n);
	_MergeSort(a,0,n - 1,tmp);
	free(tmp);
}
 归并排序非递归实现
//void MergeSortNonR(int* a, int n)
 计数排序
//void CountSort(int* a, int n)
/*void _Mfile(const char *file1,const char *file2,const char*mfile){
	FILE *fout1 = fopen(file1，"r");
	if (fout1 == NULL)
{
	printf("打开文件朱败\n");
	exit(-1);
}
	FILE*fout2 = fopen(file2，"r");
	if (fout2 == NULL)
{
	printf("打开文件失败\n"); exit(-1);
}
	FILE*fin = fopen(mfile, "w");
if (fin == NULL) {
	printf("打开文件失败\n");
	exit(-1);
}
int num1，num2;
int ret1 = fscanf(fout1，"%d\n"， &num1);
int ret2 = fscanf(fout2，"%d\n", &num2); 
while (ret1 != EOF && ret2 != EOF)
{
	if (num1 < num2) {
		fprintf(fin，"%d\n", num1);
		ret1 = fscanf(fout1，"%d\n"， &num1);
	}
	else {
		fprintf(fin，"%d\n", num2);
		ret2 = fscanf(fout2，"%d\n"， &num2);
}
}
while (ret1 != EOF) {
	fprintf(fin, "%d\n"，num1);
	ret1 = fscanf(fout1，"%d\n"， &num1);
}
while (ret2 != EOF)
{
	fprintf(fin，"%d \n", num2);
	ret2 = fscanf(fout2，"%d\n"， &num2);
}
	fclose(fout1); 
	fclose(fout2); 
	fclose(fin);
}
void MergeSortFile(const char* file) {
	FILE* fout = fopen(file, "r");
	if (fout == NULL) {
		printf("打开文件失败\n");
		exit(-1);
	}
	// 分割成一段一段数据，内存排序后写到，小文件，
	int n = 10;
	int a[10];
	int i = 0;
	int num = 0;
	char subfile[20];
	int filei = 1;
	memset(a, 0, sizeof(int) * n);
	while (fscanf(fout, "%d\n", &num) != EOF)
		if (i < n - 1)
			a[i++] = num;
		else {
			a[i] = num;
			QuickSort(a, 0, n - 1);
			sprintf(subfile, "%d", filei++);
		}

	FILE* fin = fopen(subfile, "w");

	if (fin = NULL) {
		printf("打开文件失败\n");
		exit(-1);
	}
	for (int i = 0; i < n; i++)
		fprintf(fin, "%d\n", a[i]);
	fclose(fin);
	i = 0;
	memset(a, 0, sizeof(int) * n);
	//利用互相归并到文件，实现整体有序
	char mfile[100];
	char file1[100];
	char file2[100];
	for (int i = 2; i <= n; ++i) {
		//读取file1和file2, 进行归并出mfile
		_Mfile(file1, file2, mfile);
		strcpy(file1, mfile);
		sprintf(file2, "%d", i + 1);
		sprintf(mfile, "%s%d", mfile, i + 1);
	}

	fclose(fout);
}

void CountSort(int* a, int n) {
	assert(a);
	int min = a[0];
	int max = a[0];
	for (int i = 0; i < n; i++) {
		if (a[i] > max)
			max = a[i];
		if (a[i] < min)
			min = a[i];
	}
	int range=max-min + 1;
	int* countArr = (int*)malloc(sizeof(int) * range);
	memset(countArr,0, sizeof(int) * range);
	for (int i = 0; i < n; ++i) {
		countArr[a[i] - min]++;
	}
	//排序
	int index = 0;
	for (int j = 0; j < range; ++j)
		while (countArr[j]--)
			a[index++] = j + min;
	free(countArr);
}*/
void printfarry(int* a, int n) {
	for (int i = 0; i < n; i++) {
		printf("%d ", a[i]);
	}
	printf("\n");

}
void treeInsertSort() {
	int a[] = { 1,3,4,5,4,8,4,5,9,7,8,9};
	printfarry(a, sizeof(a) / sizeof(int));
	MergeSort(a,sizeof(a) / sizeof(int));
	printfarry(a, sizeof(a) / sizeof(int));
	

}
int main() {
	treeInsertSort();
	return 0;
}

---

总结

各种排序的稳定性，时间复杂度和空间复杂度总结：

 

 我们比较时间复杂度函数的情况：

 

 

                             时间复杂度函数O(n)的增长情况

 

所以对n较大的排序记录。一般的选择都是时间复杂度为O(nlog2n)的排序方法。

 

时间复杂度来说：

(1)平方阶(O(n2))排序
　　各类简单排序:直接插入、直接选择和冒泡排序；
 (2)线性对数阶(O(nlog2n))排序
　　快速排序、堆排序和归并排序；
 (3)O(n1+§))排序,§是介于0和1之间的常数。

       希尔排序
(4)线性阶(O(n))排序
　　基数排序，此外还有桶、箱排序。

说明：

当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）；

而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）；

原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

 

稳定性：

排序算法的稳定性:若待排序的序列中，存在多个具有相同关键字的记录，经过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。 
     稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较；

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序

 

选择排序算法准则：

每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种方法结合起来使用。

选择排序算法的依据

影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊情况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。一般而言，需要考虑的因素有以下四点：

1．待排序的记录数目n的大小；

2．记录本身数据量的大小，也就是记录中除关键字外的其他信息量的大小；

3．关键字的结构及其分布情况；

4．对排序稳定性的要求。

设待排序元素的个数为n.

1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
       堆排序 ：  如果内存空间允许且要求稳定性的，

       归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。

2）  当n较大，内存空间允许，且要求稳定性 =》归并排序

3）当n较小，可采用直接插入或直接选择排序。

    直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。

    直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序

5）一般不使用或不直接使用传统的冒泡排序。

6）基数排序
它是一种稳定的排序算法，但有一定的局限性：
　　1、关键字可分解。
　　2、记录的关键字位数较少，如果密集更好
　　3、如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序。  

https://www.cnblogs.com/wanghuadongsharer/p/9526433.html