c++各种排序算法实现

#include<iostream>
#include<unordered_map>
#include<string>
#include<vector>
using namespace std;
//含有跳跃式交换的排序算法，都是不稳定的算法
//---------交换类-------
//冒泡排序---稳定的排序、最好n、平均n^2、最坏n^2
bool bubblesort(int a[],int n)
{
	if(a==NULL)
		return false;
	bool btmp;
	for(int i=n-1;i>0;i--)
	{
		btmp=false;
		for(int j=0;j<i;j++)
		{
			if(a[j+1]<a[j])
			{
				int tmp=a[j];
				a[j]=a[j+1];
				a[j+1]=tmp;
				btmp=true;
			}
		}
		if(btmp==false) return true;//最好的情况是，已经排好序，然后没有交换则跳出
	}
	return false;
}
//冒泡法改进版----记住最后一次交换的位置,减少第一次循环的次数
bool bubblehigh(int a[],int n)
{
	if(a==NULL)
		return false;
	int i=n-1;
	int j=0;
	bool btmp=true;
	int aus=0;
	while(i>0&&btmp)
	{
		btmp=false;
		for(j=0;j<i;j++)
		{
			if(a[j]>a[j+1])
			{
				int tmp=a[j];
				a[j]=a[j+1];
				a[j+1]=tmp;
				btmp=true;
				aus=j;
			}
		}
		i=j;
		if(btmp==false) return true;
	}
	return true;
}
//快排----不稳定的排序、最好nlgn、平均nlgn、最坏n^2(不能够进行二分)
void quicksort(int a[],int le,int rg)
{
	if(le>=rg) return;
	int left=le;
	int right=rg;
	int mid=a[left];
	while(left<right)
	{
		while(left<right&&mid<=a[right])
			right--;
		if(left<right) a[left]=a[right];
		while(left<right&&a[left]<=mid)
			left++;
		if(left<right) a[right]=a[left];
	}
	a[left]=mid;
	quicksort(a,le,right-1);
	quicksort(a,right+1,rg);
}
//------插入类-----
//直接插入排序，稳定排序，最好时间复杂度n(已经排好的),平均复杂度n^2,最坏n^2
bool insertsort(int a[],int n)
{
	if(a==NULL)
		return false;
	for(int i=1;i<n;i++)
	{
		int j=i-1;
		int tmp=a[i];
		while(j>=0&&tmp<a[j])
		{
			a[j+1]=a[j];
			j--;
		}
		a[j+1]=tmp;
	}
	return true;
}
//折半插入排序,改变不了时间复杂度
bool halfsort(int a[],int n)
{
	if(a==NULL)
		return false;
	for(int i=1;i<n;i++)
	{
		int tmp=a[i];
		int left=0;
		int right=i;
		while(left<=right)
		{
			int mid=(left+right)/2;
			if(tmp<=a[mid])
				right=mid-1;
			else
				left=mid+1;
		}
		int j=0;
		for(j=i-1;j>=left;j--)
			a[j+1]=a[j];
		a[j+1]=tmp;
	}
	return true;
}
//增量排序--不稳定的排序，最差复杂度n^2,最好nlgn,平均n1.3
bool shellsort(int a[],int n)
{
	if(a==NULL) return false;
	int d=n/2;
	while(d>=1)
	{
		for(int i=0;i<d;i++)
		{//插入排序
			for(int j=i;j<n;j+=d)
			{
				int tmp=a[j];
				int k=j-d;
				while(k>=i&&a[k]>tmp)///注意这里是k>i
				{
					a[k+d]=a[k];
					k=k-d;
				}
				a[k+d]=tmp;
			}
		}
		d=d/2;
	}
	return true;
}
//-------选择类----
//直接选择排序,时间复杂度最好n^2,平均n^2,最坏n^2
//例如8* 3 5 4 8 3 1 9 并不稳定
bool selectsort(int a[],int n)
{
	if(a==NULL)
		return false;
	for(int i=0;i<n;i++)
	{
		
		int minplace=i;
		for(int j=i;j<n;j++)
		{
			if(a[j]<a[minplace])
				minplace=j;
		}
		int tmp=a[i];
		a[i]=a[minplace];
		a[minplace]=tmp;
	}
		return true;
}
//堆排(这里排成了最大堆)----不稳定算法 时间复杂度最坏nlgn 平均nlgn 最好nlgn(二分)
void adjustsort(int a[],int start,int end)//start为下标，end为长度
{
	int dad=start;
	int son=2*dad+1;
	while(son<end)
	{
		if((son+1)<end&&a[son]<a[son+1])
			son++;
		if(a[son]>a[dad]) 
		{
		 	int tmp=a[son];
			a[son]=a[dad];
			a[dad]=tmp;

		    dad=son;
		    son=2*son+1;
		}
		else
			return;
	}
}
bool heapsort(int a[],int n)
{
	if(a==NULL) return false;
	for(int i=(n/2)-1;i>=0;i--)
		adjustsort(a,i,n);
	for(int i=n-1;i>=0;i--)
	{
		int tmp=a[i];
		a[i]=a[0];
		a[0]=tmp;
		adjustsort(a,0,i);
	}
	return true;
}
//归并排序
void merge(int a[],int le,int mid,int rg)
{
	int l=le;
	int r=mid+1;
//	int tmp[rg-le+1];
	vector<int> tmp;
	while(l<=mid&&r<=rg)
	{
		if(a[l]<a[r])
			tmp.push_back(a[l++]);
		else
			tmp.push_back(a[r++]);
	}
	while(r<=rg)
		tmp.push_back(a[r++]);
	while(l<=mid)
		tmp.push_back(a[l++]);

	int k=le;
	int len=tmp.size();
	for(int i=0;i<len;k++,i++)
		a[k]=tmp[i];
}


void mergesort(int a[],int left,int right)
{
	if(a==NULL) return ;
	if(left==right) return ;
	int mid=(left+right)/2;

	mergesort(a,left,mid);
	mergesort(a,mid+1,right);

	vector<int> tmp;
	merge(a,left,mid,right);
}


int main()
{
	int a[]={5,4,7,3,2,8,6,1};
        int n=sizeof(a)/sizeof(int);
	//bool res=bubblesort(a,n);
	//bool res=bubblehigh(a,n);
	//quicksort(a,0,n-1);
	//bool res=insertsort(a,n);
	//bool res=halfsort(a,n);
	//bool res=shellsort(a,n);
	//bool res=selectsort(a,n);
	//bool res=heapsort(a,n);
	mergesort(a,0,n-1);

	cout<<"排序后结果：";
	for(int i=0;i<8;i++)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
	system("pause");
}

还有： 桶排序和基数排序

效率比较：