内部排序算法C++实现

/*内部排序算法大集合*/
#include<iostream>
#include<vector>
using namespace std;

//直接插入排序=============================================================
void InsertSort(vector<int> &number)
{
	//vector<int>::iterator iter;
	int length=number.size();
	int temp=0;
	for(int i=1;i<length;i++)
		if(number[i]<number[i-1])
		{
			temp=number[i];
			number[i]=number[i-1];
			for(int j=i-2;j>=0;j--)
			{
				if(temp<number[j])
					number[j+1]=number[j];
				else break;
			}
			number[j+1]=temp;
		}
}

//折半插入排序============================================================
void BInsertSort(vector<int> &number)
{
	int length=number.size();
	int temp=0;
	for(int i=1;i<length;i++)
	{
		temp=number[i];
		int low=0;
		int high=i-1;
		while(low<=high)
		{
			int j=(low+high)/2;
			if(temp<number[j])
				high=j-1;
			else
				low=j+1;
		}
		for(int j=i-1;j>=high+1;j--)
			number[j+1]=number[j];
		number[high+1]=temp;
	}
}

//希尔排序=================================================================
void ShellInsert(vector<int> &number,int dk)
{
	int length=number.size();
	int temp=0;
	for(int i=dk;i<length;i=i+dk)
		if(number[i]<number[i-dk])
		{
			temp=number[i];
			//number[i]=number[i-dk];
			for(int j=i-dk;j>=0;j=j-dk)
			{
				if(number[j]>temp)
					number[j+dk]=number[j];
				else
					break;
			}
			number[j+dk]=temp;
		}
}

void ShellSort(vector<int> &number)
{
	for(int i=5;i>0;i--)
		ShellInsert(number,i);
}

//冒泡排序=================================================================
void BubbleSort(vector<int> &number)
{
	int length=number.size();
	int temp=0;
	for(int i=length-1;i>0;i--)
		for(int j=0;j<i;j++)
		{
			if(number[j]>number[j+1])
			{
				temp=number[j+1];
				number[j+1]=number[j];
				number[j]=temp;
			}
		}
}

//快速排序算法==============================================================
int Partion(vector<int> &number,int low,int high)
{
	int pivotkey=number[low];
	while(low<high)
	{
		while(low<high&&pivotkey<=number[high]) high--;
		number[low]=number[high];
		while(low<high&&pivotkey>=number[low])	low++;
		number[high]=number[low];
	}
	number[low]=pivotkey;
	return low;
}

void QuickSort(vector<int> &number,int low,int high)
{
	if(low<high)
	{
		int pivotloc=Partion(number,low,high);
		QuickSort(number,low,pivotloc-1);
		QuickSort(number,pivotloc+1,high);
	}
}

//简单选择排序=============================================================
void SelectSort(vector<int> &number)
{
	int length=number.size();
	for(int i=0;i<length;i++)
	{
		int min=i;
		for(int j=i;j<length;j++)
		{			
			if(number[j]<number[min])
				min=j;
		}
		int temp=number[min];
		number[min]=number[i];
		number[i]=temp;
	}
}

//堆排序===================================================================
void HeapAdjust(vector<int> &number,int s,int m)
{
	int temp=number[s];
	for(int i=2*s+1;i<=m;i=i*2)
	{
		if(i<m&&number[i]<number[i+1]) ++i;
		if(temp>=number[i]) break;
		number[s]=number[i];
		s=i;
	}
	number[s]=temp;
}

void HeapSort(vector<int> &number)
{
	int length=number.size();
	for(int i=(length-1)/2;i>=0;--i)
		HeapAdjust(number,i,length-1);
	for(i=length-1;i>0;--i)
	{
		int temp=number[0];
		number[0]=number[i];
		number[i]=temp;
		HeapAdjust(number,0,i-1);
	}
}

//归并排序==================================================================
void Merge(vector<int> &number, int start, int mid, int end)
{
	vector<int> num2;
	//将有序的num1[i…m]和num1[m+1…n]归并为有序的num2[i…n]
	for (int j = mid + 1, k = start; start <= mid && j <= end; ) {
		if (number[start] <= number[j]) {
			num2.push_back(number[start++]);
		} else {
			num2.push_back(number[j++]);
		}
	}
	if (start > mid) {
		for(; j <= end; j++)
			num2.push_back(number[j]);
	} else if (j > end) {
		for(; start <= mid; start++) {
			num2.push_back(number[start]);
		}
	}
	for (int i = 0;i < num2.size(); i++) {
		number[k + i] = num2[i];
	}
}
void MSort(vector<int> &number, int start, int end) {
	if ( start < end) {
		int m = (start + end) / 2;
		MSort(number, start, m);	
		MSort(number, m+1, end);
		Merge(number, start, m, end);
	}
}


void MergeSort(vector<int> &number, int start, int end) {
	MSort(number, start, end);	
}


int main() {
	vector<int> number;
	int num[]={4, 1, 3, 6, 2, 5};
	number.assign(num, num + 6);
	cout << "before sort:" << endl;

	for(int i = 0;i < number.size();i++) {
		cout << number[i] << endl;
	}

	//InsertSort(number);
	//BInsertSort(number);
	//ShellSort(number);
	//BubbleSort(number);
	//QuickSort(number,0,number.size()-1);
	//SelectSort(number);
	//HeapSort(number);
	MergeSort(number, 0, number.size()-1);
	cout << "after sort:" << endl;
	for(i=0; i < number.size(); i++) {
		cout << number[i] << endl;
	}
	return 0;
}