排序算法（三）：交换排序（冒泡排序、快速排序的递归与非递归）

交换排序

• 基本思想：

所谓交换，就是根据序列中两个元素键值的比较结果来交换这两个元素在序列中的位置，将键值较大的元素向序列的尾部移动，键值较小的元素向序列的前部移动。

• 排序分类：

交换排序分为冒泡排序和快速排序

一：冒泡排序

• 排序过程：

根据序列中相邻两个元素键值的比较结果来对换这两个元素在序列中的位置，将键值较大的元素向序列的尾部移动，键值较小的元素向序列的前部移动。这样的过程十分类似于水泡上浮冒泡的过程，所以成为冒泡排序。

• 代码实现：

在冒泡排序的过程中，如果某一趟执行完毕，没有做任何一次交换操作，说明剩下的序列已经有序，排序操作也就可以完成了。

C++实现：

#include<iostream>
#include<vector>
using namespace std;

void Bubblesort(vector<int>& array){
	int sz = array.size();
	// 外层循环控制每一趟冒泡的次数
	for (int out = 0; out < sz - 1; out++){
		bool flag = true;
		// 内层循环控制单趟排序
		for (int in = 0; in < sz - out - 1; in++){
			if (array[in]>array[in + 1]){
				swap(array[in], array[in + 1]);
				flag = false;
			}
		}
		// 一趟排序中没有进行交换说明已经有序
		if (flag == true){
			break;
		}
	}
}

int main(){
	vector<int> array = { 9, 3, 1, 4, 2, 7, 8, 6, 5 };
	Bubblesort(array);
	for (const auto& e : array){
		cout << e << " ";
	}
	cout << endl;
}

运行结果：1 2 3 4 5 6 7 8 9

C实现：

#include<stdio.h>

void Swap(int* num1, int* num2){
	int temp = *num1;
	*num1 = *num2;
	*num2 = temp;
}

void Print(int* array, int sz){
	for (int cur = 0; cur < sz; cur++){
		printf("%d ", array[cur]);
	}
	printf("\n");
}

void Bubblesort(int* array, int sz){
	// 外层循环控制每一趟冒泡的次数
	for (int out = 0; out < sz - 1; out++){
		int flag = 0;
		// 内层循环控制单趟冒泡
		for (int in = 0; in < sz - out - 1; in++){
			if (array[in]>array[in + 1]){
				Swap(&array[in], &array[in + 1]);
				flag = 1;
			}
		}
		if (flag == 0){
			break;
		}
	}
}

int main(){
	int array[] = { 9, 3, 1, 4, 2, 7, 8, 6, 5 };
	int sz = sizeof(array) / sizeof(array[0]);
	Bubblesort(array, sz);
	Print(array, sz);
}

运行结果：1 2 3 4 5 6 7 8 9 

• 特性总结：

1.时间复杂度：O（N²）
2.空间复杂度：O（1）
3.冒泡排序是一种稳定的排序算法

二：快速排序

• 排序过程：

任取待排序序列的中的某元素为基准值，遍历整个数组区间，比基准值小的元素放到基准值的左边，比基准值大的元素放到基准值的右边，再用相同的方式处理左右两个无序子区间，直到小区间有序。

注意：快排在序列已经有序的情况下会很慢（时间复杂度为：O（N^2）

在序列已经有序的情况下，如果选取第一个元素或最后一个元素为基准值，则快速排序将会很慢。

所以基准值的选取非常的重要

三数取中法选取基准值（防止极端情况）： 取左端、中间、右端三个数进行排序，将中间数作为基准值。

• 代码实现（递归）：

C++实现前后指针法版本的快速排序

#include<iostream>
#include<vector>
using namespace std;

int GetMiddle(vector<int>& array, int begin, int end){
	if (array.size() >= 3){
		// 获取中位数下标
		int mid = (begin + end) >> 1;
		// 三数比较
		if (array[begin] < array[mid]){
			if (array[mid] < array[end]){
				// begin < mid < end
				return mid;
			}
			else if (array[begin] < array[end]){
				// mid > end > begin
				return end;
			}
			else{
				// mid > begin > end
				return begin;
			}
		}
		else{
			// begin > mid
			if (array[end] < array[mid]){
				// begin > mid > end
				return mid;
			}
			else if (array[begin]>array[end]){
				// begin > end > mid
				return end;
			}
			else{
				// end > begin > mid 
				return begin;
			}
		}
	}
	else{
		if (array[begin] > array[end]){
			swap(array[begin], array[end]);
		}
		return 0;
	}
}

