排序算法总结

一、冒泡排序

冒泡排序的关键代码如下

for (int i = n-1; i>=0; i--)
	{
		for (int j = i; j >= 0; j--)
		{
			if (p[j]>p[i])
			{
				int temp = p[j];
				p[j] = p[i];
				p[i] = temp;
			}
		}
	}

二、希尔排序
希尔排序是插入排序的升级版本，比插排的性能更好
关键代码如下

int gap = n;
	int temp;
	while (gap>0)
	{
		gap = gap >> 1;
		for (int i = gap; i < n; i++)
		{
			temp = p[i];
			int pre = i - gap;
			while (p[pre]>temp&&pre>=0)//这里是插入排序
			{
				p[pre + gap] = p[pre];
				pre -= gap;
			}
			p[pre+gap] = temp;
		}
	}

三、快速排序
快速排序的代码如下
主要步骤有
1.找出待待排序列中的枢轴值。
2.对枢轴值左边的值构成的子序列重复第一步骤递归排序。
3.对枢轴值右边的值构成的子序列重复第一步骤递归排序。
所以一般我们可以在找枢轴的时候可以进行优化（过段时间会补充快排的优化版本）

void quicksort(int low, int high, int p[])
{
	if (low<high)
	{
		int i = low;
		int j = high;
		int k = p[low];
		while (i<j)
		{
			while (i<j && p[j]>k)
				j--;
			if (i<j)
			{
				p[i] = p[j];
				i++;
			}
			while (i<j&&p[i]<k)
				i++;
			if (i<j)
			{
				p[j] = p[i];
				j--;
			}
		}
		p[i] = k;
		quicksort(low, i - 1, p);
		quicksort(i + 1, high, p);
	}
}

四、归并排序
归并排序就是让一个数组不断地分成两份，直到分到只剩一个元素，这个时候计算机会认为排序完成，然后计算机会将两个数组按元素大小结组临时数组排序。然后再将临时数组赋值给数组（完善的归并排序会过一段时间写出来）

void mergearry(int a[], int first,int middle, int end, int temp[])
{
		int i = first;
		int j = middle + 1;
		int n = middle;
		int m = end;
		int k = 0;
		while (i <= n && j <= m)
		{
			if (a[i] <= a[j])
				temp[k++] = a[i++];
			else
				temp[k++] = a[j++];
		}
		while (i <= n)
			temp[k++] = a[i++];
		while (j <= m)
			temp[k++] = a[j++];
		for (int x = 0; x < k; x++)
		{
			a[first + x] = temp[x];
		}	
}
void mergesort(int a[], int first, int end, int temp[])
{
	if (first<end)
	{
		int middle = (first + end) /2;
		mergesort(a, first, middle, temp);
		mergesort(a, middle + 1, end, temp);
		mergearry(a, first,middle ,end, temp);
	}
}

int main()
{
	int n;
	cin >> n;
	int temp[100];
	int* p = new int[n];
	for (int i = 0; i < n; i++)
		cin >> p[i];

	mergesort(p, 0, n-1, temp);
	for (int i = 0; i < n; i++)
	{
		cout << p[i] << "\t";
	}

}

五、插入排序
插入排序是假设前面的都已经排好序了，所以就只需要比较与之相邻的数就行，如何过前一个数大于它，则交换位置，如果不大于则不动

void insert(int a[],int len)
{
	int i, j;
	for (i = 0; i < len - 1; i++)
	{//控制循环次数
		for (j = i + 1; j > 0; j--)
		{//与前面的数比价大小
			if (a[j] < a[j - 1])
				swap(a[j - 1], a[j]);
			else
				break;
		}
	}
}

六、选择排序
是一种简单直观的排序算法。工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

void choice(int a[], int len)
{
	for (int i = 0; i < len; i++)
	{
		int index = i;
		for (int j = i+1; j < len; j++)
		{
			if (a[j] > a[index])
				index = j;
		}
		if (index!=i)
			swap(a[index], a[i]);
	}
}

七、堆排序
核心思想：先建成最大堆，然后将最大堆的第一个元素与最后一个节点交换位置，然后递归该过程。
话不多说，上代码

//堆排序代码实现
#include<iostream>
#include<algorithm>
using namespace std;
//维护最大堆的性质
void max_Heap(int a[],int i,int len)
{
	int left_index = i * 2;
	int largest_index;
	int right_index = i * 2 + 1;
	if (a[i] < a[left_index] && left_index <= len)
		largest_index = left_index;
	else
		largest_index = i;
	if (a[largest_index] < a[right_index] && right_index <= len)
		largest_index = right_index;
	if (largest_index != i)
	{
		swap(a[i], a[largest_index]);
		max_Heap(a, largest_index, len);
	}
}
//将数组变成最大的堆。叶子节点的下标是分别是len/2+1......len/2+n，所以第一个不是叶子节点的下标是len/2;
void max_Build(int a[],int len)
{
	for (int i = len>>1; i>0 ; i--)
		max_Heap(a,i,len);
}
void heapSort(int a[],int len)
{
	max_Build(a, len);
	for (int i = len; i>=2 ; i--)
	{
		swap(a[1], a[i]);
	    len = len - 1;
		max_Heap(a, 1, len);
	}
}
//最后上个main函数，可以试一下
int main()
{
	int n;
	cin >> n;
	int* p = new int[n+1];
	for (int i = 1; i < n+1; i++)
	{
		cin >> p[i];
	}
	cout << endl;
	heapSort(p, n);
	for (int i = 1; i < n+1; i++)
	{
		cout << p[i]<<"\t";
	}
}

本篇文章会总结笔者遇到过的所有排序算法，不断地进行扩充，并且进行优化，如果有不懂的可以给我留言，我会帮你解答（不过我是菜鸡）本篇全是笔者一点一滴敲出来的代码。后续会补充算法并且将排序的方法进行优化
未完待续…