琅琊算法榜——排序算法大观园

在学习数据结构与算法的时候，排序算法总是最热闹的一块，现将各种各样的排序算法归纳总结如下。

1选择排序

选择排序是每次都从未排序序列中选择出最大元素，放到已排序序列的队首

代码实现如下：

#include <iostream>
#include <algorithm>
using namespace std;
void selectionSort(int a[], int length)
{
	if (length <= 0)
	{
		return;
	}
	for (int i = 0; i < length; ++i)
	{
		int min_index = i;
		for (int j = i + 1; j < length; ++j)
		{
			if (a[j] < a[min_index])
			{
				min_index = j;
			}
		}
		swap(a[i], a[min_index]);
	}
}

int main()
{
	int length = 100;
	int* a = new int[length];
	for (int i = 0; i < length; ++i)
	{
		a[i] = rand() % length;
	}
	selectionSort(a, length);
	copy(a, a + length, ostream_iterator<int>(cout, " "));
	delete[] a;
	system("pause");
	return 0;
}

2冒泡排序

从头扫描到尾，依次比较相邻的两个元素，将较大的放在前面，如此持续，将最大的元素冒泡到尾部，然后对未排序序列继续Bubble过程，直至已序，或长度衰减到平方情况

bool bubble(int a[], int length)//冒泡扫描
{
	bool res = true;
	int i = 0;
	while (i<length - 1)
	{
		if (a[i]>a[i + 1])
		{
			res = false;
			swap(a[i], a[i + 1]);
		}
		++i;
	}
	return res;
}
void bubbleSort(int a[], int length)
{
	if (length <= 1)
	{
		return;
	}
	int i = 0;
	while (i < length)
	{
		bool isSorted = bubble(a, length);
		if (isSorted)
		{
			return;//已序
		}
		else
		{
			length--;//长度减1
		}
	}
}
int main()
{
	int length = 100;
	int* a = new int[length];
	for (int i = 0; i < length; ++i)
	{
		a[i] = rand() % length;
	}
	bubbleSort(a, length);
	copy(a, a + length, ostream_iterator<int>(cout, " "));
	delete[] a;
	system("pause");
	return 0;
}

3插入排序

插入排序的思路是从第2个元素开始，在已序部分中找到他应该插入的位置（前一个元素比他小，后一个元素不比他小），将其插入其中。

void insertionSort(int a[], int length)
{
	int i = 0;
	while (i < length)
	{
		int j = 0;
		while (j < i)
		{
			if (a[i]<a[0])//应该插在序列第一个位置
			{
				int temp = a[i];
				for (int k = i; k>0; --k)
				{
					a[k] = a[k - 1];
				}
				a[0] = temp;
				break;
			}
			if (a[i] > a[j] && a[i] <= a[j + 1])
			{
				int temp = a[i];
				for (int k = i; k > j + 1; --k)
				{
					a[k] = a[k - 1];
				}
				a[j + 1] = temp;
				break;
			}
			++j;
		}
		++i;
	}
}

4归并排序

将问题规模不断缩小，直至区间长度为1，然后归并已序序列。二路归并，两个游标初始化为两路的第一个位置，而后进行比较，将较小的元素送到输出序列，对应的游标后移一位，如此持续直到有一路为空，最后将另一路剩余元素拷贝到输出序列的末尾。该算法不能就地实现，需要与输入规模相等的辅助空间。

//归并排序，不可能就地
void merge(int a[], int lo, int mid, int hi)
{
	int length = hi - lo;
	int* res = new int[length];

	int p1 = lo;
	int p2 = mid;
	int i = 0;
	while (p1 < mid && p2 < hi)
	{
		if (a[p1] <= a[p2])
		{
			res[i] = a[p1];
			++p1;
		}
		else
		{
			res[i] = a[p2];
			++p2;
		}
		++i;
	}
	if (p1 == mid)
	{
		while (p2 < hi)
		{
			res[i] = a[p2];
			++p2;
			++i;
		}
	}
	if (p2 == hi)
	{
		while (p1 < mid)
		{
			res[i] = a[p1];
			++p1;
			++i;
		}
	}
	for (int i = 0; i < length; ++i)
	{
		a[lo + i] = res[i];
	}
	delete[]res;
}
void mergeSort(int a[], int lo, int hi)
{
	int length = hi - lo;
	if (length <= 1)
	{
		return;
	}
	int mid = length >> 1;

	mergeSort(a, lo, lo + mid);
	mergeSort(a, lo + mid, hi);
	merge(a, lo, lo + mid, hi);
}

