比较经典的排序算法--C++实现

不过多解释，桶排序及堆排序还是有点难顶！
测试代码

#include <iostream>
#include"opencv.hpp"
#include"sort.h"

using namespace std;
using namespace cv;

int main()
{
	int arr[10] = {3,6,5,4,8,9,7,8,2,3};
	BucketSort(arr,10);
	ShowArraySort(arr, 10);
	waitKey(0);
	return 0;
}

排序算法

/*
主要是实现排序算法
https://www.cnblogs.com/itsharehome/p/11058010.html
*/
#pragma once
#ifndef __SORT__
#define __SORT_

#include <iostream>
#include <stdio.h>
#include "vector"
#include <cmath>
using namespace std;

//数组显示
void ShowArraySort(int* arr, int len)
{
	int i;
	for (i = 0; i < len; ++i)
		cout <<"arr["<<i<<"] = "<< arr[i] << endl;
}
//选择排序
void SelectionSort(int* arr,int len)
{
	int i, j, l;
	int t;
	for (i = 0; i < len; ++i)
	{
		l = i;
		for (j = i; j < len; ++j)
		{
			if (arr[l] > arr[j])
			{
				l = j;
			}
		}
		if (i != l)
		{
			t = arr[i];
			arr[i] = arr[l];
			arr[l] = t;
		}
	}
}
//插入排序
void InsertionSort(int* arr, int len)
{
	int i,j;
	int value;
	for (i = 1; i < len; ++i)
	{
		value = arr[i];
		j = i - 1;
		while (j >= 0&&arr[j] > value)
		{
				arr[j+1] = arr[j];
				j--;
		}
		arr[j+1] = value;
	}
}
//冒泡排序
void BubbleSort(int* arr, int len)
{
	int i, j;
	int value;
	for (i = 0; i < len; ++i)
	{
		for (j = 0; j < len-i-1; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				value = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = value;
			}
		}
	}
}
//希尔排序
void HillSort(int* arr, int len)
{
	int i,j;
	int value;
	int location;
	for (location = len / 2; location > 0; location = location/2)
	{
		for (i = location; i < len; i = i + location)
		{
			value = arr[i];
			for (j = i-location; j>=0&&value<arr[j]; j = j - location)
			{
				arr[j + location] = arr[j];
			}
			arr[j + location] = value;
		}
	}
}
//归并排序
void MergeArray(int* arr, int left, int mid, int right)
{
	int len = right - left + 1;
	int* a = new int[len]();
	int i = left;
	int j = mid + 1;
	int k = 0;
	while (i <= mid && j <= right)
	{
		if (arr[i] < arr[j])
		{
			a[k] = arr[i];
			k++;
			i++;
		}
		else
		{
			a[k] = arr[j];
			k++;
			j++;
		}
	}
	while (i <= mid && k < len)
	{
		a[k] = arr[i];
		k++;
		i++;
	}
	while (j <= right && k < len)
	{
		a[k] = arr[j];
		k++;
		j++;
	}
	for (i = 0; i < k; ++i)
	{
		arr[left++] = a[i];
	}
}
void MergeSort(int* arr,int left, int right)
{
	int mid;
	if (left < right)
	{
		mid = (left + right) / 2;
		MergeSort(arr,left, mid);
		MergeSort(arr,mid + 1, right);
		MergeArray(arr,left,mid,right);
	}
}
//快速排序
int QuickSortChildren(int* arr,int left,int right)
{
	int p = left+1, q = right;
	int t;
	int value = arr[left];
	while (p<q)
	{
		while (p<q && arr[p] <= value)
			p++;
		while (p<q && arr[q] >= value)
			q--;
		t = arr[p];
		arr[p] = arr[q];
		arr[q] = t;
	}
	if (p == q)
	{
		if (arr[p] < value)
		{
			arr[left] = arr[q];
			arr[q] = value;
		}
		else
		{
			arr[left] = arr[q-1];
			arr[q-1] = value;
			q = q - 1;
		}
	}
	return q;
}
void QuickSort(int* arr, int left,int right)
{
	int mid;
	if (left < right)
	{
		mid = QuickSortChildren(arr,left,right);
		QuickSort(arr,left,mid-1);//左
		QuickSort(arr, mid + 1, right);//右
	}
}
//堆排序，有点复杂
void DownAdjust(int* arr, int parent, int len)
{
	int temp = arr[parent];
	int children = 2 * parent + 1;
	while (children <= len)
	{
		if (children + 1 <= len && arr[children] < arr[children + 1])
			children++;
		if (arr[children] <= temp)
			break;
		arr[parent] = arr[children];
		parent = children;
		children = 2 * parent + 1;
	}
	arr[parent] = temp;
}
void HeapSort(int* arr, int len)
{
	int i,temp;
	//建堆
	for (i = (len - 2) / 2; i >= 0; --i)
		DownAdjust(arr, i, len - 1);
	//堆排序
	for (i = len - 1; i >= 1; i--)
	{
		temp = arr[i];
		arr[i] = arr[0];
		arr[0] = temp;
		DownAdjust(arr, 0, i - 1);
	}
}
//计数排序
int MaxNumber(int* arr, int len)
{
	int i;
	int temp = arr[0];
	for (i = 0; i < len; ++i)
		if (temp < arr[i])
			temp = arr[i];
	return temp;
}
int MinNumber(int* arr, int len)
{
	int i;
	int temp = arr[0];
	for (i = 0; i < len; ++i)
		if (temp > arr[i])
			temp = arr[i];
	return temp;
}
void CountSort(int* arr, int len)
{
	int i,j;
	int max = MaxNumber(arr, len);
	int min = MinNumber(arr, len);
	int distance = max - min + 1;
	int* ret = new int[distance]();
	for (i = 0; i < distance; ++i)
		ret[i] = 0;
	for (i = 0; i < len; ++i)
		ret[arr[i] - min]++;
	j = 0;
	for (i = 0; i < max + 1; ++i)
	{
		while (ret[i] > 0)
		{
			arr[j] = i + min;
			ret[i]--;
			j++;
		}
	}
}
//基数排序
void RadixSort(int* arr,int len)
{
     int digitValue;
	 int digit = MaxNumber(arr, len);
     for (int i = 1; i <= digit; i++) 
	 {
         vector<int> digitValueList[10];

         for (int j = 0; j != len; j++) 
		 {
             //得到位值，相同位值得就加在后面，这样还是有序的。
             digitValue = (arr[j] % (int)(pow(10.0, i)) - arr[j] %(int)(pow(10.0, i - 1))) / pow(10.0, i - 1);
             digitValueList[digitValue].push_back(arr[j]);

		}
         //把所有的元素读进数组
         int count = 0;
         for (int j = 0; j != 10; j++) 
		 {
             for (int k = 0; k != digitValueList[j].size(); k++) 
			 {
                 arr[count] = digitValueList[j][k];
                 count++;
			}
		}
	}
}
//桶排序,有点复杂
void BucketSort(int* arr, int len) 
{
	list<double>* b = new list<double>[len];
	for (int i = 0; i < len; i++) 
		b[int(arr[i])].push_back(arr[i]);
	for (int i = 0; i < len; i++) 
		b[i].sort();
	for (int i = 0, j = 0; i < len; i++) 
	{
		while (b[j].size() < 1)j++;
		arr[i] = b[j].front();
		b[j].pop_front();
	}
}
#endif // __CLASS_TEST__

比较好的博客