排序算法

最新推荐文章于 2024-08-23 01:18:04 发布

忽然之间bbc

最新推荐文章于 2024-08-23 01:18:04 发布

阅读量144

点赞数 1

分类专栏：数据结构文章标签：排序数据结构

本文链接：https://blog.csdn.net/qq_42978418/article/details/88241718

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

常见算法分类

十种常见排序算法一般分为以下几种：
（1）非线性时间比较类排序：交换类排序（快速排序和冒泡排序）、插入类排序（简单插入排序和希尔排序）、选择类排序（简单选择排序和堆排序）、归并排序（二路归并排序和多路归并排序）；

（2）线性时间非比较类排序：计数排序、基数排序和桶排序。
在这里插入图片描述

交换排序

冒泡排序：对所有相邻记录的关键字值进行比效，如果是逆顺（a[j]>a[j+1]），则将其交换，最终达到有序化;
算法的时间复杂度为O(n^2) ，是稳定的。

//冒泡排序
void BubbleSort(int* a, int length)
{
	for (int i = 0; i < length; i++)
	{
		for (int j = 0; j < length -  i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp;
				temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

快速排序：将一个数组由div（一般为这个数组的第一个元素）分成两个数组，将小于div的数放在div的左边，将大于div的数放在div的右边。再对两个数组独立排序，是个递归算法。算法的时间复杂度为O(nlogn) ，是不稳定的。
下面对快排的第一次操作写了三种方法。

//交换两个值
void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

//快排的一次操作,1.找小的值与大的值交换
int	OnceSort_1(int* a, int begin, int end)
{
	int key = begin;
	//int key = GetMidIndex(a, begin, end);  //三数取中法
	Swap(&a[key], &a[begin]);
	key = begin;
	while (begin < end)
	{
		//找小的
		while (begin < end && a[end] >= a[key])
		{
			end--;
		}
		//找大的
		while (begin < end && a[begin] <= a[key])
		{
			begin++;
		}
		Swap(&a[end], &a[begin]);
	}
	if (begin == end)
	{
		Swap(&a[end], &a[key]);
	}
	return begin;
}
//2.先保存第一个值，再比较覆盖
int OnceSort_2(int* a, int begin, int end)
{
	int tmp = a[begin];
	while (begin < end)
	{
		//找比key小的数
		while (begin < end && a[end] >= tmp)
		{
			end--;
		}
		a[begin] = a[end];
		//找比key大的数
		while (begin < end && a[begin] <= tmp)
		{
			begin++;
		}
		a[end] = a[begin];
	}
	a[begin] = tmp;
	return begin;
}
//3.快慢指针
int OnceSort_3(int* a, int begin, int end)
{
	int prev = begin;
	int cur = begin + 1;
	int key = begin;
	while(cur <= end)
	{
		if (a[cur] < a[key] && ++prev != cur)
		{
			Swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	//key左边比它小，右边比它大
	Swap(&a[prev], &a[key]);
	return prev;
}
//快排
void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	else
	{
		//[left, div-1]  [div+1, right]
		//int div = OnceSort_1(a, left, right);
		//int div = OnceSort_2(a, left, right);
		int div = OnceSort_3(a, left, right);

		QuickSort(a, left, div - 1);
		QuickSort(a, div + 1, right);
	}
}

用三数取中法对快排的第一次操作的法1进行优化

//三数取中法（选取三个数中次大的  考虑最坏的每次排序过程中，最小或最大为第一个）
int GetMidIndex(int* a, int begin, int end)
{
	int mid = begin + ((end - begin) >> 1);		//用>>防止溢出
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] < a[end])
			return end;
		else
			return begin;
	}
	else
	{
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] > a[end])
			return end;
		else
			return begin;
	}
}

对于快排来说，有很多次的递归，这样会导致效率很低，为了提高效率，写了一种优化的方法。当需要排序的数据规模过大的时候，快排无疑是最优的算法，但是在规模逐渐变小的时候，直接插入排序的效率更快，因此做一个判断就好。

//快排优化（递归次数太多）
void QuickSortOP(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	if (right - left > 10)
	{
		//[left, div-1]  [div+1, right]
		//int div = OnceSort_1(a, left, right);
		//int div = OnceSort_2(a, left, right);
		int div = OnceSort_3(a, left, right);

		QuickSort(a, left, div - 1);
		QuickSort(a, div + 1, right);
	}
	else
		InsertSort(a + left, right - left + 1);
}

插入排序

简单插入排序：从整个待排序列中选出一个元素插入到已经有序的子序列中去，得到一个有序的、元素加一的子序列，直到整个序列的待插入元素为0，则整个序列全部有序。
算法的时间复杂度为O(n^2) ，是稳定的。

