八大排序算法的C++实现

#include "stdafx.h"
#include<iostream>  
#include<vector>  
#include <algorithm>  
#include <math.h>
using namespace std; 

void print(vector<int> numv)//输出数组 
{ 
	int size = numv.size();  
	if(size == 0)  
	{
		cout<<"null"<<endl;
	}
	else
	{  
		cout << "数组的顺序是：" << endl;
		for(int i = 1;i < size;i++)
		{  
			cout << numv.at(i-1) << " ";  
		}  
		cout << numv.at(size-1) << endl << endl;  
	}  
}  

vector<int> insertionsort(vector<int> numv)//插入排序 
{ 
	int size = numv.size();  
	for(int i = 1;i < size;i++){  
		int v = numv.at(i);  
		int j = i-1;  
		while((j >= 0)&&(numv.at(j) > v)){  
			numv.at(j+1)=numv.at(j);  
			j--;  
		}  
		numv.at(j+1)=v;  
	}  
	return numv;  
}  

vector<int> selectionsort(vector<int> numv)//选择排序
{  
	int size = numv.size();  
	for(int i = 0;i < size-1;i++){  
		int min = i;  
		for(int j = i+1;j < size;j++){  
			if(numv.at(j) < numv.at(min))  
				min = j;  
		}  
		int a = numv.at(i);  
		numv.at(i) = numv.at(min);  
		numv.at(min) = a;  
	}  
	return numv;  
}  

vector<int> bubblesort(vector<int> numv){//冒泡排序  
	int size = numv.size();  
	for(int i = 0;i < size-1;i++){  
		for(int j = 0;j < size-1-i;j++){  
			if(numv.at(j+1) < numv.at(j)){  
				int a = numv.at(j);  
				numv.at(j) = numv.at(j+1);  
				numv.at(j+1) = a;  
			}  
		}  
	}  
	return numv;  
}  

vector<int> merge2(vector<int> nb,vector<int> nc);  
vector<int> mergesort(vector<int> numv){//归并排序  
	int size = numv.size();  
	if(size <= 1)  
		return numv;  
	else
	{  
		vector<int> numb,numc;  
		for(int i = 0;i <=size/2-1;i++)
		{  
			numb.push_back(numv.at(i));  
		}  
		for(int i = size/2;i <=size-1;i++)
		{  
			numc.push_back(numv.at(i));  
		}  
		numb = mergesort(numb);  
		numc = mergesort(numc);  
		numv = merge2(numb,numc);  
		return numv;  
	}  
}  

vector<int> merge2(vector<int> nb,vector<int> nc)//合并  
{
	vector<int> na;  
	int i = 0,j = 0;  
	while((i <= nb.size()-1)&&(j <= nc.size()-1)){  
		if(nb.at(i) >= nc.at(j))
		{  
			na.push_back(nc.at(j));  
			j++;  
		}  
		else
		{  
			na.push_back(nb.at(i));  
			i++;  
		}  
	}  
	if(i == nb.size()){  
		while(j <= nc.size()-1)
		{  
			na.push_back(nc.at(j));  
			j++;  
		}  
	}  
	else
	{  
		while(i <= nb.size()-1)
		{  
			na.push_back(nb.at(i));  
			i++;  
		}  
	}  
	return na;  
} 

struct pare{  
	vector<int> numv;  
	int s;  
};  
pare partition(vector<int> numv,int i,int j);  
vector<int> quicksort(vector<int> numv,int i,int j)//快速排序 
{ 
	int size = j-i+1;  
	if(size <= 1)
	{
		return numv;
	}
	else if(size == 2)
	{  
		if(numv.at(i) > numv.at(j))
		{  
			int a = numv.at(i);  
			numv.at(i) = numv.at(j);  
			numv.at(j) = a;  
		}  
		return numv;  
	}  
	else{  
		pare pr = partition(numv,i,j);  
		numv = pr.numv;  
		int s = pr.s;  
		numv = quicksort(numv,i,s-1);  
		numv = quicksort(numv,s+1,j);  
		return numv;  
	}  
}  
pare partition(vector<int> numv,int i,int j)//分区
{  
	int p = numv.at(i);  
	int l = i;  
	i++;  
	while(i < j)
	{  
		while((numv.at(i) <= p)&&(i < j))i++;  
		while((numv.at(j) >= p)&&(i < j))j--;  
		if(i>=j)
			break;  
		int a = numv.at(i);  
		numv.at(i) = numv.at(j);  
		numv.at(j) = a;
		i++;
		j--;  
	}     
	if(numv.at(i) > p)i--;  
	int a = numv.at(i);  
	numv.at(i) = p;  
	numv.at(l) = a;  
	pare par;  
	par.numv = numv;  
	par.s = i;  
	return par;  
}  

vector<int> quicksort(vector<int> numv)
{  
	int j=numv.size()-1;  
	return quicksort(numv,0,j);  
}  

