冒泡、插入、希尔和快速排序算法

#define MAXN 7
#include<iostream>
using namespace std;

int a[MAXN] = {4,3,2,1,5,9,6};
//交换
void swap(int &a,int &b)
{
	int tmp;
	if(a > b)
	{
		tmp = a;
		a = b;
		b = tmp;
	}
}
//输出
void show()
{
	int i;
	for(i=0; i<MAXN; i++)
		cout<< a[i] << " ";
	cout << endl;
}
/*======================冒泡排序=========================*/
void BubbleSort(int a[],int n)
{
	int i,j;
	for(i=0; i<n; i++)
	{
		for(j=1; j<n-i; j++)
		{
			swap(a[j-1],a[j]);
		}
	}
}
//冒泡排序优化
void BubbleSort2(int a[],int n)
{
	int i;
	int k = n;
	bool flag = true;
	//如果有一个内层循环没有发生交换，说明数组已经排序好了
	while(flag)
	{
		flag = false;
		for(i=1; i<k; i++)
		{
			swap(a[i-1],a[i]);
			flag = true;
		}
		k--;
	}
}
//冒泡排序再优化
void BubbleSort3(int a[],int n)
{
	int i,k;
	int index = n;
	bool flag = true;
	while(flag)
	{
		flag = false;
		k = index;
		for(i=1; i<k; i++)
		{
			swap(a[i-1],a[i]);
			index = i;
			flag = true;
		}
	}
}

/**快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。
步骤为：
1、从数列中挑出一个元素，称为 "基准"（pivot），
2、重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
	在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3、递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
	递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。
	虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
**/
//快速排序
int Partition(int a[],int low,int high)
{
	int pivot = a[low];
	while(low < high)
	{
		while(low < high && a[high] > pivot)
			high--;
		a[low] = a[high];
		while(low < high && a[low] <= pivot)
			low++;
		a[high] = a[low];
	}
	a[low] = pivot;
	return low;
}
void QuickSort(int a[],int low,int high)
{
	int loc = 0;
	if(low < high)
	{
		loc = Partition(a,low,high);
		QuickSort(a,low,loc-1);
		QuickSort(a,loc+1,high);
	}
}
/**
**插入排序算法描述如下：
*1、从第一个元素开始，该元素可以认为已经被排序
*2、取出下一个元素，在已经排序的元素序列中从后向前扫描
*3、如果该元素（已排序）大于新元素，将该元素移到下一位置
*4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
*5、将新元素插入到该位置后
*6、重复步骤2~5
**/
/*======================插入排序=========================*/
void InsertSort(int a[],int n)
{
	int i,j;
	int tmp;//每次保存较小的数
	for(i=1; i<n; i++)
	{
		if(a[i-1] > a[i])
		{
			j=i;
			tmp = a[i];
			//插入
			while(j > 0 && a[j-1] > tmp)
			{
				a[j] = a[j-1];
				j--;
			}
			a[j] = tmp;
		}
	}
}
/**希尔排序算法思路：分组，然后各组直接插入排序
/*======================希尔排序=========================*/
void ShellSort(int a[],int n)
{
	for(int gap=n/2; gap>0; gap /=2)
		for(int i=gap; i<n; ++i)
		{
			int key = a[i];
			int j = 0;
			for(j=i-gap; j>=0 && a[j]>key; j-=gap)
				a[j+gap] = a[j];
			a[j+gap] = key;
		}
}

int main()
{
	cout<< "排序前：";
	show();
	//BubbleSort(a,MAXN);
	//cout<<"冒泡排序后：";
	//show();
	//InsertSort(a,MAXN);
	//cout<<"插入排序后：";
	//show();
	//QuickSort(a,0,MAXN-1);
	//cout<<"快速排序后：";
	//show();
	ShellSort(a,MAXN);
	show();
	return 0;
}