//直接插入排序
void InsertSort(int* a, int n)
{
	int i = 0;
	for (i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > tmp)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

希尔排序：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
算法的时间复杂度为O(n^2) ，是不稳定的。

//希尔排序
void ShellSort(int* a, int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		//此i++，是将间距为gap的多组数据进行同时交换
		for (int i = 0; i < n - gap; i++)
		{
			int tmp = a[i + gap];
			int end = i;
			while (end >= 0)
			{
				if (a[end] > tmp)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

选择排序

简单选择排序：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
算法的时间复杂度为O(n^2)。是不稳定的。

//简单选择排序
void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;
	while (begin < end)
	{
		int min = begin;
		int max = end;
		for (int i = begin; i <= end; i++)
		{

			if (a[i] < a[min])
			{
				min = i;
			}
			if (a[i] > a[max])
			{
				max = i;
			}
		}
		Swap(&a[min], &a[begin]);

		if (max == begin)
			max = min;
		Swap(&a[max], &a[end]);
		begin++;
		end--;
	}
}

堆排序：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
算法的时间复杂度为O(nlogn) ，是不稳定的。

//向下调整算法
void AdjustHeap(int* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if ((child + 1) < n && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}

}
//堆排序
void HeapSort(int* a, int n)
{
	int i = 0;
	for (int i = (n / 2) - 1; i >= 0; i--)    // 从最后一个非叶子结点开始, 向前进行调整
	{
		AdjustHeap(a, n, i);
	}
	for (i = n - 1; i >= 0; i--)
	{
		Swap(&a[0], &a[i]);
		AdjustHeap(a, i, 0);
	}
}

归并排序

归并排序：假设数组A有N个元素，那么可以看成数组A是又N个有序的子序列组成，每个子序列的长度为1，然后再两两合并，得到了一个 N/2 个长度为2或1的有序子序列，再两两合并，如此重复，值得得到一个长度为N的有序数据序列为止
算法的时间复杂度为O(nlogn) ，是稳定的。

//子问题
void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
		return;
	//分解
	int mid = begin + ((end - begin) >> 1);

	 _MergeSort(a, begin, mid, tmp);
	 _MergeSort(a, mid+1, end, tmp);


	//[begin, mid] [mid+1, end]
	//归并
	int index = begin;
	int begin1 = begin;  int end1 = mid;
	int begin2 = mid + 1;int end2 = end;

	while (begin1 <= end1 && begin2 <= end2)
	{
		//选两个区间内小的值，先入tmp数组
		if (a[begin1] <= a[begin2])
		{
			tmp[index++] = a[begin1++];
		}
		else
		{
			tmp[index++] = a[begin2++];
		}
	}

	//其中一个数组为空,将另一个数组中的其他值入数组中
	while (begin1 <= end1)
	{
		tmp[index++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[index++] = a[begin2++];
	}

	//拷回原数组
	index = begin;
	while (begin <= end)
	{
		a[begin++] = tmp[index++];
	}
}
//归并排序
void MergeSort(int* a, int n)
{
	int* tmp = (int*) malloc(sizeof(int) * n);
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);  //开辟空间后一定要记得释放空间
}

计数排序

计数排序：在待排序序列中，如果我们能统计出有多少元素小于或等于某一个元素，我们也就知道了该元素的正确位置。
算法的时间复杂度为O(MAX(N,范围)) ，是稳定的。

void CountSort(int* a, int n)
{
	int max = a[0];
	int	min = a[0];
	for (int i = 0; i < n; i++)
	{
		if (a[i] > max)
			max = a[i];
		if(a[i] < min)
			min = a[i];
	}

	int range = max - min + 1; //数值的范围

	int* count = (int*)malloc(sizeof(int)*range);
	memset(count, 0, sizeof(int)*range);	//数组初始化为0

	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;		//计数数组储存的是相对位置
	}

	//放回数组中,i--,j++
	int j = 0;
	for (int i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
}

忽然之间bbc

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序算法

常见算法分类十种常见排序算法一般分为以下几种：（1）非线性时间比较类排序：交换类排序（快速排序和冒泡排序）、插入类排序（简单插入排序和希尔排序）、选择类排序（简单选择排序和堆排序）、归并排序（二路归并排序和多路归并排序）；（2）线性时间非比较类排序：计数排序、基数排序和桶排序。交换排序冒泡排序：对所有相邻记录的关键字值进行比效，如果是逆顺（a[j]&gt;a[j+1]），则将其交换，最...
复制链接

扫一扫

专栏目录