十大排序算法

1，冒泡排序

//1，冒泡排序
void bubbleSort(int arr[],int len)
{
	//外层循环到倒数第二个，则内存循环可到最后一个
	for(int i = 0;i<len-1;i++)
	{
		//注意最后的边界
		//内存循环的边界为最后已排序的前一个索引处
		for(int j = 0;j<len-1-i;j++)
		{
			if (arr[j] > arr[j+1])
				swap(arr[j], arr[j+1]);
		}
	}
}

2，选择排序

//2，选择排序
void selectSort(int arr[],int len)
{
	for(int i = 0; i<len-1; i++)
	{
		int imin = i;
		//注意起始位置，以及交换的是索引
		//内存循环找最小值索引，将最小值与外层循环当前值交换
		for(int j = i+1;j<len;j++)
		{
			if (arr[j] < arr[imin])
				imin = j;
		}
		swap(arr[i], arr[imin]);
	}
}

3，插入排序

//3,插入排序
void insertSort(int arr[],int len)
{
	for (int i = 1; i < len; i++)
	{
		//创建临时值存储要插入的元素
		int key = arr[i];
		int j = i - 1;
		//在数组前部已排序的数据中找到大于要插入值的值
		//将插入值插入在该值之后
		while (j >= 0 && key < arr[j])
		{
			arr[j + 1] = arr[j];
			j--;
		}
		arr[j + 1] = key;
	}
}

4，希尔排序

//4，希尔排序
void shellSort(int arr[],int len)
{
	//创建递减的增值序列，理论证明此增值为最高效的
	int h = 1;
	while(h<len/3)
	{
		h = 3 * h + 1;
	}

	//对每一个增值的所有待排序序列进行插入排序
	while (h >= 1)
	{
		//共有增值为h个的待排序序列,起始值索引分别为0~h-1，间隔为h
		for(int i = 0; i < h; i++)
		{
			//对每一个间隔为h的序列进行插入排序
			for (int j = i+h; j <len; j += h)
			{
				int tem = arr[j];
				int k = j - h;
				while (k >= i&&tem < arr[k])
				{
					arr[k+h] = arr[k];
					k -= h;
				}
				arr[k+h] = tem;
			}
		}
		//将增值递减
		h = h / 3;
	}
}

5，归并排序

//5，归并排序
void mergeSort(int arr[],int li,int ri,int tem[])
{
	//递归的退出条件，即最小子数组为1个
	if(li>=ri) return;
	int mid = (li + ri) / 2;

	//划分子数组
	mergeSort(arr, li, mid,tem);
	mergeSort(arr, mid + 1, ri,tem);

	//定义左右子数组的索引以及临时数组的索引
	int i = li, j = mid + 1, pos = li;

	//将左右子数组元素依次比较，将较小元素放入临时数组中
	while (i<=mid&&j<=ri)
	{
		if(arr[i]<arr[j])
			tem[pos++] = arr[i++];
		else
			tem[pos++] = arr[j++];
		
	}

	//将左或右数组中未放完的数据继续放入临时数组中
	while(i<=mid)
	{
		tem[pos++] = arr[i++];
	}
	while (j<=ri)
	{
		tem[pos++] = arr[j++];
	}

	//将临时数组的值复制到原数组对应的位置，即li到ri中间
	for(int mi = li;mi<=ri;mi++)
	{
		arr[mi] = tem[mi];
	}
}

6，快速排序

//6，快速排序
void quickSort(int arr[],int li,int ri)
{
	//一定要有递归的退出条件
	if (li >= ri) return;;
	//设定高低位指示标志，以及存储临时变量
	int low = li, hight = ri, tem = arr[li];
	while (low<hight)
	{
		// 当队尾的元素大于等于基准数据时,向前挪动high指针
		while (low < hight&&arr[hight] >= tem)
		{
			hight--;
		}
		// 如果队尾元素小于tmp了,需要将其赋值给low
		arr[low] = arr[hight];

		// 当队首元素小于等于tmp时,向后挪动low指针
		while (low < hight&&arr[low] <= tem)
		{
			low++;
		}
		// 当队首元素大于tmp时,需要将其赋值给high
		arr[hight] = arr[low];
	}
	// 外层循环结束时low和high相等,此时的low或high就是tmp的正确索引位置
	// 由原理部分可以很清楚的知道low位置的值并不是tmp,所以需要将tmp赋值给arr[low]
	arr[low] = tem;

	// 进行迭代对low之前和之后的数组进行相同的操作使整个数组变成有序
	quickSort(arr, li, low - 1);
	quickSort(arr, low + 1, ri);
}

7，堆排序

//7，堆排序
void heapAdjust(int arr[],int si,int ei)
{
	//调整堆结构，使之成为大顶堆
	//由父节点计算左节点
	int dad = si, son = dad * 2 + 1;
	while(son<=ei)
	{
		//选择最大子节点的索引,下一次父节点的调整方向为最大子节点处
		if (son + 1 <= ei && arr[son] < arr[son + 1])
			son++;
		//如果父节点已经大于子节点就直接返回
		if (arr[dad] > arr[son])
			return;
		else
		{
			//交换父子节点
			swap(arr[dad], arr[son]);
			dad = son;
			son = dad * 2 + 1;
		}

	}
}
void heapSort(int arr[],int len)
{
	//初始化堆，从最后一个父节点开始，即从下往上
	for (int i = len / 2 - 1; i >= 0; i--)
	{
		heapAdjust(arr, i, len - 1);
	}
	for (int i = len - 1; i > 0; i--)
	{
		//将堆的最后一个元素与堆顶元素交换，即最大的元素依次放到了最后
		swap(arr[0], arr[i]);
		//重新调整堆结构
		heapAdjust(arr, 0, i - 1);
	}
}

8，计数排序

//8，计数排序
void countSort(int arr[],int len)
{
	//查找待排序数组的最大最小值
	int vmax = arr[0], vmin = arr[0];
	for(int i = 1;i<len;i++)
	{
		if (arr[i] > vmax)
			vmax = arr[i];
		if (arr[i] < vmin)
			vmin = arr[i];
	}

	// 创建差值大小的数组
	int d = vmax - vmin+1;
	int *tem = new int[d];
	for (int j = 0; j < d; j++)
	{
		tem[j] = 0;
	}
	for(int i = 0;i<len;i++)
	{
		tem[arr[i] - vmin]++;
	}

	int k = 0;
	for (int i = 0; i < d; i++)
	{
		for(int j = 0;j<tem[i];j++)
		{
			arr[k++] = i + vmin;
		}
	}
}

9，桶排序

10，基数排序

main函数

#include "stdafx.h"
#include <iostream>
#include <queue>
using namespace std;

//数据打印
void printData(int arr[],int n)
{
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

int main() {
	int n = 10;
	int nums[10] = { 5,3,8,2,4,1,6,7,9,0 };
	int *tem = new int[10];
	cout << "sort before: ";
	printData(nums, n);
	cout << "sort  after: ";
	// bubbleSort(nums, n);
	// selectSort(nums, n);
	// insertSort(nums, n);
	// shellSort(nums, n);
	// mergeSort(nums, 0, n - 1, tem);
	// quickSort(nums, 0, n - 1);
	// heapSort(nums, n);
	
	printData(nums, n);
	cout << endl;
	delete[]tem;
	system("pause");
	return 0;
}