常见排序方法

#include <cstdio>
#include <iostream>
using namespace std;
const int MAXSIZE = 100;

void MySwap(int &a,int &b);
void BubbleSort(int *a,int len);
void Print(int *a,int len);

/*冒泡排序：时间复杂度：最坏情况O(n^2),最好情况O(n),平均情况O(n^2);空间复杂度：O(1);稳定，简单*/
/*基本思想：外循环len-1次，从一端第一个数开始依次和剩下的数比较交换*/
void BubbleSort(int *a,int len)
{
	for(int i = 0;i < len -1;i++)
	{
	    for(int j = 0;j < len-1-i;j++)
		{
			if(*(a+j) > *(a+j+1))
			{
			     MySwap(*(a+j),*(a+j+1));				 
			}
		}
	}
}
/*插入排序：时间复杂度：最坏情况O(n^2),最好情况O(n),平均情况O(n^2);空间复杂度：O(1);稳定，简单*/
void InsertSort(int *a,int len)
{
	for(int i = 1;i <= len-1;i++)
	{
		int tmp = a[i];
		int j;
		for(j = i-1; j >= 0; j--)
		{
			if(a[j] > tmp)
				a[j+1] = a[j];
			else
				break;
		}
		a[j+1] = tmp;
	}
}

/*希尔排序：改进的插入排序*/
void ShellSort(int *a,int len)
{

	int group = len/3;
	while(group > 0)
	{
		for(int f = 0;f < group;f++)//插入排序的次数
			for(int i = f + group;i <= len-1;i+=group)//插入排序
			{
				int tmp = a[i];
				int j;
				for(j = i-group;j >= 0;j-=group)
				{
					if(a[j] > tmp)
					    a[j+group] = a[j];
					else
						break;
				}
				a[j+group] = tmp;
			}
			
		group /= 3;
	}
}
/*选择排序：时间复杂度：最坏情况O(n^2),最好情况O(n^2),平均情况O(n^2);空间复杂度：O(1);不稳定，简单*/
void SelectSort(int *a,int len)
{
	int min = 0;
	for(int i = 0;i < len-1;i++)
	{
		min = i;
		for(int j = i+1;j <= len-1;j++)
		{
			if(a[min] > a[j])
				min = j;
		}
		if(min != i)
		    MySwap(a[i],a[min]);
	}
}
/*堆排序：首先从len/2-1下标的位置开始至到0的位置进行大堆/小堆的调整,然后从0下标开始和len-i下标的元素进行交换，每进行
一次交换，对剩下的元素进行0下标的堆调整*/
void HeapAdjust(int *a,int len,int index)
{
	int max,i ;
	for(i = index;i < len ; )
	{
		int lcld = 2*i + 1;
		int rcld = 2*i + 2;
		if(lcld >= len)
			break;
		else 
			if(rcld >= len)
				max = lcld;
			else 
				max = a[lcld] > a[rcld] ? lcld : rcld;
		if(a[i] > a[max])
			break;
		swap(a[i],a[max]);
		i = max ;
	}
}

void HeapSort(int * a,int len)
{
	int i;
	for(i = len/2-1;i >= 0;i--)
		HeapAdjust(a,len,i);
	Print(a,len);
	for(i = 1;i < len; i++)
	{
		swap(a[0],a[len - i]);
		if(i < len - 1)
			HeapAdjust(a,len - i,0);
	}
}
//快速排序：时间复杂度：最坏情况O(n^2),最好情况O(nlog2n),平均情况O(nlog2n);
//空间复杂度：O(nlog2n);不稳定
int partition(int *p,int len)
{
	if(len<=1)
		return 1;
	int mid=p[0];
	int left=0;
	int right=len-1;
	while(left<right)
	{
		while(p[right]>=mid && left<right)
			right--;
		p[left]=p[right];
		while(p[left]<=mid  && left<right)
			left++;
		p[right]=p[left];
	}
	p[left]=mid;
	return left;
	
}
void Quick_sort(int *p,int len)
{
	int pivot;
	if(len<=1)
		return;
	
	pivot=partition(p,len);
	Quick_sort(p,pivot);//对pivot前面的快速排序
	Quick_sort(p+pivot+1,len-pivot-1);//对pivot后面的快速排序，不断迭代
}
//归并排序
void merge(int *p,int left,int mid,int right)
{
	int i,j;
	i=left;
	j=mid+1;
	int tmp[MAXSIZE];
	int k=0;
	if(left>=right)
		return;
	while(i<=mid&&j<=right)
	{
		if(p[i]<=p[j])
		{
			tmp[k++]=p[i++];
		}
		else 
		{
			tmp[k++]=p[j++];
		}
	}
	if(i>mid)
	{
		for(;j<=right;j++)
			tmp[k++]=p[j];
	}
	if(j>right)
	{
		for(;i<=mid;i++)
			tmp[k++]=p[i];
	}
	k=0;
	for(i=left;i<=right;i++)
		p[i]=tmp[k++];
}
void Merge_sort(int *p,int len)
{
	if(len<=1)
		return;
	Merge_sort(p,len/2);
	Merge_sort(p+len/2,len-len/2);
	merge(p,0,len/2-1,len-1);
}

void MySwap(int &a,int &b)
{
	int temp = b;
	b = a;
	a = temp;
}
void Print(int *a,int len)
{
	for(int i = 0;i < len;i++)
	    cout << a[i] << "  " ;
	cout << endl;
}

int main()
{
	int a[] = {5,2,3,1,5,6,7,3,9,0};

	Print(a,sizeof(a)/sizeof(int));
	//InsertSort(a,sizeof(a)/sizeof(int));
	//BubbleSort(a,sizeof(a)/sizeof(int));
	//SelectSort(a,sizeof(a)/sizeof(int));
	//ShellSort(a,sizeof(a)/sizeof(int));
	HeapSort(a,sizeof(a)/sizeof(a[0]));
	//Quick_sort(a,sizeof(a)/sizeof(a[0]));
	//Merge_sort(a,sizeof(a)/sizeof(a[0]));
	Print(a,sizeof(a)/sizeof(int));

	return 0;
}