八种排序算法大集合（选择排序，插入排序，希尔排序，冒泡排序，快速排序，桶排序，基数排序，归并排序，堆排序）

八种排序的实现

代码

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <ctime>

using namespace std;

// 输出结果
void Print_Array(int* arr, int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("%d", arr[i]);
		i == n - 1 ? printf("\n") : printf(" ");
	}
}

// 随机生成检验数组
void Rand_Array(int* arr)
{
    for (int i = 0; i < 10; ++i)
        arr[i] = rand() % 100 + 1;
}

// 选择排序
void Select_Sort(int* arr, int n)
{
	int temp;

	for (int i = 0; i < n - 1; ++i)
	{
		temp = i;
		for (int j = i + 1; j < n; ++j)
			if (arr[temp] > arr[j])
			{
				temp = j;
			}
		if (temp != i)
		{
			int t = arr[i];
			arr[i] = arr[temp];
			arr[temp] = t;
		}
	}
}

void Select_Sort_Reult(int* arr, int n)
{
	printf("选择排序：\n");
	Select_Sort(arr, n);
	Print_Array(arr, n);
}

// 插入排序
void Insertion_Sort(int* arr, int n)
{
	int temp, j;
	for (int i = 1; i < n; ++i)
	{
		temp = arr[i];
		for (j = i - 1; (j >= 0) && (arr[j] > temp); --j)
		{
			arr[j + 1] = arr[j];
		}

		arr[j + 1] = temp;
	}
}

void Insertion_Sort_Reult(int* arr, int n)
{
	printf("插入排序：\n");
	Insertion_Sort(arr, n);
	Print_Array(arr, n);
}

// 希尔排序
void Shell_Sort(int* arr, int n)
{
	int gap = n;

	while (1)
	{
		gap /= 2;

		for (int x = 0; x < gap; ++x)
		{
			for (int i = x + gap; i < n; i += gap)
			{
				int temp = arr[i];
				int j;
				for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
					arr[j + gap] = arr[j];

				arr[j + gap] = temp;
			}
		}

		if (gap == 1)
			break;
	}
}

void Shell_Sort_Reult(int* arr, int n)
{
	printf("希尔排序：\n");
	Shell_Sort(arr, n);
	Print_Array(arr, n);
}

// 冒泡排序
void Bubble_Sort(int* arr, int n)
{
	for (int i = 0; i < n - 1; ++i)
		for (int j = 0; j < n - 1 - i; ++j)
		{
			if (arr[j + 1] < arr[j])
			{
				int t = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = t;
			}
		}
}

void Bubble_Sort_Reult(int* arr, int n)
{
	printf("冒泡排序：\n");
	Bubble_Sort(arr, n);
	Print_Array(arr, n);
}

// 快速排序
void Quick_Sort(int* arr, int left, int right)
{
	int mid = (left + right) / 2;
	int i, j, t;
	if (left > right) return;

	int temp = arr[mid];
	i = left, j = right;
	while (i != j)
	{
		while (arr[j] >= temp && i < j)
			j--;
		while (arr[i] <= temp && i < j)
			i++;
		if (i < j)
		{
			t = arr[i];
			arr[i] = arr[j];
			arr[j] = t;
		}
	}

	arr[mid] = arr[i];
	arr[i] = temp;

	Quick_Sort(arr, left, i - 1);
	Quick_Sort(arr, i + 1, right);

	return;
}

void Quick_Sort_Reult(int* arr, int n)
{
	printf("快速排序：\n");
	Quick_Sort(arr, 0, n - 1);
	Print_Array(arr, n);
}

// 桶排序
void Bucket_Sort(int* arr, int n)
{
	int ans[101] = { 0 };
	int maxn = -1;
	for (int i = 0; i < n; ++i)
	{
		maxn = max(maxn, arr[i]);
		ans[arr[i]]++;
	}

	printf("桶排序：\n");

	for (int i = 0; i <= maxn; ++i)
	{
		while (ans[i])
		{
			printf("%d", i);
			i == maxn && ans[i] == 1 ? printf("\n") : printf(" ");
			ans[i]--;
		}
	}
}

