亲宝软件园·资讯

展开

七大排序算法

waywt1 人气:0

插入排序

①直接插入排序

基本思想

每次从一个有序序列开始，将待排元素与有序序列中的元素从后往前逐个比较，

若有序序列中的元素大于待排元素，则将较大的元素往后覆盖；

否则，将待排元素插入其前面，并结束此轮比较。

动图演示

​

代码实现

void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int x = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > x)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
				break;
		}
		a[end + 1] = x;
	}
}

②希尔排序

基本思想

先选定一个整数作为 gap ,将待排序列以 gap 为间隔分成 gap 组，

先对每组进行直接插入排序，

然后再适当缩小 gap ,重复上述步骤。

当 gap = 1 时，此时序列已经进行了多次预排序，接近有序。

这时再对序列进行直接插入排序，就能达到优化的效果。

图示

​

代码实现

void ShellSort(int* a, int n)
{
	//多次预排序(gap > 1) + 直接插入( gap == 1)
	int gap = n;
	while (gap > 1)
	{
		//使gap最后一次一定能到1
		gap = gap / 3 + 1;
		//多组一起排
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int x = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > x)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
					break;
			}
			a[end + gap] = x;
		}
	}
}

选择排序

③直接选择排序

基本思想

每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始(末尾)位置，直到全部待排序的数据元素排完 。

动图演示

以每次选出最小值为例

代码实现

void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
 
void SelectSort(int* a, int n)
{
	int begin = 0;
	while (begin < n - 1)
	{
		int mini = begin;
		for (int i = begin; i < n; i++)
		{
			if (a[i] < a[mini])
				mini = i;
		}
		Swap(&a[begin], &a[mini]);
		++begin;
	}
}

④堆排序

基本思想

小堆根上的元素是堆中最小的元素，大堆根上的元素是堆中最大的元素。

先将待排序列建成小(大)堆，

获取堆根上的元素，这样就达到了选出待排序列中最小(大)元素的目的，

然后再将其放至正确位置。

建堆需要注意的问题

若将待排序列建成小堆，则每次可将待排序列中最小的元素放至正确的位置，但每次排除堆根后，剩下元素组成的堆结构被打乱，需要对剩下待排序列重新建堆，反而增加的问题的复杂性。

故我们将其建成大堆，每次将堆根上的元素(待排序列中最大的元素)与待排序列中最后一个元素进行交换，将大堆根上的元素换至正确位置，然后再使用向下调整算法，将交换上来的元素调整至一个大堆中的合适位置。

图示

代码实现

void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
 
//建大堆的向下调整算法
void AdjustDown(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
			++child;
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}
 
void HeapSort(int* a, int n)
{
    //先使用向下调整算法，从最后一个元素的父亲开始建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}
    //先交换，再调整
	for (int end = n - 1; end > 0; --end)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
	}
}

交换排序

⑤冒泡排序

基本思想

从待排序列的首元素开始，从前往后依次进行比较，

若大于则交换，将其继续与后面元素比较，直到被放至正确位置。

否则迭代至与其比较的元素，重复上面的步骤。

动图演示

代码实现

void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
 
void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		for (int i = 0; i < n - j - 1; i++)
		{
			if (a[i] > a[i + 1])
			{
				Swap(&a[i], &a[i + 1]);
			}
		}
	}
}

⑥快速排序

基本思想

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

基本框架

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
 
    //先将选定的基准值排好
	int keyi = Partion(a, left, right);
 
    //再通过递归排序其左右子序列
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

Partion函数分析

Partion函数在这里的作用是：

将选定的基准值排到正确位置，并将待排序列分成比基准值小的左子序列，比基准值大的右子序列。

将区间按照基准值划分为左右两半部分的常见方式有：

1.hoare版本
基本思想：

选择待排序列的最左值的下标为基准值所指下标，当区间左下标小于区间右下标时，先从右开始找比基准值小的值，找到后再从左开始找比基准值大的值，都找到后，将左右下标对应的值交换，然后从右开始重复上述步骤，直到左右下标相等。当左右下标相等时，将下标所指向的值与基准值互换。

动图演示：

