7大常用排序算法总结_最常用的排序算法-优快云博客

常用算法总结（包括代码，时间复杂度）

（本文中为从小到大排序）

1、冒泡排序

最常用的排序算法了，从第1个数开始，和下一个数进行比较，假如下一个数小，则交换这两个数的位置，第一趟排序得到数组的最大值，第二趟排序得到次最大值，依次列推，若一趟比较中没有交换，则数组已经正序排列。排序结束。
最好的情况：正序排列，时间复杂度O（n）；
最差的情况：逆序排列，时间复杂度O（nn）；
平均时间复杂度：O(nn)；
代码如下：

void bubble(int array[],int length)//every time it gets a biggest number
{
	for (int i = 0; i < length-1; i++)
	{
		bool flag = false;
		for (int j = 0; j < length - i-1; j++)
		{
			if (array[j]>array[j + 1])
			{
				swap(array[j], array[j + 1]);
				flag = true;
			}
		}
		if (!flag) break;//假如某次排序没有交换，则说明已经正序
	}
	return;
}

2、选择排序

第一遍从n个数中选出最小的数，记录他的位置，和第一个数交换；然后再n-1个数中选出最小的数，记录位置，和第二个数交换。以此类推，直到最后一个数。
最好的情况，最坏的情况，平均情况：O（n*n）；

void select(int array[], int length)
{
	for (int i = 0; i < length-1; i++)
	{
		int  min = i;
		int j = i+1;
		while (j < length)
		{
			if (array[j] < array[min])
			{
				min = j;
			}
			j++;
		}
		if (min != i) swap(array[i], array[min]);
	}
	return;
}

3直接插入排序

直接插入排序就是从第二个数开始，往前插入到合适的位置（如果小于某个位置的数，继续向前，直到大于或等于）。
最好的情况：正序排列O（n）；
最坏的情况：逆序排列O（nn）；
平均情况：O（nn）；
代码如下：

void insert(int array[], int length)//every time it gets a smallest number
{
	for (int i = 0; i < length-1; i++)
	{
		int j = i;
		int temp = array[i];
		while (j >= 0&&array[j+1]<array[j])
		{
			swap(array[j], array[j + 1]);
			j--;
		}
	}
}

4、快速排序

快排首先需要在数组中随机选一个数，然后把数组分别排列到这个数的两边，大于它的在右边，小于它的在左边，然后再在它的左右两边数组中分别选一个数，继续上面的操作，直到全部数组有序。
最好的情况：正序排列O（nlogn）；
最坏的情况：逆序排列O（nn）；
平均情况：O（nlogn）；
代码如下：

int oncesort(int array[], int start, int end)//choose the number at end and sort the two groups of numbers
{
	if (start > end||start<0) return -1;
	int small = start - 1;
	for (int index = start; index < end; index++)
	{
		if (array[index] < array[end])
		{
			small++;
			if (small != index)
				swap(array[index], array[small]);
		}
	}
	small++;
	swap(array[small], array[end]);
	return small;
	
}
void quick(int array[], int start,int end)
{
	if (start == end) return;
	int index = oncesort(array,start,end);
	if (index > start) quick(array, start, index-1);
	if (index < end) quick(array, index + 1, end);
	return;
}

5、希尔排序

也是一种选择排序，但是是分区域来进行排序，先选择一个增量，对对应的增量进行排序，然后逐步减小增量，直到最后增量为1时，几乎已经是排好序的序列了。
最好的情况：O（nlogn）；
最坏的情况：O（nlogn）；
平均情况：O（n*logn）；
代码如下：

void herl(int array[], int length)
{
	if (length < 0) return;
	
	for (int add = length / 2; add > 0; add = add / 2)
	{
		for (int i = 0; i + add < length; i++)
		{
			if (array[i]>array[i + add])
				swap(array[i], array[i + add]);
		}
	}
	return;
}

6、归并排序

归并排序和快排类似，不过归并排序是把数组直接分成前后两个部分进行排序，然后前后两个数组再继续分成两个数组，直到有序。每次排好的部分按顺序放进一个新的数组中，最后把这个数组一一赋值出传递给原数组得到有序数组。
最好的情况：O（nlogn）；
最坏的情况：O（nlogn）；
平均情况：O（n*logn）；
代码如下：

void mergetwo(int array[], int start, int mid,int end, int *temp)
{
	int k = start;
	int i = start, j = mid + 1;
	while ( i <= mid&&j <= end)
	{
		if (array[i] <= array[j])
		{
			temp[k++] = array[i++];
		}
		else
			temp[k++] = array[j++];
	}
	while (i <= mid) temp[k++] = array[i++]; 
	while (j <= end) temp[k++] = array[j++];
	for (int i = start; i <= end; i++)
	{
		array[i] = temp[i];
	}
}
void mergecore(int array[], int start, int end, int *temp)
{
	if (start >= end) return;
	int mid = (end + start) / 2;
	
	mergecore(array, start, mid, temp);
	mergecore(array, mid + 1, end, temp); 
	mergetwo(array, start, mid, end, temp); 
	return;
}
void merge(int array[], int length)
{
	if (length<1) return;
	int *temp = new int[length]();
	int start = 0;
	int  end = length - 1;
	mergecore(array, start, end, temp);
	show(array, length);
	delete[]temp;
}

7、堆排序

堆排序首先需要把数组建立成一个最大堆，然后交换堆顶和堆的最后一个数，然后去掉最后一个数，继续调整数组为最大堆，再交换堆顶和堆的最后一个数，直到数组有序。
最好的情况：O（nlogn）；
最坏的情况：O（nlogn）；
平均情况：O（n*logn）；
代码如下：

void maxheap(int array[], int start, int end)
{
	int dad = start;
	int son = 2 * dad + 1;
	while (son <= end)
	{
		if (son + 1 <= end&&array[son] < array[son + 1])
			son++;
		if (array[dad] > array[son])
			return;
		else
			swap(array[son], array[dad]);
		dad = son;
		son = dad * 2 + 1;
	}
}
void heap(int array[], int length)
{
	for (int i = length / 2 - 1; i >= 0; i--)
		maxheap(array, i, length - 1);
	for (int i = length - 1; i > 0; i--)
	{
		swap(array[0], array[i]);
		maxheap(array, 0, i-1);
	}
	return;
}