// 基数排序
int Max_Bit(int* arr, int n)
{
	int numbit = 0;
	int p = 1;
	for (int i = 0; i < n; ++i)
	{
		if (arr[i] >= p)
		{
			++numbit;
			p *= 10;
		}
	}
}

void Radix_Sort(int* arr, int n)
{
	int numbit = Max_Bit(arr, n);
	int cnt[10];
	int tmp[100];
	int radix = 1;

	for (int i = 1; i <= numbit; ++i)
	{
		for (int j = 0; j <= 9; ++j)
			cnt[j] = 0;

		for (int j = 0; j < n; ++j)
			cnt[(arr[j] / radix) % 10]++;

		for (int j = 1; j <= 9; ++j)
			cnt[j] = cnt[j] + cnt[j - 1];

		for (int j = n - 1; j >= 0; --j)
		{
			tmp[cnt[(arr[j] / radix) % 10] - 1] = arr[j];
			cnt[(arr[j] / radix) % 10]--;
		}

		for (int j = 0; j < n; ++j)
			arr[j] = tmp[j];

		radix *= 10;
	}
}

void Radix_Sort_Reult(int* arr, int n)
{
	printf("基数排序：\n");
	Radix_Sort(arr, n);
	Print_Array(arr, n);
}

// 归并排序
void Merge(int* arr, int l, int mid, int r)
{
	int aux[r - l + 1];

	for (int i = l; i <= r; ++i)
		aux[i - l] = arr[i];

	int i = l, j = mid + 1;

	for (int k = l; k <= r; ++k)
	{
		if (i > mid)
		{
			arr[k] = aux[j - l];
			j++;
		}
		else if (j > r)
		{
			arr[k] = aux[i - l];
			i++;
		}
		else if (aux[i - l] < aux[j - l])
		{
			arr[k] = aux[i - l];
			i++;
		}
		else
		{
			arr[k] = aux[j - l];
			j++;
		}
	}
}

void Merge_Sort(int* arr, int l, int r)
{
	if (l >= r) return;
	int mid = (l + r) / 2;
	Merge_Sort(arr, l, mid);
	Merge_Sort(arr, mid + 1, r);
	Merge(arr, l, mid, r);
}

void Merge_Sort_Result(int* arr, int n)
{
    printf("归并排序：\n");
	Merge_Sort(arr, 0, n - 1);
	Print_Array(arr, n);
}

// 堆排序
void Max_Heapify(int* arr, int left, int right)
{
	int dad = left;
	int son = 2 * dad + 1;
	while (son <= right)
	{
		if (son + 1 <= right && arr[son] < arr[son + 1])
			son++;
		if (arr[dad] > arr[son])
			return;
		else
		{
			int t = arr[dad];
			arr[dad] = arr[son];
			arr[son] = t;
			dad = son;
			son = dad * 2 + 1;
		}
	}
}

void Heap_Sort(int* arr, int n)
{
	for (int i = n / 2 - 1; i >= 0; --i)
		Max_Heapify(arr, i, n - 1);
	for (int i = n - 1; i >= 0; --i)
	{
		int t = arr[0];
		arr[0] = arr[i];
		arr[i] = t;
		Max_Heapify(arr, 0, i - 1);
	}
}

void Heap_Sort_Reult(int* arr, int n)
{
	printf("堆排序：\n");
	Heap_Sort(arr, n);
	Print_Array(arr, n);
}

int main()
{
	int n = 10;
	int a[100];

	Rand_Array(a);
	Select_Sort_Reult(a, n);

	Rand_Array(a);
	Insertion_Sort_Reult(a, n);

	Rand_Array(a);
	Shell_Sort_Reult(a, n);

	Rand_Array(a);
	Bubble_Sort_Reult(a, n);

	Rand_Array(a);
	Quick_Sort_Reult(a, n);

	Rand_Array(a);
	Bucket_Sort(a, n);

	Rand_Array(a);
	Radix_Sort_Reult(a, n);

	Rand_Array(a);
	Merge_Sort_Result(a, n);

	Rand_Array(a);
	Heap_Sort_Reult(a, n);

	getchar(); getchar();

	return 0;
}

结果