代码实现：
//hoare版本
int Partion(int* a, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		//右边先走，找小
		while (left < right && a[right] >= a[keyi])
		{
			--right;
		}
		//左边走，找大
		while (left < right && a[left] <= a[keyi])
		{
			++left;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	return left;
}
2.挖坑法
基本思想：

选择待排序列的最左值为基准值，将其下标记为坑的下标。当区间左下标小于区间右下标时，先从右开始找比基准值小的值，找到后将其放在当前坑上，并将坑替换到所找位置。再从左开始找比基准值大的值，找到后同样将其放在当前坑上，然后从右开始重复上述步骤，直到左右下标相等。当左右下标相等时，把基准值放到当前坑所在位置。

动图演示：

代码实现：
//挖坑法
int Partion(int* a, int left, int right)
{
    int key = a[left];
	int pivot = left;
	while (left < right)
	{
		//右边先走，找小
		while (left < right && a[right] >= key)
		{
			--right;
		}
		//值覆盖，坑替换
		a[pivot] = a[right];
		pivot = right;
		//左边走，找大
		while (left < right && a[left] <= key)
		{
			++left;
		}
		//值覆盖，坑替换
		a[pivot] = a[left];
		pivot = left;
	}
	a[pivot] = key;
	return pivot;
}
3.前后指针法
基本思想：

选择最左值的下标为基准值下标，并设定指向前后位置的两个下标 cur , prev 。使 prev 指向基准值的位置，cur 指向基准值的前一个位置。当 cur <= right,也就是 cur 指向的位置小于等于右区间的位置时，从 cur 开始找比基准值小的值，并将其与 prev 所在位置的前一个交换。当 cur 跳出右区间时，将基准值与 prev 所指向的值交换。

动图演示：

代码实现： 
//前后指针法 ——更推荐
int Partion(int* a, int left, int right)
{
	int keyi = left;
	int cur = left + 1;
	int prev = left;
	while (cur <= right)
	{
		//cur找小，把小的换到左边
		if (a[cur] < a[keyi])
		{
            ++prev;
			Swap(&a[cur], &a[prev]);
		}
		++cur;
	}
	Swap(&a[prev], &a[keyi]);
	return prev;
}

小结：

hoare版本与挖坑法都需要注意，不管是从右开始找还是从左开始找，始终都要注意左下标要小于右下标，若没有此限定条件，当从任一方向开始找值时，一旦没有找到我们所预想的值，就会导致越界情况产生。

而前后指针法是从一个方向开始，遍历搜索一次待排序列，只需设定一次限定条件。

故这里更推荐使用前后指针法来实现快速排序。

Partion函数的优化

由于每次是以基准值为准，将待排序列分成左右两个子序列，若每次能保证选到的基准值的正确位置在待排序列的中间部分，则每次分序列时，都能大致将待排序列分成均衡的两部分，从而将排序次数减少。

这里使用到三数取中的方法：

再排序前，先将最左值、中间值与最右值进行比较，选出三个数中的中间值，并将其与最左值交换，这样每次以最左值为基准值时，都能选到一个大致在中间部分的数。

代码：
//三数取中
int GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] > a[mid])
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] < a[right])
			return left;
		else
			return right;
	}
	else
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] > a[right])
			return left;
		else
			return right;
	}
}

快速排序代码实现

//三数取中
int GetMidIndex(int* a, int left, int right)
{
	//int mid = (left + right) / 2;
	int mid = left + ((right - left) >> 1);
	if (a[left] > a[mid])
	{
		if (a[mid] > a[right])
			return mid;
		else if (a[left] < a[right])
			return left;
		else
			return right;
	}
	else
	{
		if (a[mid] < a[right])
			return mid;
		else if (a[left] > a[right])
			return left;
		else
			return right;
	}
}
 
void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
 
//前后指针法
int Partion(int* a, int left, int right)
{
	int midi = GetMidIndex(a, left, right);
	Swap(&a[midi], &a[left]);
 
	int keyi = left;
	int cur = left + 1;
	int prev = left;
	while (cur <= right)
	{
		//cur找小，把小的换到左边
		if (a[cur] < a[keyi] && ++prev != cur)
		{
			Swap(&a[cur], &a[prev]);
		}
		++cur;
	}
	Swap(&a[prev], &a[keyi]);
	return prev;
}
 
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
 
	int keyi = Partion3(a, left, right);
 
	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

归并排序

⑦归并排序

基本思想

归并排序是将待排序列先分解至单个子序列，再将已有序的子序列合并一个临时数组中，得到完全有序的序列后再拷贝回原数组。即先使左右子序列有序，再将其归并为一个完整的有序序列。

动图演示

代码实现

void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left >= right)
		return;
	int mid = left + ((right - left) >> 1);
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);
 
	//归并
	int begin1 = left, end1 = mid;
	int begin2 = mid + 1, end2 = right;
	int i = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] <= a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
 
	//把排序后的元素拷贝回原来的数组
	for (int j = left; j <= right; ++j)
	{
		a[j] = tmp[j];
	}
}
 
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
 
	_MergeSort(a, 0, n - 1, tmp);
 
	free(tmp);
	tmp = NULL;
}

排序算法复杂度及稳定性分析

以上所述是小编给大家介绍的七大经典排序算法图解，希望对大家有所帮助。在此也非常感谢大家对网站的支持！

加载全部内容
相关教程
猜你喜欢
用户评论