算法：一些 4000 经典的排序算法

//下面的排序算法中，数据类型T根据情况，需要重载比较操作符或类型转换操作符

#include<cmath>
#include<ctime>
#include<iostream>
#include<iomanip>

using namespace std;

//-----------------------------------------------------------------------------
//直接插入排序
//稳定的

template<typename T>
void InsertSort(T arr[], int n) {
T temp;
int i, j;
for (i = 1; i < n; i++) {
temp = arr[i];
j = i - 1;
while (j >= 0 && arr[j] > temp) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
return;
}

//-----------------------------------------------------------------------------
//Shell排序(增量序列为1,2,4,8,16,...,2^k)
//不稳定的

template<typename T>
void ShellSort(T arr[], int n) {
T temp;
int delta, i, j, k;
for(delta=n/2;delta>0;delta/=2)
for(i=0;i<delta;i++)
for (j = i + delta; j < n; j += delta) {
temp = arr[j];
k = j - delta;
while (k >= 0 && arr[k] > temp) {
arr[k + delta] = arr[k];
k -= delta;
}
arr[k + delta] = temp;
}
return;
}

//-----------------------------------------------------------------------------
//直接选择排序
//不稳定的

template<typename T>
void SelectSort(T arr[], int n) {
T temp;
int i, j, t;
for (i = 0; i < n - 1; i++) {
t = i;
for (j = i + 1; j < n; j++) {
if (arr[j] < arr[t])
t = j;
}
temp = arr[i];
arr[i] = arr[t];
arr[t] = temp;
}
return;
}

//-----------------------------------------------------------------------------
//堆排序(大顶堆)
//不稳定的

template<typename T>
void HeapAdjust(T arr[], int i, int n) {
T temp = arr[i];
int j;
while (i < n / 2) {
j = i * 2 + 1;
if (j + 1 < n && arr[j + 1] > arr[j])
j = j + 1;
if (arr[j] > temp)
arr[i] = arr[j];
else
break;
i = j;
}
arr[i] = temp;
return;
}

template<typename T>
void HeapSort(T arr[], int n) {
T temp;
int i;
for (i = n / 2 - 1; i >= 0; i--)
HeapAdjust(arr, i, n);
for (i = n - 1; i > 0; i--) {
temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
HeapAdjust(arr, 0, i);
}
return;
}

//-----------------------------------------------------------------------------
//冒泡排序
//稳定的

template<typename T>
void BubbleSort(T arr[], int n) {
T temp;
int i, j;
bool flag;
for (i = 0; i < n - 1; i++) {
flag = true;
for (j = n - 1; j > i; j--) {
if (arr[j - 1] > arr[j]) {
temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
flag = false;
}
}
if (flag)
break;
}
return;
}

//-----------------------------------------------------------------------------
//快速排序
//不稳定的

template<typename T>
void QuickSort(T arr[], int lo, int hi) {
T temp;
int pivot, lo_t = lo, hi_t = hi;
if (lo < hi) {
pivot = (lo + hi) / 2;
temp = arr[pivot];
arr[pivot] = arr[hi];
while (lo_t < hi_t) {
while (arr[lo_t] <= temp && lo_t < hi_t)
lo_t++;
if (lo_t < hi_t)
arr[hi_t--] = arr[lo_t];
while (arr[hi_t] >= temp && lo_t < hi_t)
hi_t--;
if (lo_t < hi_t)
arr[lo_t++] = arr[hi_t];
}
arr[lo_t] = temp;
QuickSort(arr, lo, lo_t - 1);
QuickSort(arr, hi_t + 1, hi);
}
return;
}

//-----------------------------------------------------------------------------
//归并排序
//稳定的

template<typename T>
void MergeSort(T arr[], T arr_t[], int lo, int hi) {
int mid, i, m, n;
if (lo < hi) {
mid = (lo + hi) / 2;
MergeSort(arr, arr_t, lo, mid);
MergeSort(arr, arr_t, mid + 1, hi);
for (i = lo; i <= hi; i++)
arr_t[i] = arr[i];
i = lo;
m = lo;
n = mid + 1;
while (m <= mid && n <= hi) {
if (arr_t[m] <= arr_t
)
arr[i++] = arr_t[m++];
else
arr[i++] = arr_t[n++];
}
while (m <= mid)
arr[i++] = arr_t[m++];
while (n <= hi)
arr[i++] = arr_t[n++];
}
return;
}

//-----------------------------------------------------------------------------
//桶式排序
//稳定的

template<typename T>
void BucketSort(T arr[], int n, int max) {
T *arr_t = new T
;
int *cnt = new int[max];
int i;
for (i = 0; i < n; i++)
arr_t[i] = arr[i];
for (i = 0; i < max; i++)
cnt[i] = 0;
for (i = 0; i < n; i++)
cnt[arr[i]]++;
for (i = 1; i < max; i++)
cnt[i] += cnt[i - 1];
for (i = n - 1; i >= 0; i--)
arr[--cnt[arr_t[i]]] = arr_t[i];
delete[] arr_t;
delete[] cnt;
return;
}

//-----------------------------------------------------------------------------

template<typename T>
void disorder(T arr[], int n) {
for (int i = 0; i < n; i++)
swap(arr[rand() % n], arr[rand() % n]);
return;
}

template<typename T>
void display(T arr[], int n) {
int i = 0;
while (i < n) {
cout << setw(4) << arr[i] << " ";
if (++i % 10 == 0)
cout << endl;
}
cout << endl;
return;
}

#define MAX 100

int main() {
int arr[MAX], temp[MAX];
for (int i = 0; i < MAX / 2; i++)
arr[i] = arr[MAX - 1 - i] = i;

disorder(arr, MAX);
display(arr, MAX);
cout << "InsertSort:" << endl;
InsertSort(arr, MAX);
display(arr, MAX);

disorder(arr, MAX);
display(arr, MAX);
cout << "ShellSort:" << endl;
ShellSort(arr, MAX);
display(arr, MAX);

disorder(arr, MAX);
display(arr, MAX);
cout << "SelectSort:" << endl;
SelectSort(arr, MAX);
display(arr, MAX);

disorder(arr, MAX);
display(arr, MAX);
cout << "HeapSort:" << endl;
HeapSort(arr, MAX);
display(arr, MAX);

disorder(arr, MAX);
display(arr, MAX);
cout << "BubbleSort:" << endl;
BubbleSort(arr, MAX);
display(arr, MAX);

disorder(arr, MAX);
display(arr, MAX);
cout << "QuickSort:" << endl;
QuickSort(arr, 0, MAX - 1);
display(arr, MAX);

disorder(arr, MAX);
display(arr, MAX);
cout << "MergeSort:" << endl;
MergeSort(arr, temp, 0, MAX - 1);
display(arr, MAX);

disorder(arr, MAX);
display(arr, MAX);
cout << "BucketSort:" << endl;
BucketSort(arr, MAX, MAX);
display(arr, MAX);

getchar();
return 0;
}