排序算法——选择法，冒泡法和快速排序算法

一. 简介

这里介绍三种排序算法：选择法，冒泡法和快速排序算法。

选择法和冒泡法是最简单的两种排序算法，易于编写，但是在处理大量数据时效率不高（在处理少量数据时，所有算法的效率都差不多）

快速排序算法是目前效率最高的排序算法，但是编写较为麻烦。快速排序的平均时间复杂度为O（nlogn），在原数组有序的情况下会退化为O（n^2）。

二. 代码

直接上三个排序算法的代码（C实现）：

1.选择排序算法

void SelectSort(int* ar, int n)//选择法
{
	int i, j;
	int temp;

	for (i = 0; i < n - 1; i++)  //每一次外层循环确定当前未排序部分的最小项，并放在未排序部分的最前面
		for (j = i + 1; j < n; j++)
		{
			if (ar[i] > ar[j])  //将未排序部分的第一项与后面每一项比较，若某一项比第一项小，则交换位置
			{
				temp = ar[i];
				ar[i] = ar[j];
				ar[j] = temp;
			}
		}
}

2.冒泡排序算法

void BubbleSort(int* ar, int n)//冒泡法
{
	int i, j;
	int temp;

	for (i = n - 1; i > 0; i--)  //每一次外层循环确定当前未排序部分的最大项，并放在未排序部分最后
		for (j = 0; j < i; j++)
		{
			if (ar[j] > ar[j + 1])  //将未排序部分，以第一项开始，每一项和它的后一项比较，若后项更小，则交换位置
			{
				temp = ar[j];
				ar[j] = ar[j + 1];
				ar[j + 1] = temp;
			}
		}
}

 3.快速排序算法

void QuickSort(int* ar, int left, int right) //快速排序
{
	if (left >= right)
		return;
	int p = left;
	int q = right;
	int pivot = ar[left];  //以第一个数为枢轴

	while (p != q)//当p=q时确定枢轴位置
	{
		while (ar[q] >= pivot && p < q)   //q从右向左找比枢轴小的数，然后放在当前枢轴位置
			q--;
		if (p < q)
			ar[p] = ar[q];
		while (ar[p] <= ar[q] && p < q)   //p从左向右找比枢轴大的数，然后放在当前枢轴位置
			p++;
		if (p < q)
			ar[q] = ar[p];
	}
	ar[p] = pivot;  //最后把枢轴放在枢轴位置
	QuickSort(ar, left, q - 1); //递归处理左区间
	QuickSort(ar, p + 1, right);//递归处理右区间
}

三. 实例源码

最后给出应用实例的完整源码（c++实现）：

sort.h //头文件

/*sort.h*/
void SelectSort(int* ar, int n);
void BubbleSort(int* ar, int n);
void QuickSort(int* ar, int left, int right);

sort.cpp //排序算法文件

/*sort.cpp*/
void SelectSort(int* ar, int n)//选择法
{
	int i, j;
	int temp;

	for (i = 0; i < n - 1; i++)  //每一次外层循环确定当前未排序部分的最小项，并放在未排序部分的最前面
		for (j = i + 1; j < n; j++)
		{
			if (ar[i] > ar[j])  //将未排序部分的第一项与后面每一项比较，若某一项比第一项小，则交换位置
			{
				temp = ar[i];
				ar[i] = ar[j];
				ar[j] = temp;
			}
		}
}

void BubbleSort(int* ar, int n)//冒泡法
{
	int i, j;
	int temp;

	for (i = n - 1; i > 0; i--)  //每一次外层循环确定当前未排序部分的最大项，并放在未排序部分最后
		for (j = 0; j < i; j++)
		{
			if (ar[j] > ar[j + 1])  //将未排序部分，以第一项开始，每一项和它的后一项比较，若后项更小，则交换位置
			{
				temp = ar[j];
				ar[j] = ar[j + 1];
				ar[j + 1] = temp;
			}
		}
}

void QuickSort(int* ar, int left, int right) //快速排序
{
	if (left >= right)
		return;
	int p = left;
	int q = right;
	int pivot = ar[left];  //以第一个数为枢轴

	while (p != q)//当p=q时确定枢轴位置
	{
		while (ar[q] >= pivot && p < q)   //q从右向左找比枢轴小的数，然后放在当前枢轴位置
			q--;
		if (p < q)
			ar[p] = ar[q];
		while (ar[p] <= ar[q] && p < q)   //p从左向右找比枢轴大的数，然后放在当前枢轴位置
			p++;
		if (p < q)
			ar[q] = ar[p];
	}
	ar[p] = pivot;  //最后把枢轴放在枢轴位置
	QuickSort(ar, left, q - 1); //递归处理左区间
	QuickSort(ar, p + 1, right);//递归处理右区间
}

main.cpp //主函数文件

/*main.cpp*/
#include<iostream>
#include "sort.h"
using namespace std;

int main(void)
{
	int ar[100];
	int count;
	char ch;

	cout << "Enter your array" << endl;
	for (count = 0; count < 100; count++) {
		cin >> ar[count];
		if (cin.get() == '\n')
			break;
	}

	cout << endl << "Select a sorting algorithm" << endl;
	cout << "b:Bubble Sort  s:Selection sort  q:Quick sort" << endl;
	cin >> ch;

	switch (ch) {
	case 'b':BubbleSort(ar, count + 1); break;
	case 's':SelectSort(ar, count + 1); break;
	case 'q':QuickSort(ar, 0, count); break;
	default:break;
	}

	cout << endl;
	for (int i = 0; i <= count; i++) {
		cout << ar[i];
		cout << ' ';
	}
	cout << endl;

	return 0;

}