【数据结构19】交换排序（快速、冒泡）

---

冒泡排序

基本思想：
冒泡排序每一趟都把整个数组两两进行比较（已经有确定位置的数不再比较），如果前一个比后一个大则交换，否则不变。每比较一趟就确定一个数的正确位置，一共比较n-1趟。

冒泡排序的特性总结：

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

void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		int flag = 1;
		for (int i = 0; i < n - 1-j; i++)
		{
			if (a[i] > a[i + 1])
			{
				flag = 0;
				swap(&a[i], &a[i + 1]);
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}

快速排序

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

1. hoare版本
2. 挖坑法
3. 前后指针版本

hoare版本

排序过程：

int GetMidIndex(int* a,int left,int right)
{
	int mid = (left + right) / 2;
	if (a[mid] > a[left])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[right] < a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[right] > a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
int partition1(int* a,int left,int right)
{
	int mid = GetMidIndex(a, left, right);
	swap(&a[mid], &a[left]);

	int keyi = left;
	while (left < right)
	{
		while (left<right && a[right] >= a[keyi])
		{
			right--;
		}
		while(left<right && a[left] <= a[keyi])
		{
			left++;
		}
		swap(&a[left], &a[right]);
	}
	swap(&a[left], &a[keyi]);

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

}

挖坑版

挖坑法和第一个方法差不过，但是更好理解，他是先把key的值保存，然后把key的位置做坑，之后每次改变坑位直到循环结束再把保存的值放在最后的坑位上。
排序过程

int GetMidIndex(int* a,int left,int right)
{
	int mid = (left + right) / 2;
	if (a[mid] > a[left])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[right] < a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[right] > a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
int partition2(int* a, int left, int right)
{
	int mid = GetMidIndex(a, left, right);
	swap(&a[mid], &a[left]);
	int pit = left;
	int x = a[left];
	while (left < right)
	{
		while (left < right && a[right] >= x)
		{
			right--;
		}
		a[pit] = a[right];
		pit = right;
		while (left < right && a[left] <= x)
		{
			left++;
		}
		a[pit] = a[left];
		pit = left;
	}
	a[pit] = x;

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

}

前后指针版

前后指针法定义了两个指针，cur和prev。每一趟都cur先走找小，找到了就停下来，然后prev先++再把prev处的值和cur位置的值交换，就这样一直进行下去直到cur超出了数组的范围，这一趟就结束了。
然后再递归下去进行已经排好的数据的左边数组和右边数组的排序。
排序过程：

int GetMidIndex(int* a,int left,int right)
{
	int mid = (left + right) / 2;
	if (a[mid] > a[left])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[right] < a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[right] > a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
int partition3(int* a, int left, int right)
{
	int mid = GetMidIndex(a, left, right);
	swap(&a[mid], &a[left]);

	int cur = left + 1;
	int prev = left;
	int key = left;
	while (cur <= right)
	{
		if (a[cur] < a[key] && cur != ++prev)
		{
			swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	swap(&a[key], &a[prev]);

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

}

非递归版

非递归版的快速排序，是使用栈保存了快速排序的left和right
1.一开始先存入整个数组的left和right
2.开始进行先取出栈的数据，第一次排序
3.保存第一次排序后两个分割区的left和right（先保存右边的数组，再保存左边的数组）
4.然后再开始取出栈的数据，进行下面的排序
5.就这样一直排序下去，直到栈为空

void QuickSortNoR(int* a, int left, int right)
{
	ST st;
	StackInit(&st);
	StackPush(&st, left);
	StackPush(&st, right);
	while (!StackEmpty(&st))
	{
		int end = StackTop(&st);
		StackPop(&st);
		int begin = StackTop(&st);
		StackPop(&st);

		int keyi = partition1(a, begin, end);
		if (begin < keyi)
		{
			StackPush(&st, begin);
			StackPush(&st, keyi-1);
		}
		if (keyi < end)
		{
			StackPush(&st, keyi+1);
			StackPush(&st, end);
		}
	}


	StackDestroy(&st);
}

这里的栈的各种操作的代码并未给出，有需要的可以翻看专栏数据结构基础，里面有分享和分析栈的各种操作实现。

快速排序的特性总结：

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