// 前后指针
int Partsort(vector<int>& array, int begin, int end){
	// 基准值
	int midindex = GetMiddle(array, begin, end);
	swap(array[end], array[midindex]);

	int cur = begin;
	int prev = begin - 1;

	while (cur < end){
		// 找到小于基准值的元素
		// 两个指针一起走，若碰到大于基准值的元素前指针停下，后指针继续++
		if (array[cur] < array[end] && ++prev != cur){
			swap(array[cur], array[prev]);
		}
		cur++;
	}

	prev++;
	// 和基准值交换
	swap(array[prev], array[end]);
	return prev;
}

void Quicksort(vector<int>& array, int begin, int end){
	if (end - begin < 1){
		return;
	}

	int keyindex = Partsort(array, begin, end);
	Quicksort(array, begin, keyindex - 1);
	Quicksort(array, keyindex + 1, end);
}

int main(){
	vector<int> array = { 4, 5, 7, 8, 1, 2, 3, 6 };
	Quicksort(array, 0, array.size()-1);

	for (const auto& e : array){
		cout << e << " ";
	}
	cout << endl;
}

运行结果：1 2 3 4 5 6 7 8

• 特性总结：

1.时间复杂度：O（N×logN）
2.空间复杂度：O（logN）
3.快速排序是一种不稳定的排序算法

• 代码实现（非递归）：

利用栈模拟递归的过程

#include<iostream>
#include<stack>
#include<vector>
using namespace std;

int GetMiddle(vector<int>& array, int begin, int end){
	if (array.size() >= 3){
		// 获取中位数下标
		int mid = (begin + end) >> 1;
		// 三数比较
		if (array[begin] < array[mid]){
			if (array[mid] < array[end]){
				// begin < mid < end
				return mid;
			}
			else if (array[begin] < array[end]){
				// mid > end > begin
				return end;
			}
			else{
				// mid > begin > end
				return begin;
			}
		}
		else{
			// begin > mid
			if (array[end] < array[mid]){
				// begin > mid > end
				return mid;
			}
			else if (array[begin]>array[end]){
				// begin > end > mid
				return end;
			}
			else{
				// end > begin > mid 
				return begin;
			}
		}
	}
	else{
		if (array[begin] > array[end]){
			swap(array[begin], array[end]);
		}
		return 0;
	}
}

// 前后指针
int Partsort(vector<int>& array, int begin, int end){
	// 基准值
	int midindex = GetMiddle(array, begin, end);
	swap(array[end], array[midindex]);

	int cur = begin;
	int prev = begin - 1;

	while (cur < end){
		// 找到小于基准值的元素
		// 两个指针一起走，若碰到大于基准值的元素前指针停下，后指针继续++
		if (array[cur] < array[end] && ++prev != cur){
			swap(array[cur], array[prev]);
		}
		cur++;
	}

	prev++;
	// 和基准值交换
	swap(array[prev], array[end]);
	return prev;
}

// 递归可能会导致栈溢出
// 快排换用栈模拟实现非递归
void QuicksortNonr(vector<int>& array, int begin, int end){
	if (end - begin < 1){
		return;
	}

	stack<int> st;
	st.push(begin);
	st.push(end);

	while (!st.empty()){
		int right = st.top();
		st.pop();
		int left = st.top();
		st.pop();

		int keyindex = Partsort(array, left, right);
		if (left < keyindex - 1){
			st.push(left);
			st.push(keyindex - 1);
		}
		if (keyindex + 1 < end){
			st.push(keyindex + 1);
			st.push(end);
		}

	}
}

int main(){
	vector<int> array = { 4, 5, 7, 8, 1, 2, 3, 6 };
	QuicksortNonr(array, 0, array.size() - 1);

	for (const auto& e : array){
		cout << e << " ";
	}
	cout << endl;
}