算法

最新推荐文章于 2024-09-01 16:42:17 发布
最新推荐文章于 2024-09-01 16:42:17 发布
阅读量191 收藏 1
点赞数 2
分类专栏： 算法 文章标签： 排序算法 快速排序 c++ 排序 插入排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45209954/article/details/115115869
版权

内部排序算法

  1. 排序（Sorting）：将杂乱无章的数据元素（或记录），通过一定的方法按关键字顺序排列的过程叫做排序。

  2. 稳定排序算法：一般情况下，称某个排序算法是稳定的，指的是当待排序序列中有相同的元素时，它们的相对位置在排序前后不会发生改变。要证明一个算法不是稳定的，只需要举例排序后有相等的元素位置关系发生变化即可。

  3. 排序分类：
    排序记录数量不同，存储在不同的存储器（内存和外存）中，由此可以将排序算法分为内部排序和外部排序。这里主要介绍内部排序。
    非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破 O ( n l o g 2 n ) O(nlog_2^n) O(nlog2n​)，因此称为非线性时间比较类排序。
    线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。
    在这里插入图片描述

  4. 希尔增量序列：目前为止尚未有人求得最好的增量序列，但是需要注意：增量元素不互质，小增量可能根本不起作用，并且最有一个增量值必须是1。

  5. 多关键字排序：1）最高位优先法（MSD法 Most Significant Digit first）；2）最低位优先法（LSD法 Least Significant Digit first)。

  6. 各个算法复杂度及稳定性比较
    在这里插入图片描述

冒泡排序（Bubble Sort）

  • 基本思想：假设从小到大排序，重复扫描待排序序列，并比较每一对相邻元素，当这对元素顺序不当进行交换，一直重复直到全部有序。即两个数比较大小，较大的数下沉，较小的数冒起来。

  • 动图

    冒泡排序动图

  • 算法实现：

    template<class T=int>
T *bubble_sort(T *arr, int len)
{
	// 每遍历一趟，将一个最大的数移动到序列末尾。
	T temp;
	for (int i = 0; i < len - 1; i++) {	// 最多循环len - 1次
		for (int j = 1; j < len - i; j++) {	// 每次比较前len-i个
			if (arr[j] < arr[j - 1])
			{	// 前边元素大，交换元素
				temp = arr[j];
				arr[j] = arr[j - 1];
				arr[j - 1] = temp;
			}
		}
	}
	return arr;
}

int main()
{	// 学生结构体
	typedef struct Stu{
		int age;
		char name[16];

		void operator=(Stu& s) {
			age = s.age;
			strcpy_s(name, s.name);
		}
		bool operator<(Stu& c) {
			return age < c.age;
		}
		bool operator>(Stu& c) {
			return age > c.age;
		}
	}STU_T;

	STU_T array[5] = { {7, "1"}, {0, "2"}, {4, "3"}, {6, "4"}, {0, "5"}};
	STU_T* res = bubble_sort(array, 5);	// 冒泡排序
	for (int i=0; i < 5; i++) {
		printf("%d %s\t", res[i].age, res[i].name);
	}
	printf("\n");
	return 0;
}

  • 算法复杂度

    时间复杂度:O(N^2)
    空间复杂度: O(1)
    稳定性：稳定

  • 算法改进

  1. 设置标志遍历pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。
    template<class T = int>
T* bubble_sort1(T arr[], int len) {
	int i = len - 1;  //初始为最后一个数据元素的位置
	while (i > 0) {
		int pos = 0; //每趟开始时,无记录交换,当遍历结束没有交货则结束排序
		for (int j = 0; j < i; j++)
			if (arr[j] > arr[j + 1]) {
				pos = j; //记录交换的位置 
				T tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp;
			}
		i = pos; //为下一趟排序作准备
	}
	return arr;
}
  2. 传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。
    template<class T = int>
T* bubble_sort2(T arr[], int len) {
	int low = 0, j = 0;
	int high = len - 1;
	T tmp;
	while (low < high) {
		for (j = low; j < high; ++j) //正向冒泡,找到最大者,并下沉
			if (arr[j] > arr[j + 1]) {
				tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp;
			}
		--high;					//修改high值, 前移一位
		for (j = high; j > low; --j) //反向冒泡,找到最小者，并上浮
			if (arr[j] < arr[j - 1]) {
				tmp = arr[j]; arr[j] = arr[j - 1]; arr[j - 1] = tmp;
			}
		++low;					//修改low值,后移一位
	}
	return arr;
}

