程序员成长之旅——交换排序

冒泡排序

基本思想

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

图解假如是升序

时间和空间复杂度

时间复杂度是O(n^2)
空间复杂度 O(1)

稳定性

稳定的

代码实现

//冒泡排序
void BubbleSort(int* a, int n)
{
	int end = n;
	while (end > 0)
	{
		//单趟冒泡
		for (int i = 1; i < end; ++i)
		{
			if (a[i - 1] > a[i])
				swap(a[i - 1], a[i]);
		}
		--end;
	}
}

快速排序

基本思想

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

图解假如是升序

1.左右指针法

2.挖坑法

3.前后指针法

时间和空间复杂度

时间复杂度我们：O(N*logN)
空间复杂度：O(logN)

稳定性

不稳定

代码实现

快速排序可以有两种方法进行优化，在下面的代码中也体现出来了，还有一个问题是，快速排序递归的情况有可能会出现栈溢出，因此下面也要给出来了方法，是用数据结构中的栈代替栈空间，就可以避免栈溢出，因为它是在堆上的。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<algorithm>
#include<stack>
using namespace std;
void InsertSort(int* array, int sz)
{
	for (int i = 1; i < sz; i++)
	{
		int key = array[i];
		int end = i - 1;
		//找待插入的位置  O(n)
		while (end >= 0 && key < array[end])
		{
			array[end + 1] = array[end];
			--end;
		}
		//插入数据
		array[end + 1] = key;
	}
}

//冒泡排序
void BubbleSort(int* a, int n)
{
	int end = n;
	while (end > 0)
	{
		//单趟冒泡
		for (int i = 1; i < end; ++i)
		{
			if (a[i - 1] > a[i])
				swap(a[i - 1], a[i]);
		}
		--end;
	}
}
//快速排序
//有序的时候时间效率最差 O（N*N）
//优化快排
//1.三数取中
int GetMidIndex(int* a, int left, int right)
{
	int mid = left + (right - left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] > a[right])
			return left;
		else
			return right;
	}
	else
	{
		if (a[right] < a[mid])
			return mid;
		else if (a[right] < a[left])
			return left;
		else
			return right;
	}
}
//左右指针法
int PartSort1(int* a, int left,int right)
{
	int mid = GetMidIndex(a, left, right);
	swap(a[mid], a[right]);
	int key = a[right];
	int keyindex = right;
	while (left < right)
	{
		while (left < right && a[left] <= key)
			left++;

		while (left < right && a[right] >= key)
			right--;

		if (left < right)
			swap(a[left], a[right]);
	}
	swap(a[left], a[keyindex]);
	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];
	int keyindex = right;
	while (left < right)
	{
		//左边找大放到右边的坑
		while (left < right && a[left] <= key)
		{
			++left;
		}
		if (left < right)
		{
			a[right] = a[left];
			keyindex = left;
		}
		//右边找小，放到左边的坑
		while (left < right && a[right] >= key)
		{
			--right;
		}
		if (left < right)
		{
			a[left] = a[right];
			keyindex = right;
		}
	}
	swap(a[keyindex], key);
	return keyindex;
}
//前后指针法
int PartSort3(int* a, int left, int right)
{
	int mid = GetMidIndex(a, left, right);
	swap(a[mid], a[right]);
	int key = a[right];
	int cur = left;
	int prev = cur - 1;
	while (cur < right)
	{
		if (a[cur] < key && ++prev != cur)
			swap(a[prev], a[cur]);

		++cur;
	}
	++prev;
	swap(a[prev], a[right]);
	return prev;
}
//优化 2.
//递归
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return; 

	if (right - left + 1 > 10)
	{
		//int keyindex = PartSort1(a, left, right);
		//int keyindex = PartSort2(a, left, right);
		int keyindex = PartSort3(a, left, right);
		QuickSort(a, left, keyindex - 1);
		QuickSort(a, keyindex + 1, right);
	}
	else
	{
		InsertSort(a + left, right - left + 1);
	}
}
//非递归
void QuickSortNonR(int* a, int left, int right)
{
	stack<int> s;
	s.push(left);
	s.push(right);
	while (!s.empty())
	{
		int end = s.top();
		s.pop();
		int begin = s.top();
		s.pop();

		int keyindex = PartSort3(a, begin, end);

		if (keyindex - 1 > begin)
		{
			s.push(begin);
			s.push(keyindex - 1);
		}

		if (keyindex + 1 < end)
		{
			s.push(keyindex + 1);
			s.push(end);
		}
	}
}
void PrintSort(int* a, int n)
{
	for (int i = 0; i < n; ++i)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}
int main()
{
	int array[10] = { 10,2,3,4,5,6,7,8,9,1 };
	int size = sizeof(array) / sizeof(int);
	//BubbleSort(array, size);
	//QuickSort(array, 0, 9);
	QuickSortNonR(array, 0, 9);
	PrintSort(array, size);
	return 0;
}