基本排序算法

#include <iostream>
using namespace std;
#define RADIX 10

void cp(const int array[],int k,int array_cp[]){
	for (int i = 0; i < k; i++)
		array_cp[i] = array[i];
}
void arr_cout(int array_cp[], int k){
	for (int i = 0; i < k; i++)
		cout << array_cp[i] << " ";
	cout << endl;

}
/*
**直接插入排序，时间复杂度O(n^2)，最好O(n),最差O(n^2),额外空间O(1)，稳定
*/
void InsertSort(const int array[],const int k,int array_cp[]){
	cout << "InsertSort: \n";
	cp(array, k, array_cp);
	int i, j;
	int tmp;
	for (i = 1; i <=k-1;i++)
		if (array_cp[i] < array_cp[i - 1]){
			tmp = array_cp[i];
			for (j = i - 1; j >= 0 && tmp < array_cp[j]; j--)
				array_cp[j + 1] = array_cp[j];
			array_cp[j + 1] = tmp;
		}
	arr_cout(array_cp, k);
}
/*
**折半插入排序，时间复杂度O(nlogn),最好O(nlogn),最差O(nlogn),额外空间O(1)，稳定
*/
void BinaryInsertSort(const int array[], const int k, int array_cp[]){
	cout << "BinaryInsertSort: \n";
	cp(array, k, array_cp);
	int i, j;
	int mid,high,low;
	int tmp;
	for (i = 1; i <= k - 1;i++)
		if (array_cp[i] < array_cp[i - 1]){
			tmp = array_cp[i];
			low = 0;
			high = i - 1;
			while (low <= high){
				mid = (low + high) / 2;
				if (tmp < array_cp[mid]) high = mid - 1;
				else low = mid + 1;
			}
			for (j = i - 1; j >= low; j--)
				array_cp[j+1] = array_cp[j];
			array_cp[low] = tmp;
		}
	arr_cout(array_cp, k);
}
/*
**冒泡排序，时间复杂度O(n^2)，最好O(n),最差O(n^2),额外空间O(1)，稳定
*/
void BubbleSort(const int array[], const int k, int array_cp[]){
	cout << "BubbleSort: \n";
	cp(array, k, array_cp);
	int i, j;
	int tmp;
	bool exchage;
	for (i = 0; i <= k-1; i++){
		exchage = false;
		for (j = k - 1; j >= i + 1;j--){
			if (array_cp[j - 1]>array_cp[j]){
				tmp = array_cp[j];
				array_cp[j] = array_cp[j - 1];
				array_cp[j - 1] = tmp;
				exchage = true;
			}			
		}
		if (!exchage) { 
			arr_cout(array_cp, k); 
			return;
		}
	}
}
/*
**选择排序，时间复杂度O(n^2)，最好O(n^2),最差O(n^2),额外空间O(1)，不稳定
*/
void SelectSort(const int array[], const int k, int array_cp[])
{
	cout << "SelectSort:\n";
	cp(array, k, array_cp);
	int i, j;
	int tmp;
	//int m;
	for (i = 0; i <= k - 2; i++)
	{
	//	m = i;
		for (j = i + 1; j <= k - 1;j++)
			if (array_cp[j] < array_cp[i])
			{
				tmp = array_cp[j];
				array_cp[j] = array_cp[i];
				array_cp[i] = tmp;
			}
	}
	arr_cout(array_cp, k);
}
/*
**希尔排序，时间复杂度O(n^1.25)，最好O(n^2),最差O(n^2),额外空间O(1)，不稳定
*/
void ShellSort(const int array[], const int k, int array_cp[]){
	cout << "ShellSort: \n";
	cp(array, k, array_cp);
	int i, j, gap;
	int tmp;
	//gap=gap/3+1; gap>1;
	for (gap = k / 2; gap > 0; gap /= 2)
	{
		for (i = gap; i < k; i++)
		{
			tmp = array_cp[i];
			for (j = i-gap ; j >= 0&&tmp<array_cp[j] ; j -= gap)			
					array_cp[j+gap] = array_cp[j];
			array_cp[j+gap] = tmp;
		}
	}
	arr_cout(array_cp, k);
}
/*
**快速排序，时间复杂度O(nlogn),最好O(nlogn),最差O(n^2),额外空间O(logn)~O(n)，不稳定
*/
void QuickSort(int array_cp[],int low,int high){
	int i, j, t;
	int tmp;
	if (low > high) return;
	i = low;
	j = high;
	tmp = array_cp[i];
	while (i != j)
	{
		while (array_cp[j] >=tmp && i<j)  
			j--;
		while (array_cp[i] <= tmp && i<j)  
			i++;
		if (i < j)
		{
			t = array_cp[i];
			array_cp[i] = array_cp[j];
			array_cp[j] = t;
		}
	}
	array_cp[low] = array_cp[i];
	array_cp[i] = tmp; 
	QuickSort(array_cp, low, i - 1);
	QuickSort(array_cp, i + 1, high);;

}
void QS_cout(const int array[], const int k, int array_cp[]){
	cout << "QuickSort: \n";
	cp(array, k, array_cp);
	QuickSort(array_cp, 0, k - 1);
	arr_cout(array_cp, k);
}
/*
**归并排序，时间复杂度O(nlogn),最好O(nlogn),最差O(nlogn),额外空间O(n)，稳定
*/
void Merge(int array[], int low, int mid, int high){
	int i = low, j = mid ;
	int m = mid+1, n = high;
	int k = 0;
	int *p = new int[high - low + 1];
	while (i <= j&&m <= n){
		if (array[i] < array[m])
			p[k++] = array[i++];
		else 
			p[k++] = array[m++];
	}
	while (i <= j)
		p[k++] = array[i++];
	while (m <= n)
		p[k++] = array[m++];
	for (i = 0; i <= k - 1; i++)
		array[low + i] = p[i];
}
void MergeSort(int array_cp[], int low, int high){
	if (low < high){
		int mid = (low + high) / 2;
		MergeSort(array_cp, low, mid);
		MergeSort(array_cp, mid+1, high);
		Merge(array_cp, low, mid, high);
	}
}
void MS_cout(const int array[], const int k, int array_cp[]){
	cout << "MergeSort: \n";
	cp(array, k, array_cp);
	MergeSort(array_cp, 0, k - 1);
	arr_cout(array_cp, k);
}
/*
**堆排序，时间复杂度O(nlogn),最好O(nlogn),最差O(nlogn),额外空间O(1)，不稳定
*/
void SiftDown(int array_cp[], int start, int m){
	int i = start;
	int j = 2 * i+ 1;
	int tmp = array_cp[i];
	while (j <= m){
		if (j < m&&array_cp[j] < array_cp[j + 1])j++;
		if (tmp >= array_cp[j])
			break;
		else {
			array_cp[i] = array_cp[j];
			i = j;
			j = 2 * j + 1;
		}
	}
	array_cp[i] = tmp;
}
void HeapSort(int array[], int k,int array_cp[]){
	cout << "HeapSort: \n";
	cp(array, k, array_cp);
	int i;
	int tmp;
	for (i = (k - 2) / 2; i >= 0; i--)
		SiftDown(array_cp, i, k - 1);
	for (i = k - 1; i >= 0; i--){
		tmp = array_cp[0];
		array_cp[0] = array_cp[i];
		array_cp[i] = tmp;
		SiftDown(array_cp, 0, i - 1);
	}
	arr_cout(array_cp, k);
}
/*
**桶排序
*/
void BucketSort(int array[], int k, int array_cp[]){
	cout << "BucketSort: \n";
	cp(array, k, array_cp);
	int *p = new int[100]();
	for (int i = 0; i < k; i++)
		p[array_cp[i]]++;
	for (int i = 0; i < 100; i++)
		for (int j = 0; j < p[i]; j++)
			cout <<i << " ";
	cout << endl;
	delete[]p;
}
/*
**基数排序
*/
int getDigit(int value, int d){
	int temp = 1;
	for (int i = 0; i < d - 1; i++)
		temp *= 10;
	return (value / temp) % 10;
}
void RadixSort(int array[], int low, int high, int d){
	int i, j, count[RADIX], p1, p2;
	int *auxArray=new int[high-low+1];
	if (d <=0)return;
	for (j = 0; j < RADIX; j++)
		count[j]=0;
	for (i = low; i <= high; i++)
		count[getDigit(array[i], d)]++;
	for (j = 1; j <= RADIX; j++)
		count[j] += count[j - 1];
	for (i = low; i <= high; i++){
		j = getDigit(array[i], d);
		auxArray[count[j] - 1] = array[i];
		count[j]--;
	}
	for (i = low, j = 0; i <= high; i++, j++)
		array[i] = auxArray[j];
	for (j = 0; j < RADIX; j++){
		p1 = count[j];
		p2 = count[j + 1] - 1;
		RadixSort(array, p1, p2, d - 1);
	}
}
void RadixSort2(int array[], int k, int array_cp[]){
	cout << "RadixSort: \n";
	cp(array, k, array_cp);
	/*int maxDigit = 10;
	int **auxArray = new int*[10];
	for (int i = 0; i <10; i++){
		auxArray[i] = new int[k+1];
		auxArray[i][0] = 0;
	}
	for (int d = 1; d < maxDigit; d++){
		for (int i = 0; i < k; i++){
			int Dnum = getDigit(array_cp[i], d);
			int index = ++auxArray[Dnum][0];
			auxArray[Dnum][index] = array_cp[i];
		}
	}
	for (int i = 0, j = 0; i < 10; i++){
		for (int k = 1; k <= auxArray[i][0]; k++)
			array_cp[j++] = auxArray[i][k];
		auxArray[i][0] = 0;
	}		*/
	int tmp[10][20] = { 0 };
	int order[10] = { 0 };
	int i, j, m;
	int d;
	int p;
	d = 1;
	while (d <= 100)
	{
		for (i = 0; i < k; i++)
		{
			m = (array_cp[i] / d) % 10;
			tmp[m][order[m]] = array_cp[i];
			order[m]++;
		}
		p = 0;
		for (i = 0; i < 10; i++)
		{
			if (order[i] != 0){
				for (j = 0; j < order[i]; j++){
					array_cp[p] = tmp[i][j];
					p++;
				}
				order[i] = 0;
			}
		}
		d *= 10;
	}
	arr_cout(array_cp, k);
	//delete[] * auxArray;
}
int main(){
	int array[14] = { 10, 24, 8, 16, 4, 32, 24, 20, 35, 18,43,1,4,4};
	const int length = sizeof(array) / sizeof(array[0]);
	cout << "origin array:";
	arr_cout(array, length);
	int array_cp[length];
	InsertSort(array,length,array_cp);
	BinaryInsertSort(array, length, array_cp);
	BubbleSort(array, length, array_cp);
	SelectSort(array, length, array_cp);
	ShellSort(array, length, array_cp);
	QS_cout(array, length, array_cp);
	MS_cout(array, length, array_cp);
	HeapSort(array, length, array_cp);
	BucketSort(array, length, array_cp);
	//RadixSort(array, 0, length-1, 2);
	//arr_cout(array, length);
	RadixSort2(array, length, array_cp);
	return 0;
}