直接插入排序（Straight Insertion Sort）

  • 基本思想：将数据分为有序部分和无序部分，每一步将一个无序的数据插入到前面已经排好的有序序列中，直到插完所有元素为止。

  • 动图
    插入排序动图

  • 算法实现

    template<class T=int>
T* insertion_sort(T* arr, int len) {
	// 插入排序(假设从小到大排序) 
	// 第一个元素已经排好序，从第二个开始一直到末尾	
	for (int i = 1; i < len; i++) {
		T cur = arr[i];	// 哨兵位 记录正在插入的元素
		int j = i;
		for (; j > 0; j--) {
			if (arr[j - 1] > cur) {	// 插入  插入后的元素统一向后移动
				arr[j] = arr[j - 1];	// 如果大 向后移动
			}
			else {	// 如果小于等于  插入
				break;
			}
		}
		arr[j] = cur;
	}
	return arr;
}

int main()
{
	int array[10] = { 9, 18, 32, 65, 43, 89, 99, 88, 54, 90 };
	int* res = insertion_sort(array, 10);	// 插入排序
	for (int i=0; i < 10; i++) {
		printf("%d\t", res[i]);
	}
	printf("\n");
	return 0;
}

  • 算法复杂度
    正序时关键字间需要比较次数最小，为n-1，即 ∑ i = 2 n 1 \sum_{i=2}^{n}{1} i=2∑n​1记录不需要移动；反之当逆序时，比较次数达到最大值（n+2)(n-1)/2，即 ∑ i = 2 n i \sum_{i=2}^{n}{i} i=2∑n​i记录需要移动最大值(n+4)(n-1)/2，即 ∑ i = 2 n i + 1 \sum_{i=2}^{n}{i+1} i=2∑n​i+1

    时间复杂度：O(N^2)
    空间复杂度：O(1)
    稳定性：稳定

简单选择排序(Simple Select Sort)

一种非常简单易懂的排序方法，也称为选择排序或者直接选择排序。

  • 基本思想：每趟从未排序序列中找出最小（最大）元素，插入到已排序序列末尾，直到全部变为有序序列为止。

  • 动图
    简单排序动图

  • 算法实现

    template<class T = int>
T* simple_select_sort(T arr[], int len) {
	// 第i趟从n-i+1个记录中选出最小值和第i个记录交换，比较次数 n-i (假设升序排列)
	for (int i = 0; i < len; i++) {
		int min = i;	// 记录最小值下标  初始为当前位置最小
		for (int j = min + 1; j < len; j++) {
			if (arr[min] > arr[j]) {
				min = j;
			}
		}
		if (min != i) {// 基于交换的选择排序  交换
			T temp = arr[i]; arr[i] = arr[min]; arr[min] = temp;
		}
	}
	return arr;
}

int main()
{
	int array[15] = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
	int* res = simple_select_sort(array, 15);
	for (int i = 0; i < 15; i++) {
		printf("%d\t", res[i]);
	}
	printf("\n");
	return 0;
}

  • 算法复杂度

    时间复杂度：O(N^2)
    空间复杂度：O(1)
    稳定性：不确定。 基于交换的选择排序是不稳定的；基于插入的选择排序是稳定的。如果没有说明默认是基于交换的选择排序即不稳定。

希尔排序（Shell’s Sort）

希尔排序又称“缩小增量排序”（Diminishing Increment Sort），直接插入排序在序列基本有序 时或序列长度n很小时效率比较高，希尔排序正是基于这两点对直接插入排序的改进得到的排序方法。
子序列构成不是简单地逐段分割，而是将相隔一定增量的记录组成一个子序列。例如：增量取5时，序列{49 38 65 97 76 13 27 49 55 04}组成子序列为{49 13}、{38 27}、{65 49}、{97 55}、{76 04}

  • 基本思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

  • 动图 希尔排序动图

  • 算法实现

    template<class T=int>
T* shell_sort(T arr[], int len, int dlta[], int t) {
	// dlta 增量序列  t 增量序列长度
	for (int k = 0; k < t; k++) {
		int dk = dlta[k];	// 遍历增量序列
		for (int i = dk; i < len; i++) {
			T cur = arr[i];	// 哨兵位 记录正在插入的元素
			int j = i;
			for (; j >= dk; j-= dk) {
				if (arr[j - dk] > cur) {	// 插入  插入后的元素统一向后移动
					arr[j] = arr[j - dk];	// 如果大 向后移动
				}
				else {	// 如果小于等于  插入
					break;
				}
			}
			arr[j] = cur;
		}
		// 打印每个增量排序后的结果
		printf("第%d趟：", k+1);
		for (int c = 0; c < len; c++) {
			printf("%d\t", arr[c]);
		}
		printf("\n");
	}
	return arr;
}

