四种排序算法

1、冒泡排序

   使用了一个局部变量exchange来记录本次扫描时有没有进行过数据交换。每次在扫描前，把exchange置0。如果扫描时发生数据交换，则把exchange置位1；如果没有，则说明数组已经是排序了的，不需要进行下一次趟扫描。对于已经排好序的，使用这种处理方式将会简化程序的运行量。

#include<iostream>
using namespace std;
void bubble_sort(int a[],int len)
{
	int i,j,temp;
	int exchange;
	temp=exchange=0;
	for(i=0;i<len;i++)
	{
		exchange=0;
		for(j=0;j<len-i-1;j++)
		{
			if(a[j]>a[j+1])
			{
				temp=a[j+1];
				a[j+1]=a[j];
				a[j]=temp;
				exchange=1;
			}
		}
		if(exchange!=1)
		{
			cout<<"排序提前结束"<<endl;
			return;
		}
	}
}
int main()
{
	int data[9]={54,38,96,23,15,75,60,45,83};
	bubble_sort(data,9);
	for(int i=0;i<9;i++)
		cout<<data[i]<<" ";
	return 0;
}

2、快速排序法

快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的的策略，通常称其为分治法（Divide-and-ConquerMethod）分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

基本思路：设当前带排序的数组为A[low...high]，利用分治法可描述为：

（1）分解：在A[low...high]中任选一个记录作为基准（pivot），以此基准将当前无序区划分为左、右两个较小的子区间A[low...pivotpos-1]和A[pivotpos+1...high]。使左边区间所有记录的关键字都小于等于基准记录（pivot），右边的子区间中所有记录的关键字都大于等于pivot，而基准记录则在正确的位置上，她无需参加后续的排序。化为结果可以表示为：

（pivot=pivotpos）:A[low...pivotpos-1]<=A[pivotpos]<=A[pivotpos+1...hogh]

（2）求解：通过递归调用快速排序对左右子区间A[low...pivotos-1]和A[pivopos+1...high]快速排序。

（3）组合：当“求解”步骤中的两个递归调用结束时，其左、右两个子区间已有序。

void quick_sort(int a[],int low,int high)
{
	int i,j,pivot;
	if(low<high)
	{
		i=low;
		j=high;
		pivot=a[i];
		while(i<j)
		{
			while(i<j&&a[j]>=pivot)
				j--;
			if(i<j)
				a[i++]=a[j];
			while(i<j&&a[i]<=pivot)
				i++;
			if(i<j)
				a[j--]=a[i];
		}
		a[i]=pivot;
		quick_sort(a,low,i-1);
		quick_sort(a,i+1,high);
	}
}

3、插入排序

将待插入记录R[i]的关键字（R[i]=temp）从右向左←依次与有序区中记录R[j]（j=i-1，i-2，...，1）的关键字进行比较：
（1）如果R[j]的关键字大于R[i]的关键字，则将R[j]后移一个位置；

（2）如果R[j]的关键字小于或等于R[i]的关键字，则查找过程结束，j+1即为R[i]的插入位置。

关键字比R[i]的关键字大的记录均已后移，所以j+1的位置已经腾空，只要将R[i]直接插入此位置即可完成一趟直接插入排序。

void insert_sort(int a[],int len)
{
	int i,j,temp;
	for(i=1;i<len;i++)
	{
		temp=a[i];
		for(j=i-1;j>=0&&temp<a[j];j--)
		{
			a[j+1]=a[j];//后移
		}
		a[j+1]=temp;
	}
}

4、选择排序

排序思想：

（1）初始状态：A[1...n]，为待排序序列

（2）第一趟，在无序区A[1...n]中选出最小值的记录A[k]，将它与无序区的第一个记录A[1]交换，使A[1]变为记录个数增加1的新有序区，A[2...n]变为记录个数减1的新无序区。

（3）第i趟排序：第i排序开始时，当前有序区和无序区分别为A[i...i-1]和A[i...n]。该趟排序从当前无序区中选出关键字最小的记录A[k]，将它与无序区的第一个记录A[i]交换，使A[1...i]变为记录个数增加1的新有序区，A[i+1...n]变为记录个数减1的新无序区。

每次都在无序区找出最大的那个，并与无序区第一个进行交换

{54,38,96,23,15,75,60,45,83};第一次，最小值15与54交换，结果为：

↓

{15,38,96,23,54,75,60,45,83};第二次，最小值23与38交换，结果为：

↓

{15,23,96,38,54,75,60,45,83};第三次，最小值38与96交换，结果为：

↓

{15,23,38,96,54,75,60,45,83};第n次

↓

void select_sort(int a[],int len)
{
	int i,j,x,l;
	for(i=0;i<len;i++)
	{
		x=a[i];            //每次遍历前x和l的初值设置
		l=i;
		for(j=i;j<len;j++)  //遍历从i位置向数组尾部进行
		{                   //每次遍历，都寻找出最小值和最小值位置
			if(a[j]<x)
			{
				x=a[j];     //x保存每次遍历搜索到的最小数
				l=j;        //l记录最小数的位置
			}
		}
		a[l]=a[i];           //把最小数与a[i]交换；
		a[i]=x;
	}
}

5、四种排序比较

冒泡排序：稳定的排序，时间复杂度Ο(n^2)；

快速排序：不稳定的排序，最理想情况下算法复杂度是Ο(nlog2n)，最坏是Ο(n^2)；

插入排序：稳定的排序，时间复杂度Ο(n^2)；

选择排序：不稳定的排序，时间复杂度Ο(n^2)；