[数据结构与算法]数据结构与算法 —— 排序

一、排序的概念

????????排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
????????稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

二、常见排序算法的实现

? 1.插入排序

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

1.1 直接插入排序

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

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

1.2 希尔排序

??????? （1）希尔排序：先选定一个整数，把待排序文件中所有记录分成个
组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

??????? （2）算法特性

????????????????1. 希尔排序是对直接插入排序的优化。
????????????????2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
????????????????3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定。

??????????????? 4.稳定性：不稳定

1.3 算法实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
// 插入排序
void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
// 希尔排序
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap /= 2;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
	
}

int main()
{
	int a1[] = { 10,9,8,7,6,5,4,3,2,1 };
	int a2[] = { 10,9,8,7,6,5,4,3,2,1 };
	int n = sizeof(a1) / sizeof(a1[0]);

	InsertSort(a1, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ",a1[i]);
	}
	printf("\n");

	ShellSort(a2, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a2[i]);
	}
}

? 2.选择排序

??????? 算法思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

2.1 选择排序

??????? （1）选择排序：在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素。若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换。在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素。

??????? （2）算法特性

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

2.2 堆排序

??????? （1）堆排序：堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

??????? （2）算法特性

????????????????1. 堆排序使用堆来选数，效率就高了很多。
????????????????2. 时间复杂度：O(N*logN)
????????????????3. 空间复杂度：O(1)
????????????????4. 稳定性：不稳定

2.3算法实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
//交换
void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

// 选择排序
void SelectSort(int* a, int n)
{
	int left = 0, right = n - 1;
	while (left < right)
	{
		int min = left, max = left;
		for (int i = left; i <= right; i++)
		{
			if (a[min] > a[i])
				min = i;
			if (a[max] < a[i])
				max = i;
		}
		Swap(&a[left], &a[min]);
		if (max == left)
			max = min;
		Swap(&a[right], &a[max]);
		left++;
		right--;
	}
}

// 堆排序
void AdjustDwon(int* a, int n, int parent)
{
	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);
	}
	//排序
	for (int i = 1; i <= n; i++)
	{
		Swap(&a[0], &a[n - i]);
		AdjustDwon(a, n - i, 0);
	}
}

int main()
{
	int a1[] = { 5,4,3,1,2,10,9,8,7,6 };
	int a2[] = { 5,4,3,1,2,10,9,8,7,6 };
	int n = sizeof(a1) / sizeof(a1[0]);

	SelectSort(a1, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a1[i]);
	}
	printf("\n");

	HeapSort(a2, n);
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a2[i]);
	}
 	return 0;
}

? 3.交换排序

??????? 算法思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

????? 3.1 冒泡排序

??????? （1）冒泡排序：对于n个元素，将所有相邻的元素依次进行比较并将较大的元素放在后面。重复执行 n-1 次便可得到有序序列。

????????（2）算法特性

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

????? 3.2 快速排序

??????? （1）快速排序

????????快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。本文将使用三种方法进行实现。

??????? （2）算法特性：

????????????????1.?快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
????????????????2.?时间复杂度：O(N*logN)
????????????????3.?空间复杂度：O(logN)
????????????????4.?稳定性：不稳定

3.3 算法实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include "stack.h"

//交换
void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

//三数取中
int GetMidIndex(int* a, int left, int right)
{
	int mid = left + (right - left) / 2;
	if (a[left] > a[right])
	{
		if (a[mid] > a[left])
			return left;
		else if (a[mid] > a[right])
			return mid;
		else
			return right;
	}
	else    //a[right] > a[left] 
	{
		if (a[mid] > a[right])
			return right;
		else if (a[mid] > a[left])
			return mid;
		else
			return left;
	}
}

// 冒泡排序
void BubbleSort(int* a, int n)
{
	for (int j = 1; j <= n; j++)
	{
		int flag = 1;
		for (int i = 0; i < n - j; i++)
		{
			if (a[i + 1] < a[i])
			{
				Swap(&a[i + 1], &a[i]);
				flag = 0;
			}
		}
		if (flag)
			break;
	}
	
}

// 快速排序递归实现
// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	int key = left;
	while (left < right)
	{
		while (left < right && a[right] >= a[key])
			right--;
		while (left < right && a[left] <= a[key])
			left++;
		if (left < right)
			Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[key]);
	return key;
}

// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{
	int mid = GetMidIndex(a, left, right);
	Swap(&a[left], &a[mid]);
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;

		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	return hole;
}

// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	int mid = GetMidIndex(a, left, right);
	int key = left;
	int prev = left, cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < a[key] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	Swap(&a[key], &a[prev]);
	return prev;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
	int key = PartSort1(a, left, right);
	QuickSort(a, left, key - 1);
	QuickSort(a, key + 1, right);
}

// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
	Stack St;
	StackInit(&St);
	StackPush(&St, left);
	StackPush(&St, right);

	while (!StackEmpty(&St))
	{
		int rright = StackTop(&St);
		StackPop(&St);
		int lleft = StackTop(&St);
		StackPop(&St);

		int key = PartSort2(a, lleft, rright);

		if (lleft < rright)
		{
			StackPush(&St, key + 1);
			StackPush(&St, rright);
		}
		if (lleft < rright)
		{
			StackPush(&St, lleft);
			StackPush(&St, key - 1);
		}
	}
}


int main()
{
	int a1[] = { 6,5,4,3,2,1,10,9,8,7 };
	int a2[] = { 6,5,4,3,2,1,10,9,8,7 };
	int a3[] = { 6,5,4,3,2,1,10,9,8,7 };
	int n = sizeof(a1) / sizeof(a1[0]);

	BubbleSort(a1, n);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", a1[i]);
	}
	printf("\n");

	QuickSort(a2, 0, n - 1);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", a2[i]);
	}
	printf("\n");

	QuickSortNonR(a3, 0, n - 1);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", a3[i]);
	}
	return 0;
}