int main()
{
	int array[10] = {49, 38, 65, 97, 76, 13, 27, 49, 55, 04};
	int dlta[] = { 5, 3, 2, 1 };	// 增量序列  最好增量序列中没有除1之外的公因子
	int* res = shell_sort(array, 10, dlta, 4);
	printf("排序结果：");	// 打印排序结果
	for (int i = 0; i < 10; i++) {
		printf("%d\t", res[i]);
	}
	printf("\n");
	return 0;
}

  • 算法复杂度
    由于它的时间是所取增量序列的函数，它的分析很复杂。它的效率要比直接插入排序好很多。不稳定。

快速排序（Quick Sort）

快速排序是对冒泡排序的一种改进。

  • 基本思想：通过一趟排序将待排记录按一个基准分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

  • 动图
    快速排序动图

  • 算法实现

    template<class T>
int Partition(T arr[], int low, int high) {
	T poivtkey = arr[low];	// 以子序列低位元素为基准
	// 这么写好处是不用交换   这里保存了基准（地位），开始把其他小的元素填充到这里，
	// 然后交换把大元素填充到刚才小的元素，如此交替，最后在结束的地方填充基准
	// 也可以以高位为基准，相应的要先用大的元素填充高位。（即先在low段找大值）
	while (low < high) {
		while (low < high && poivtkey <= arr[high]) {
			--high;
		}
		arr[low] = arr[high];
		while (low < high && poivtkey >= arr[low]) {
			++low;
		}
		arr[high] = arr[low];
	}
	arr[low] = poivtkey;
	return high;	// 返回基准的位置 这里low==high
}
template<class T>
void QSort(T arr[], int low, int high) {
	if (low < high) {// 当low==high就是递归的出口
		int pivotloc = Partition(arr, low, high);	// 划分并找到基准位置下标
		QSort(arr, low, pivotloc - 1);	// 递归排序比基准值左边部分
		QSort(arr, pivotloc + 1, high);	// 递归排序比基准右边部分
	}
}
template<class T>
T* quick_sort(T arr[], int len) {
	// 快速排序  默认升序
	QSort(arr, 0, len - 1);
	return arr;
}

int main()
{
	int array[10] = {84, 83, 88, 87, 61, 50, 70, 60, 80, 99};
	int* res = quick_sort(array, 10);
	printf("排序结果：");	// 打印排序结果
	for (int i = 0; i < 10; i++) {
		printf("%d\t", res[i]);
	}
	printf("\n");
	return 0;
}

  • 算法复杂度

    时间复杂度： O ( n l o g 2 n ) O(nlog_2^n) O(nlog2n​)
    空间复杂度： O ( n l o g 2 n ) O(nlog_2^n) O(nlog2n​)
    稳定性：不稳定

归并排序

  • 基本思想：归并就是将两个（或者两个以上）有序序列合并为一个新的有序表；即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。（分治）
    2-路归并排序：假设初始序列含有n个记录，则可看做n个有序序列，两两归并，得到⌈n/2⌉个长度为2或1的有序子序列，以此类推，最终得到一个长度为n的有序序列。

  • 动图
    归并排序动图

  • 算法实现

    template<class T>
