交换排序C

---

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排
序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。主要的例子有冒泡排序还有快速排序。

一、冒泡排序(BubbleSort)

void BubbleSort(int* a, int n)
{
	// 1 2 3 4 5 6 7 8
	for (int j = 0; j < n; j++)
	{
		int flag = 0;  //设置标志
		for (int i = 1; i < n-j; i++)
		{
			if (a[i - 1] > a[i])
			{
				swap(&a[i - 1], &a[i]);
				flag = 1;   //如果交换了，将标志置为1
			}
		}
		if (flag == 0) //一趟冒泡排序中没有交换过，即已经有序
		{
			break;
		}
	}
}

冒泡排序的特性总结：

1. 时间复杂度：O(N^2)
2. 空间复杂度：O(1)
3. 稳定性：稳定

二、快速排序(QuickSort)

1.来源

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

void QuickSort(int* a, int begin,int end)
{
	if (begin >= end)
	{
		return;
	}
	if (end - begin + 1 < 15)//排序数少的用直接插入排序替代，可大大降低递归次数
	{ 
		//直接插入排序
		InsertSort(a+begin, end - begin + 1);
	}
	else
	{
		int keyi = PartSort3(a, begin, end);// 划分成功后以keyi为边界形成了左右两部分 [begin, keyi-1] 和 [keyi+1, end]
		QuickSort(a, begin, keyi - 1);
	    QuickSort(a, keyi + 1, end);
	}
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，同学们在写递归框架时可想想二叉
树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。
将区间按照基准值划分为左右两半部分的常见方式有：

2.hoare法

代码如下（示例）：

int PartSort1(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);//让划分界限的值不大也不小，在有序的情况下
	swap(&a[begin], &a[mid]);
	int keyi = begin;
	int left = begin;
	int right = end;
	while (left < right)
	{
		//选取的key为左边，则右边先走，右边找小
			while(left<right&&a[keyi] <= a[right])//1,2,1,2,4,53,3,2,7,8,6,5
			{
				right--;
			}
		//选取的key为左边，则左边后走，左边找大
			while (left < right && a[keyi] >= a[left])
			{
				left++;
			}
			//交换
			swap(&a[left], &a[right]);
	}
	swap(&a[keyi], &a[left]);
	keyi = left;
	return keyi;//接口函数,，返回分割数
	//分成两段 [begin,keyi-1] keyi [keyi+1,end]
	//PartSort1(a, keyi+1, end);
}

3.挖坑法(容易理解)

int PartSort2(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);
	swap(&a[begin], &a[mid]);

	//挖洞法
	if (begin >= end)
	{
		return;
	}
	int key = a[begin];
	int hole = begin;
	int left = begin;
	int right = end;
	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;
}

4.双指针法(最好用)

思想：

初始状态：

int PartSort3(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);//三数取中
	swap(&a[begin], &a[mid]);
	int keyi = begin;
	int prev = begin;
	int cur = begin + 1;
	while (cur <= end)
	{
		//找到比key小的值的时候，跟++prev交换，小的往前翻，大的往后翻
		if (a[cur] < a[keyi]&&++prev!=cur)  //这里可以有"="吗
		{
			swap(&a[prev], &a[cur]);
		}
		cur++;
	}
	swap(&a[prev], &a[keyi]);
	keyi = prev;
	/*PartSort1(a, begin, keyi - 1);
	PartSort1(a, keyi + 1, end);*/
	return keyi;//接口函数，返回分割数
}

5.快速排序优化

1. 三数取中法选key(为什么要这样？)
   说明：我们可以来看一看下图
   
   因为要是分割区间的数值过大或过小，在有序的情况下会出现分割不均衡的情况，如上图的最坏情况，此时快排的时间复杂度为O(N^2)，所以我们需要让这个分割区间的数值保持在中间左右为极好，三数取中后快排瞬间从原来的最坏变为最好，快排几乎可以认定不会出现最坏情况，可以认为其时间复杂度为O(N*logN)
2. 递归到小的子区间时，可以考虑使用插入排序
   
   说明：我们知道二叉树越往深处走，其每排节点越多，如上图，可知，最后一排的数量已经占了将近一半的递归调用，所以我们采取对这个排序数据区间小的时候进行直接插入排序来减少递归所消耗的内存
   

6.快排(非递归)

//栈实现非递归快排
void QuickSortNonR(int* a,int begin, int end)
{
	ST s;
	int left = begin;
	int right = end;
	StackInit(&s);
	StackPush(&s,begin);
	StackPush(&s, end);
	while (!IsEmpty(&s))
	{
		int right = StackTop(&s);
		StackPop(&s);
		int left = StackTop(&s);
		StackPop(&s);
		int keyi = PartSort3(a, left, right);
		//[begin,keyi-1] keyi [keyi+1,end]
		if (keyi + 1 < right) //如果只有一个数,或者没有数就不用入栈
		{
			StackPush(&s, keyi+1);
			StackPush(&s, right);
		}
		if (left < keyi - 1)//如果只有一个数,或者没有数就不用入栈
		{
			StackPush(&s, left);
			StackPush(&s, keyi - 1);
		}
	}
	StackDestory(&s);
}

7.快排总结

快速排序的特性总结：

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

---

总结

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