class heap//二叉堆 
{ 
private:  
	vector<int> h;  
	void buildheap()
	{  
		for(int i=h.size()-1;i>0;i--)
		{  
			pdown(i);  
		}  
	}  
	void pdown(int x)
	{  
		if(2*x+1<=h.size()-1)
		{  
			if((h.at(x)>h.at(2*x))||(h.at(x)>h.at(2*x+1)))
			{  
				if(h.at(2*x)<h.at(2*x+1))
				{  
					int a=h.at(2*x);  
					h.at(2*x)=h.at(x);  
					h.at(x)=a;  
					pdown(2*x);  
				}  
				else
				{  
					int a=h.at(2*x+1);  
					h.at(2*x+1)=h.at(x);  
					h.at(x)=a;  
					pdown(2*x+1);  
				}  
			}  
		}  
		else if((2*x==h.size()-1)&&(h.at(x)>h.at(2*x)))
		{  
			int a=h.at(2*x);  
			h.at(2*x)=h.at(x);  
			h.at(x)=a;  
			pdown(2*x);  
		}  
	}  
public:  
	heap()
	{  
		h.push_back(0);  
	}  
	heap(vector<int> nuin)
	{  
		h.push_back(0);  
		for(int i=0;i<nuin.size();i++)  
			h.push_back(nuin.at(i));  
		buildheap();  
	}  
	void print()
	{  
		for(int i=1;i<h.size();i++){  
			cout<<h.at(i)<<" ";  
		}  
		cout<<endl;  
	}  
	int top()
	{  
		return h.at(1);  
	}  
	void deletemin()
	{  
		if(h.size()>1){  
			h.at(1)=h.back();  
			h.pop_back();  
			pdown(1);  
		}  
	}  
	bool isempty()
	{  
		return h.size()<=1;  
	}  
};  

vector<int> heapsort(vector<int> numv)
{  
	heap heap1(numv);  
	vector<int> num;  
	while(!heap1.isempty())
	{  
		num.push_back(heap1.top());  
		heap1.deletemin();  
	}  
	return num;  
}  

vector<int> shell_sort(vector<int> numv)
{
	int size = numv.size();
	for (int h = size / 2;h > 0;h /= 2)//间隔循环减半
	{
		for (int k = 0;k < h;k++)
		{
			for(int i = k + h;i < size;i = i + h)
			{  
				int v = numv.at(i);  
				int j = i - h;  
				while((j >= 0)&&(numv.at(j) > v))
				{  
					numv.at(j + h) = numv.at(j);  
					j = j - h;  
				}  
				numv.at(j + h) = v;  
			} 
		}
	}
	return numv;
}

int find_max(vector<int> numv)//找出数组中最大的数
{
	int max = numv.at(0);
	for (int i = 1;i < numv.size();i++)
	{
		if (max < numv.at(i))
		{
			max = numv.at(i);
		}
	}
	return max;
}

int digit_num(int num)
{
	int digit = 0;
	do 
	{
		num /= 10;
		digit++;
	} while (num != 0);
	return digit;
}

int Kth_digit(int number,int Kth)
{
	for (int i = 0;i < Kth;i++)
	{
		number /= 10;
	}
	number = number % 10;
	return number;
}

vector<int> radix_sort(vector<int> numv)//基数排序
//基数排序参考了《C和C++程序员面试秘笈》人民邮电出版社
{
	int len = numv.size();
	int max = find_max(numv);
	int max_digit = digit_num(max);
	int count[10] = {0,0,0,0,0,0,0,0,0,0};
	int * temp[10];
	for (int i = 0;i < 10;i++)
	{
		temp[i] = new int[len];
		memset(temp[i],0,sizeof(int) * len);
	}
	for (int i = 0;i < max_digit;i++)
	{
		memset(count,0,sizeof(int) * 10);
		for (int j = 0;j < len;j++)
		{
			int xx = Kth_digit(numv[j],i);
			temp[xx][count[xx]] = numv[j];
			count[xx]++;
		}
		int index = 0;
		for (int j = 0;j < 10;j++)
		{
			for (int k = 0;k < count[j];k++)
			{
				numv[index] = temp[j][k];
				index++;
			}
		}
	}
	return numv;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int n = 100;  
	vector<int> number;  
	for(int i = 1;i <= n;i++)
	{  
		number.push_back(i);  
	}  
	random_shuffle(number.begin(),number.end());//生成乱序的1到n的数  
	vector<int> number1;  
	print(number);  
	cout << "插入排序" << endl;
	number1 = insertionsort(number);  
	print(number1); 

	cout << "选择排序" << endl;
	number1 = selectionsort(number);  
	print(number1);  

	cout << "冒泡排序" << endl;
	number1 = bubblesort(number);  
	print(number1); 

	cout << "归并排序" << endl;
	number1 = mergesort(number);  
	print(number1); 

	cout << "快速排序" << endl;
	number1 = quicksort(number); 
	print(number1);  

	cout << "堆排序" << endl;
	number1 = heapsort(number);  
	print(number1); 

	cout << "希尔排序" << endl;
	number1=shell_sort(number);  
	print(number1);  

	cout << "基数排序" << endl;
	number1=radix_sort(number);  
	print(number1); 
	return 0;    
}