排序算法（二）快速排序

冒泡排序

冒泡排序是一种交换排序，他的基本思想是：两两比较相邻记录的关键字，如果逆序则交换，直到没有逆序的记录为止。

void BubbleSort(int arr[], int len)
{
	int temp;
	int i, j;
	for(i = 0; i < len - 1; i++)
	{
		for(j = 0; j < len - i -1; j++)
		{
			if(arr[j] >arr[j + 1])
			{
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

快速排序的基本思想是：通过一趟排序将记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

int QSort(int arr[], int start, int end)  //一趟快排
{
	int temp = arr[start];
	while(start < end)
	{
		while(start < end && arr[end] >= temp) end--;
		arr[start] = arr[end];
		while(start < end && arr[start] <= temp) start++;
		arr[end] = arr[start];
	}
	arr[start] = temp;
	return start;
}

void Quick(int arr[], int start, int end)  //快排的递归实现
{
	if(start < end)
	{
		int mid = QSort(arr, start, end);
		Quick(arr, start, mid - 1);
		Quick(arr, mid + 1, end);
	}
}

void QuickSort(int arr[], int len)
{
	Quick(arr, 0, len - 1);
}

void NoReQuick(int arr[], int start, int end) //快速排序的非递归实现
{
	stack<int> temp;
	int i, j;
	temp.push(end);
	temp.push(start);
	while (!temp.empty())
	{
		i = temp.top();
		temp.pop();
		j = temp.top();
		temp.pop();
		if (i < j)
		{
			int mid = QSort(arr, i, j);
			if (mid > i)
			{
				temp.push(mid - 1);
				temp.push(i);
			}
			if (mid < j)
			{
				temp.push(j);
				temp.push(mid + 1);
			}
		}
	}
}

void NoRecursionQuickSort(int arr[], int len)
{
	NoReQuick(arr, 0, len - 1);
}

void Show(int arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << "   ";
	}
	cout << endl;
}

int main()
{
	int arr[] = { 10, 91, 15, 187, 36, 61, 2, 81, 42, 99, 512, 128, 55 };
	int len = sizeof(arr) / sizeof(arr[0]);
	//QuickSort(arr, len);  //递归
	NoRecursionQuickSort(arr, len); //非递归
	Show(arr, len);
}