void Merge(T arr[], int l,int m, int r) {
	// 合并  将T[l...m] 和T[m+1, r]两个数组归并为T[l..r]
	T *p_arr = (T*)malloc(sizeof(T)*(r + 1 - l));	// 这里使用了辅助空间
	int k = 0, i = l, j = m + 1;
	for (; i <= m && j <= r; k++) {	// 找完一个子序列为止 
		if (arr[i] <= arr[j]) {
			p_arr[k] = arr[i++];
		}
		else {
			p_arr[k] = arr[j++];
		}
	}
	while (i <= m)	// 插入没有进入辅助空间的剩余元素
	{
		p_arr[k++] = arr[i++];
	}
	while (j <= r)
	{
		p_arr[k++] = arr[j++];
	}
	i = l, k = 0;
	printf("\nmerge%d-%d-%d", l, m, r);
	while (i<=r)
	{
		arr[i++] = p_arr[k++];
		printf("\t%d", arr[i-1]);	// 打印刚才排序的序列
	}
	free(p_arr);	// 释放堆内存空间
}
template<class T>
void MSort(T arr[], int low, int high) {
	// 划分  这里为了方便看递归调用顺序打印了提示信息， 可以自行注释
	if (low < high) {	// 如果low==high表示一个元素，直接返回停止递归
		int m = (low + high) / 2;
		printf("\n划分 b %d %d", low, m);
		MSort(arr, low, m);	
		printf("\n划分 m %d %d", m+1, high);
		MSort(arr, m + 1, high);
		printf("\n合并%d %d %d", low, m, high);
		Merge(arr, low, m, high);
	}
}
template<class T>
T* merge_sort(T arr[], int len) {
	// 归并排序  递归写法 可以转为迭代方法后续加进来
	MSort(arr, 0, len - 1);
	return arr;
}

int main()
{
	int array[10] = {84, 83, 88, 87, 61, 50, 70, 60, 80, 99}; 
	printf("原始数据：");
	for (int i = 0; i < 10; i++) {
		printf("%d\t", array[i]);
	}
	int* res = merge_sort(array, 10);
	printf("\n排序结果：");	// 打印排序结果
	for (int i = 0; i < 10; i++) {
		printf("%d\t", res[i]);
	}
	printf("\n");
	return 0;
}

  • 算法复杂度

    时间复杂度： O ( n l o g 2 n ) O(nlog_2^n) O(nlog2n​)
    空间复杂度： O ( n ) O(n) O(n)
    稳定性：稳定

堆排序（Heap Sort）

堆排序是一种树形选择排序，是对直接选择排序的有效改进。

  • 基本思想：将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆; 将堆顶元素与末尾元素交换，将最大(小)元素"沉"到数组末端; 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

  • 动图
    堆排序动图

  • 算法实现

template<class T>
void adjust_heap(T* arr, int cur, int len) {
	T temp = arr[cur];
	for (int i = 2 * cur + 1; i < len; i = 2 * i + 1) {
		if (i + 1 < len && arr[i + 1] > arr[i]) {// 存在右子结点 且右子结点大
			i = i + 1;	// 指向右子结点
		}
		if (arr[i] > temp) {
			arr[cur] = arr[i];
			cur = i;
		}
		else {
			break;
		}
	}
	arr[cur] = temp;
}
template<class T>
T* heap_sort(T arr[], int len) {
	// 堆排序
	// 将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
	// 将堆顶元素与末尾元素交换，将最大(小)元素"沉"到数组末端;
	// 重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。	
	// 构建大顶堆  这里是升序排列
	for (int i = len / 2 - 1; i >= 0; --i) {
		adjust_heap(arr, i, len);
	}
	// 交换，重新调整结构
	T temp = 0;
	for (int j = len - 1; j > 0; --j) {
		temp = arr[0]; arr[0] = arr[j]; arr[j] = temp;
		adjust_heap(arr, 0, j);
	}
	return arr;
}

int main()
{	
	int array[10] = {84, 83, 8, 187, 661, 50, 70, 60, 8, 999};
	printf("原始数据：");
	for (int i = 0; i < 10; i++) {
		printf("%d\t", array[i]);
	}
	int* res = heap_sort(array, 10);
	printf("\n排序结果：");	// 打印排序结果
	for (int i = 0; i < 10; i++) {
		printf("%d\t", res[i]);
	}
	printf("\n");
	return 0;
}
  • 算法复杂度

    时间复杂度： O ( n l o g 2 n ) O(nlog_2^n) O(nlog2n​)
    空间复杂度： O ( 1 ) O(1) O(1)
    稳定性：不稳定

基数排序（Radix Sorting）

基数排序和其他排序方法不同 ，一般排序方法主要通过关键字间比较和移动记录这两种操作排序，而基数排序不需要进行记录关键字间的比较。

  • 基本思想：将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

  • 动图
    基数排序动图
    基数排序图

  • 算法实现

    int* radix_sort(int arr[], int len) {
	// 基数排序
	// 是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位
	int max = -1;	// 这里排序的数字都是非负数， 所以初始为-1
	for (int i = 0; i < len; ++i) {
		if (max < arr[i]) {
			max = arr[i];
		}
	}
	int order = 1;	// 从10^0开始，一直到最大位
	int index = 0;	//
	std::list<int> bukct[10] = {};

	while (order <= max) {
		// 低位排序  即放入0-9不同的桶
		for (int i = 0; i < len; ++i) {
			index = arr[i] / order % 10;	// 这样计算位数小的自然填0
			bukct[index].push_back(arr[i]);
		}
		// 收集  即从桶里依次取出到数组
		for (int i = 0, j = 0; i < 10; ++i) {
			while (!bukct[i].empty()) {
				arr[j++] = bukct[i].front();
				bukct[i].pop_front();
			}
		}

		order *= 10;
	}
	return arr;
}

