几种常用排序算法

1、选择排序(升序排列)

#include <iostream>
using namespace std;

/*-------------------- 排序规则 --------------------

		它的工作原理是每一次从待排序的数据元素中选出
		最小（或最大）的一个元素，存放在序列的起始位
		置，直到全部待排序的数据元素排完。

		稳定性:选择排序是不稳定的排序方法 如:[5,5,3]

-------------------------------------------------*/

//选择排序(升序排列)
void selectionSort(int *array, int len)
{
	// 指向最小的元素的位置
	int min = 0;	
	// 外层循环 - 取无序序列的第一个元素
	for (int i = 0; i < len - 1; ++i)
	{
		min = i;
		// 内层循环
		for (int j = i + 1; j < len; ++j)
		{
			// 判断
			if (array[min] > array[j])
			{
				// 保存最小的元素的位置
				min = j;
			}
		}
		// 判断是否需要交换
		if (min != i)
		{
			// 找到了新的最小值
			// 交换
			int tmp = array[min];
			array[min] = array[i];
			array[i] = tmp;
		}
	}
}

#if 0
void main()
{
	//定义整型数组
	int array[] = { 12, 5, 33, 6, 10 };
	//计算数组长度
	int len = sizeof(array) / sizeof(int);
	//遍历数组
	cout << "待排序数组序列:\t\t";
	for (int i = 0; i < len; ++i)
	{
		cout << array[i] << "\t";
	}
	cout << endl;

	//排序
	selectionSort(array, len);

	//遍历
	cout << "选择排序之后的序列:\t";
	for (int i = 0; i < len; ++i)
	{
		printf("%d\t", array[i]);
	}
	cout << endl;
	system("pause");
}
#endif

2、冒泡排序

#include <iostream>
using namespace std;

/********************* 排序规则 *********************

冒泡排序算法的运作如下：（从后往前）
	1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
	2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
	3. 针对所有的元素重复以上的步骤，除了最后一个。
	4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

稳定性:冒泡排序是一种稳定排序算法

***************************************************/

//冒泡排序(升序)
void bubbleSort(int *array, int len)	//O(n²)
{
#if 0
	// 外层
	for (int i= 0; i < len; ++i)
	{
		for (int j = 1; j < len - i; j++)
		{
			// 交换
			if (array[j] < array[j - 1])
			{
				int tmp = array[j];
				array[j] = array[j - 1];
				array[j - 1] = tmp;
			}
		}
	}
#endif
	// 0: 没有排好, 1: 已经排好
	int flag = 0;	// 减少判断的次数
	for (int i = len - 1; i > 0 && flag==0; --i)
	{
		flag = 1;	// 默认已经排好
		for (int j = 0; j < i; ++j)
		{
			if (array[j] > array[j + 1])
			{
				int tmp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = tmp;
				flag = 0;	// 没有排好
			}
		}
	}
}

#if 0
void main()
{
	//定义整型数组
	int array[] = { 11, 8, 7, 6, 3 };
	//计算数组长度
	int len = sizeof(array) / sizeof(int);
	//遍历数组
	cout << "待排序数组序列:\t\t";
	for (int i = 0; i < len; ++i)
	{
		cout << array[i] << "\t";
	}
	cout << endl;

	//排序
	bubbleSort(array, len);

	//遍历
	cout << "冒泡排序之后的序列:\t";
	for (int i = 0; i < len; ++i)
	{
		cout << array[i] << "\t";
	}
	cout << endl;
	system("pause");
}
#endif

3、插入排序

#include <iostream>
using namespace std;

/******************* 排序规则 *******************

	每次处理就是将无序数列的第一个元素与有序数列
	的元素从后往前逐个进行比较，找出插入位置，将
	该元素插入到有序数列的合适位置中。

	稳定性:插入排序是稳定的

***********************************************/

//插入排序算法(升序排列)
void insertionSort(int *array, int len)
{
	int tmp = 0;	// 存储基准数
	int index = 0;	// 坑的位置
	// 遍历无序序列
	for (int i = 1; i < len; ++i)
	{
		index = i;
		tmp = array[i];
		// 遍历有序序列(从后往前)
		for (int j = i - 1; j >= 0; --j)
		{
			// 基准数根有序序列中的元素比较
			if (tmp < array[j])
			{
				// 有序序列元素后移
				array[j + 1] = array[j];
				// 坑的位置
				index = j;
			}
			else
			{
				break;
			}
		}
		// 填坑
		array[index] = tmp;
	}
}

#if 0
void main()
{
	int i;
	//定义整型数组
	int array[] = { 12, 5, 33, 6, 10 };
	//计算数组长度
	int len = sizeof(array) / sizeof(int);
	//遍历数组
	cout << "待排序数组序列:\t\t";
	for (int i = 0; i < len; ++i)
	{
		cout << array[i] << "\t";
	}
	cout << endl;

	//排序
	insertionSort(array, len);

	//遍历
	printf("插入排序之后的序列:	");
	for (i = 0; i < len; ++i)
	{
		cout << array[i] << "\t";
	}
	cout << endl;
	system("pause");
}
#endif