冒泡排序与快速排序

一、冒泡排序

冒泡排序与快速排序属于互换类的排序方法。所谓互换排序是指借助数据元素之间的互相交换进行排序的一种方法。

1.1冒泡排序

算法情景:将一个无序的数组进行冒泡排序

冒泡排序方案1：

算法思路：冒泡排序方案1的排序思想就是外层循环n-1；内层循环n-i-1次，内层的每次的循环都是将最大的数字下沉到最后位置，意思就是说把最大的数字放到最后的位置，次大的放到最后位置的前一位，依此类推。

编码：

#include "stdafx.h"
#include <iostream>
#include <iomanip>

using namespace std;

template <class T>
void bub1(T p[], int n){

	T temp;
	for (int i = 0; i < n; i++)
		for (int j = 0; j < n - i - 1;j++)
		{
			if (p[j] > p[j + 1])
			{
				temp = p[j];
				p[j] = p[j + 1];
				p[j + 1] = temp;
			}
		}
	
}

int _tmain(int argc, _TCHAR* argv[]){

	double a[10] = { 5, 8, 12, 78, 96, 41, 20 ,3,255,24};

	cout << "排序前：" << endl;
	for (int i = 0; i < 10; i++){
		cout << setw(5) << a[i];
	}

	bub1(a, 10);

	cout << "排序后：" << endl;
	for (int i = 0; i < 10; i++){
		cout << setw(5) << a[i];
	}

	return 0;
}

冒泡排序方案2：

算法思路：首先，从表头开始往后扫描线性表，在扫描过程中逐次比较相邻两个元素的大小。若相邻两个元素中，前面的元素大于后面的元素，则将他们交换，称之为消去一个逆序，最后将线性表中的最大者换到了表的最后。

然后，从后到前扫描剩下的线性表，同样在扫描过程中逐次比较相邻两个元素的大小。若相邻两个元素中，后面的元素小于前面的元素，则将它们互换，这样就又消失了一个逆序，最后将线性表中最小者换到了表的最前面，

对剩下的线性表重复上述过程，知道剩下的线性表变空为止，此时的线性表已经变为有序。

冒泡排序过程示意图如下所示：

编码：

#include "stdafx.h"
#include <iostream>
#include <iomanip>

using namespace std;

template <class T>
void bub2(T p[], int n){
	int m, k, j, i;
	T temp;
	k = 0;
	m = n - 1;
	while (k < m)
	{
		j = m - 1;
		m = 0;
		for (i = k; i <= j;i++)			//从前往后扫描
			if (p[i]>p[i + 1])			//顺序不对，交换
			{
				temp = p[i];
				p[i] = p[i + 1];
				p[i + 1] = temp;
				m = i;
			}
		j = k + 1;
		k = 0;
		for (i = m; i >= j;i--)			//从后往前扫描
			if (p[i-1]>p[i])			//顺序不对，交换
			{
				temp = p[i];
				p[i] = p[i - 1];
				p[i - 1] = temp;
				k = i;
			}
	}
	return;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int i, j;
	double p[50], r = 1.0;
	for (i = 0; i < 50;i++)			//产生50个0-1之间的随机数
	{
		r = 2053.0*r + 13849.0;
		j = r / 65536.0;
		r = r - j*65536.0;
		p[i] = r / 65536.0;
	}

	for (i = 0; i < 50; i++)		//产生50个100-300之间的随机数
		p[i] = 100.0 + 200.0*p[i];
	cout << "排序前的序列：" << endl;
	for (i = 0; i < 10;i++)
	{
		for (j = 0; j < 5; j++)cout << setw(10) << p[5 * i + j];
		cout << endl;
	}

	bub2(p, 10);				//对原序列中的第11到第40个元素进行排序
	cout << "排序后的序列：" << endl;
	for (i = 0; i < 10;i++)
	{
		for (j = 0; j < 5; j++)cout << setw(10) << p[5 * i + j];
		cout << endl;
	}

	return 0;
}

二、快速排序

算法情景：将一个无序的数组进行快速排序

算法思路：对线性表或字表进行实际分割时，可以按如下步骤进行：
首先，在表的第一个、中间一个与最后一个元素中选取中项，设为P(k),并将P(k)赋给T，再将表中的第一个元素移到p(k)的位置上。
然后设置两个指针i和j分别指向表的起始与最后的位置。反复作以下两步：
(1)将j逐渐减小，并逐次比较p(j)与T，直到发现一个p(i)<T为止，将p(j)移动到p(i)的位置上。
(2)将i逐渐增大，并逐次比较p(i)与T，直到发现一个p(i)>T为止，将p（i）移动到p(j)的位置上。
上述两个操作交替进行，直到指针i与j指向同一个位置（即i=j）为止，此时将T移到p(i)的位置上

编码测试：

#include <stdlib.h>
#include <iostream>
#include "bub.h"

using namespace std;
/*
对线性表或字表进行实际分割时，可以按如下步骤进行：
首先，在表的第一个、中间一个与最后一个元素中选取中项，设为P(k),并将P(k)赋给T，再将表中的第一个元素移到p(k)的位置上。
然后设置两个指针i和j分别指向表的起始与最后的位置。反复作以下两步：
(1)将j逐渐减小，并逐次比较p(j)与T，直到发现一个p(i)<T为止，将p(j)移动到p(i)的位置上。
(2)将i逐渐增大，并逐次比较p(i)与T，直到发现一个p(i)>T为止，将p（i）移动到p(j)的位置上。
上述两个操作交替进行，直到指针i与j指向同一个位置（即i=j）为止，此时将T移到p(i)的位置上
*/
template <class T>
void qck(T p[], int n){

	int m, i;
	T *s;
	if (n > 10) //子表长度大于10，用快速排序
	{
		i = split(p, n); //对表进行分割
		qck(p, i); //对前面的子表进行快速排序
		s = p + (i + 1);
		m = n - (i + 1);
		qck(s, m); //对后面的子表进行快速排序
	}
	else
	{
		bub(p, n);
	}
	return;
}

//表的分割
template<class T>
static int split(T p[], int n){

	int i, j, k, l;
	T t;
	i = 0;
	j = n - 1;
	k = (i + j) / 2;
	if ((p[i] >= p[j]) && (p[j] >= p[k])) l = j;
	else if ((p[i] >= p[k]) && (p[k] >= p[j]))l = k;
	else l = i;

	t = p[l]; //选取一个元素为T
	p[l] = p[i];
	while (i != j)
	{
		while ((i < j) && p[j] >= t) //逐渐减小j,直到发现p[j]<t
			j = j - 1;
		if (i < j)
		{
			p[i] = p[j];
			i = i + 1;
			while ((i < j) && (p[i] <= t)) //逐渐增大i,直到发现p[i]>t
				i = i + 1;
			if (i < j)
			{
				p[j] = p[i]; j = j - 1;
			}
		}
	}
	p[i] = t;
	return i;
}

int main(){

	int array1[] = { 5, 77, 18, 62, 13, 27, 55, 10, 103, 98, 111, 24, 63 };
	int arraySize = sizeof(array1) / sizeof(array1[0]);

	for (int i = 0; i < arraySize; i++)
	{
		printf("%d ", array1[i]);
	}
	printf("\n");
	qck(array1, arraySize);
	for (int i = 0; i < arraySize; i++)
	{
		printf("%d ", array1[i]);
	}
	system("pause");
	return 0;
}