int main()
{	
	int array[10] = {84, 83, 8, 187, 661, 50, 70, 60, 8, 999}; 
	printf("原始数据：");
	for (int i = 0; i < 10; i++) {
		printf("%d\t", array[i]);
	}
	int* res = radix_sort(array, 10);
	printf("\n排序结果：");	// 打印排序结果
	for (int i = 0; i < 10; i++) {
		printf("%d\t", res[i]);
	}
	printf("\n");
	return 0;
}

  • 算法复杂度

    时间复杂度：O(nk)
    空间复杂度：O(n    k)
    稳定性：稳定

参考：

  1. 值得收藏的十大经典排序算法.
  2. 八大排序算法.
  3. 【数据结构、算法】八大排序算法概述（算法复杂度、稳定性）.

说明：图片来自网络和以上博客，如有侵权请联系删除

当下，
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法——Prim算法
百锦再的博客
12-13 1万+
Prim算法是一种用于求解图的最小生成树的算法。该算法得名于美国计算机科学家罗伯特·普林姆（Robert C. Prim）。Prim算法的基本思想是从一个起始节点开始，并选择与当前生成树相连的边中权值最小的边，然后将该边加入到生成树中，再选择下一条权值最小的边，直到生成树覆盖了所有节点为止。祝您好运！
《算法设计与分析》期末不挂科
风口IT猪的成长录
06-18 8万+
考前知识点整理算法分析基础算法的定义算法正确性算法的性质程序的定义程序与算法的区别算法设计和分析的步骤复杂度分析算法的时间复杂性算法渐近复杂性渐近分析的记号渐近上界记号渐近下界记号非紧上界记号非紧下界记号紧渐近界记号意义算法分析中常见的复杂性函数 我们学校开设的这门课，过于理论，实践太少，考试不会太难，一起学习，一起不挂科！ 但是算法平时一定要练哦！加油！ 算法分析基础 算法的定义 算法是指解决问题的一种方法或一个过程。 算法是若干指令的有穷序列。 算法正确性 对每一个输入实例算法都能终止，并给出
匈牙利算法详解
热门推荐
lemonxiaoxiao的博客
09-19 8万+
参考： https://zhuanlan.zhihu.com/p/96229700 一、匈牙利算法概述 匈牙利算法（Hungarian algorithm），即图论中寻找最大匹配的算法，暂不考虑加权的最大匹配（用KM算法实现）。 匈牙利算法（Hungarian algorithm），主要用于解决一些与二分图匹配有关的问题。 概念点1——匹配。图G的一个匹配是由一组没有公共端点的不是圈的边构成的集合。 这里，我们用一个图来表示下匹配的概念： 如图所示，其中的三条边即该图的一个匹配。所以，匹配的.
代码 多种群遗传算法的函数优化算法代码
06-04
代码 多种群遗传算法的函数优化算法代码代码 多种群遗传算法的函数优化算法代码代码 多种群遗传算法的函数优化算法代码代码 多种群遗传算法的函数优化算法代码代码 多种群遗传算法的函数优化算法代码代码 多种群遗传...
代码 基于遗传算法的Bp神经网络优化算法代码
06-04
代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化算法代码代码 基于遗传算法的Bp神经网络优化...
粒子群算法、遗传算法以及两者的结合的优化算法
10-25
粒子群算法（Particle Swarm Optimization, PSO）与遗传算法（Genetic Algorithm, GA）是两种在优化问题中广泛应用的全局搜索方法。它们都是基于自然选择和群体智能的启发式算法，能够有效地解决复杂多模态优化问题...
JAVA近百种算法大全
05-29
Java算法大全是一个包含约100种常见算法的资源库，专为Java程序员设计，用于深入理解和实践编程中的各种算法。这些算法涵盖了数据结构、排序、搜索、图论等多个领域，是提升编程技能和解决问题能力的重要工具。下面...
新型群智能优化算法（matlab实现）——烟花算法、粒子群算法、蚁群算法
09-24
在本压缩包中，包含了四种不同的群智能优化算法的MATLAB实现：烟花算法、粒子群算法、蚁群算法以及免疫算法。 1. **烟花算法**（Fireworks Algorithm, FWA）： 火花算法是2010年由华中科技大学的学者提出的一种...
Java算法之选择排序（Selection Sort）
weixin_38959316的博客
08-29 509
选择排序是一种简单直观的排序算法，它的工作原理是每次从待排序的数据元素中选出最小（或最大）的一个元素，然后放到序列的起始位置。通过重复这个过程，直到所有元素都被排序。
Java算法之希尔排序（Shell Sort）
weixin_38959316的博客
08-29 458
希尔排序，又称为缩小增量排序，是插入排序的一种改进算法。它通过引入增量序列，将原始数据序列分成多个子序列，对每个子序列进行插入排序，然后逐渐减小增量，直到增量为1，完成整个排序过程。
Java算法之归并排序（Merge Sort）
weixin_38959316的博客
08-29 528
归并排序是一种采用分治法的排序算法，它将排序问题分解为多个较小的子问题来解决，然后将这些子问题的解合并以得到原问题的解。归并排序以其稳定性和高效率而著称，尤其适用于大数据集的排序。归并排序是一种非常强大的排序算法，它通过分治法有效地解决了大规模数据集的排序问题。虽然它需要额外的内存空间，但其稳定性和高效率使其成为许多应用场景下的首选算法。
介绍几种常用的排序算法
m0_48022770的博客
08-26 655
通过重复地遍历要排序的序列，每次比较相邻的元素并交换它们的位置，使得每次遍历都将当前未排序部分中的最大（或最小）元素移动到末尾。：通过选择一个“基准”（pivot），将数据分为两部分，一部分比基准小，另一部分比基准大，然后对这两部分递归进行快速排序。：利用堆这种数据结构，将序列构造成一个大顶堆或小顶堆，然后反复将堆顶元素移到序列末尾，并重新调整堆结构。：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。：适用于数据范围较小的整数排序，效率高，但需要较大的额外空间。
Java算法之堆排序（Heap Sort）
weixin_38959316的博客
08-29 478
堆排序是一种基于比较的排序算法，它使用二叉堆数据结构来实现。二叉堆是一种特殊的完全二叉树，其中每个父节点的键值都大于（或等于）其子节点的键值（大顶堆），或者小于（或等于）其子节点的键值（小顶堆）。堆排序通过维护堆的性质来高效地组织数据，从而实现排序。堆排序是一种高效的排序算法，尤其适合处理大数据集和实现优先队列。虽然它不是稳定的排序算法，但其原地排序的特性和对并行化的支持使其在许多应用场景下非常有价值。
Java算法之计数排序（Counting Sort）
weixin_38959316的博客
08-29 956
计数排序是一种线性时间复杂度的排序算法，它不依赖于元素之间的比较，而是通过统计数组中每个元素出现的次数，然后根据这些统计信息对元素进行排序。这种算法特别适用于整数且整数的范围不是非常大时。
数据结构与算法---排序算法
beingstrong的博客
08-31 1609
选择排序、冒泡排序、插入排序、希尔排序、归并排序、快速排序、桶排序、计数排序、基数排序、堆排序思路
Java算法之快速排序（Quick Sort）
weixin_38959316的博客
08-29 480
快速排序是一种分而治之的排序算法，由C. A. R. Hoare在1960年提出。它通过选取一个元素作为"基准"（pivot），然后重新排列数组，使得所有比基准值小的元素都在基准的左边，所有比基准值大的元素都在基准的右边。这个过程称为分区（partitioning）。之后，递归地对基准左边和右边的子数组进行同样的操作。
【C++】深入理解C++模板：从基础到进阶
最新发布
2403_86785171的博客
09-01 523
模板是C++中用于泛型编程的工具。它允许你编写可以处理任意类型的函数和类，而不必重复编写相似的代码。函数模板和类模板。
Python算法进阶指南
3. **图论算法**：涉及图的遍历（如DFS和BFS）、最短路径算法（如Dijkstra算法和Floyd-Warshall算法）以及最小生成树算法（如Prim算法和Kruskal算法）。这些概念在网络分析、社交网络、交通路线优化等领域有广泛应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值