5桶排序

参见前面文章散列/桶排序

6堆排序

堆排序本质上还是选择排序，但是因为是通过优先级队列的方式组织的序列，每次查找最大元只需要常数的时间，时间花耗主要在建堆上面，以及每次删除最大元后重新维护堆序性上面。

//堆排序
#define Parent(i) (i-1)>>1
#define Lchild(i) 2*i+1
#define Rchild(i) 2*i+2
void percolateDown(int a[], const int& length, int i)//下滤算法
{
	int lc = Lchild(i);
	int rc = Rchild(i);
	if (lc==length-1)
	{
		if (a[i] < a[lc])
		{
			swap(a[i], a[lc]);
			return;
		}
	}
	if (lc < length - 1 )
	{
		if (a[i]>=a[lc] &&a[i]>=a[rc])
		{
			return;
		}
		else
		{
			int next = a[lc] >= a[rc] ? lc : rc;
			swap(a[next], a[i]);
			percolateDown(a, length, next);
		}
	}
	

}
void _make_heap(int a[], const int &length)//建堆算法
{
	int mark = Parent(length - 1);
	while (mark >= 0)
	{
		percolateDown(a, length, mark);
		--mark;
	}
}
void delete_max(int a[], int &length)//删除最大元，只是将最大元移到序列的尾部，然后将堆的规模减1，并没有真的删除
{
	swap(a[0], a[length - 1]);
	--length;
	percolateDown(a, length, 0);
}

int main()
{
	int length = 100;
	int* a = new int[length];
	for (int i = 0; i < length; ++i)
	{
		a[i] = rand() % length;
	}
	_make_heap(a, length);

	for (int i = 0; i < length;)//注意每次删除最大元，length的大小会减1，因此不用递增i
	{
		delete_max(a, length);
	}
	copy(a, a + 100, ostream_iterator<int>(cout, " "));
	delete[] a;
	system("pause");
	return 0;
}

7快速排序

快速排序首先找到一个参考的元素，理论上可以任意选取，但是从性能上考虑，选择第一个元素，中间位置元素，最后一个元素的中间那个元素比较好，此为“三值取中”。然后以该元素为参考，p1自前向后扫描，直到找到第一个不小于该元素的位置停止，p2自后往前扫描，直到找到不大于该元素的位置停止，如果此时p1在p2的左侧，则交换两个元素，此时p1的位置即是完全排序后参考元素应处的位置，该元素左侧均比他小，右侧均不比他大。思想还是分治法。

int medianof3(int a, int b, int c)
{
	if (max(max(a, b), c) == c)
	{
		return max(a, b);
	}
	else
	{
		return a > b ? max(b, c) : max(a, c);
	}
}
void quickSort(int a[], int lo,int hi)
{
	int length = hi - lo;
	if (length==1)
	{
		return;
	}
	int mid = length >> 1;
	int pivot = medianof3(a[lo], a[lo+mid], a[hi-1]);
	int p1 = lo;
	int p2 = hi-1;
	while (p1<p2)
	{
		while (a[p1]<pivot)//考虑区间中只有两个元素的情况，这里都不能取等于号，
		{
			++p1;
		}
		while (a[p2]>pivot)
		{
			--p2;
		}
		if (p1 < p2)
		{
			swap(a[p1], a[p2]);
			++p1;
			--p2;
		}
	}
	quickSort(a, lo, p1);
	quickSort(a, p1, hi);
}

8性能总结

基于windows7,8G内存，Intel处理器，100000个数据。