【数据结构】冒泡排序、快速排序（递归，非递归）、归并排序（递归，非递归），七大排序比较，

news2024/9/25 7:24:52

文章目录

  • 冒泡排序
  • 快速排序
  • 归并排序
  • 七大排序之间的对比

冒泡排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
在代码中添加了exchange是为了提高一下数据在有序情况以下的效率。
请添加图片描述

void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		int exchange = 0;
		for (int j = 1; j < n - i; j++)
		{
			if (a[j - 1] > a[j])
			{
				swap(&a[j - 1], &a[j]);
				exchange = 1;
			}
		}
		if (exchange == 0)
		{
			break;
		}
	}
}

冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
这里一共有几个不同的写法：hoare版本、 挖坑法、前后指针版本
hoare版本
请添加图片描述

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)//递归结束
	{
		return;
	}
	int left = begin;
	int right = end;
	int keyi = begin;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}

		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		swap(&a[right], &a[left]);
	}
	swap(&a[left],&a[keyi]);
	keyi = left;
	QuickSort(a,begin,keyi-1);
	QuickSort(a, keyi+1,end);
}

上面的代码，可以计算出在理想状态下时间复杂度是O(N*logN)，和希尔、堆排是同一量级的，但是在不是理想状态下（数据处于有序，或者key处于在数据最大或者最小时）时间复杂度是O(N^2)，在不理想状态下也就相当于冒泡排序。而且快排使用到了递归，使用了递归我们就必须要注意对栈帧的使用，防止栈溢出。
以上的问题使用两种方法来解决：三数取中、小区间优化。
三数取中：很好的解决了key处于最大值或者最小值的问题，也就避免了时间复杂度出现O(N^2)的情况。
小区间优化：因为在之前我们也学习过树的结构，最低层的数据就占全部数据的一半，所以我们在大区间使用递归，小区间直接使用插入排序，为了减少递归使用的次数，从而造成栈溢出的问题。

int GetMidIndex(int* a, int begin, int end)
{
    //三数取中
	int mid = (begin + end) / 2;
	if (a[end] > a[mid])
	{
		if (a[mid] > a[begin])
		{
			return mid;
		}
		else if(a[begin]>a[end])
		{
			return end;
		}
		else
		{
			return begin;
		}
	}
	else
	{
		if (a[begin] > a[mid])
		{
			return mid;
		}
		else if(a[end]>a[begin])
		{
			return end;
		}
		else
		{
			return begin;
		}
	}
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)//递归结束
	{
		return;
	}
	//小区间优化
	if ((end - begin + 1) < 15)
	{
		// 小区间用直接插入替代，减少递归调用次数
		InsertSort(a+begin, end - begin + 1);
	}
	else
	{
		//三数取中，对快排进行优化
		int mid = GetMidIndex(a, begin, end);
		swap(&a[begin], &a[mid]);
		int left = begin;
		int right = end;
		int keyi = left;
		while (left < right)
		{
			while (left < right && a[right] >= a[keyi])
			{
				right--;
			}
			while (left < right && a[left] <= a[keyi])
			{
				left++;
			}
			swap(&a[right], &a[left]);
		}
		swap(&a[left], &a[keyi]);
		keyi = left;
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

挖坑法

挖坑法的思路是：同样的用三数取中求出keyi，也就是左边的第一个数据，再用一个变量将第一个设为坑，从右开始找出小于keyi的值，将该数放到坑中，再将此位置从新设为坑，然后再从左边开始遍历，找出大于keyi的值，以此类推，最后相遇在坑上，将keyi放在坑中，在依次遍历。
请添加图片描述

//挖坑法
int PartSort2(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);
	swap(&a[begin], &a[mid]);
	int left = begin;
	int right = end;
	int keyi = a[left];
	int hole = left;
	while (left < right)
	{
		while (left < right && a[right] >= keyi)
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;

		while (left < right && a[left] <= keyi)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = keyi;
	return hole;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)//递归结束
	{
		return;
	}
	//小区间优化
	if ((end - begin + 1) < 15)
	{
		// 小区间用直接插入替代，减少递归调用次数
		InsertSort(a+begin, end - begin + 1);
	}
	else
	{
		int keyi = PartSort2(a,begin,end);
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

前后指针法

前后指针法思路是：从最左边设置两个前后指针，cur在prev的前一个，cur先移动碰到比keyi小的数就将++prev进行交换，直至cur到达尾部。再将keyi和prev位置的值进行交换再将prev位置设置为新的keyi
请添加图片描述

//前后双指针法
int PartSort3(int* a, int begin, int end)
{
	int mid = GetMidIndex(a, begin, end);
	swap(&a[begin], &a[mid]);
	int keyi = begin;
	int prev = begin;
	int cur = begin + 1;
	while (cur <= end)
	{
		if( ++prev!=cur&& a[cur]<a[keyi])
		{
			swap(&a[prev], &a[cur]);
		}
		
		cur++;
	}
	swap(&a[prev], &a[keyi]);
	keyi = prev;
	return keyi;
}


void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)//递归结束
	{
		return;
	}
	//小区间优化
	if ((end - begin + 1) < 15)
	{
		// 小区间用直接插入替代，减少递归调用次数
		InsertSort(a+begin, end - begin + 1);
	}
	else
	{
		int keyi = PartSort3(a,begin,end);
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

非递归写法

上面已经介绍完递归的写法，因为一提到递归的问题首先就应该想到的栈溢出的问题，所以就介绍了非递归的写法。
非递归思路：这里我们借用到了栈（当然不是只能使用栈，队列也是可以的，只是用栈更加符合递归的流程）将数据两头的数据进行入栈，还是接入上面的三种方法（hoare，挖坑法，前后指针）然后取到keyi分割为两部分继续进行入栈。

//快排非递归
void QuickSortNonR(int* a, int begin, int end)
{
	ST st;
	StackInit(&st);
	StackPush(&st,begin);
	StackPush(&st,end);
	while (!StackEmpty(&st))
	{
		int right=StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);
		int keyi = PartSort3(a, left,right);
		if (keyi + 1<right)
		{
			StackPush(&st, keyi+1);
			StackPush(&st, right);
		}
		if (keyi - 1 > begin)
		{
			StackPush(&st, begin);
			StackPush(&st, keyi-1);
		}
	}
	StackDestroy(&st);
}

解决数据当中有大量重复数据，或者全是相同数据效率的问题

OJ链接

我们上面提供的代码已经可以解决大部分的问题了，但是有时在写OJ的情况下会发现再碰到一些特殊用例并不能高效的解决，也就不能通过测试用例。上面的代码时间复杂度是O(N*logN)但是在特殊情况下时间复杂度是O(N^2)，所以提出了解决的方法，在我们上面应用的方法可以把他们称为两路划分，而我们要解决的问题的方法称为三路划分。
解题思路：将数据分为三部分，前面是小于keyi的而中间放和keyi相等的，后面放大于keyi的，这样如果再碰到数据全是相同的也能很好的解决。
在这里我们再继续使用三数取中来完成OJ是行不通的了，可能大量区间选keyi让你选到比较小的或者比较大的，导致性能下降，座椅解决方案就是：结合随机选keyi优化。

void swap(int* a, int* b)
{
	int temp = 0;
	temp = *a;
	*a = *b;
	*b = temp;
}

int GetMidIndex(int* a, int begin, int end)
{
	//int mid = (begin + end) / 2;
    int mid=begin+rand()%(end-begin);
	if (a[end] > a[mid])
	{
		if (a[mid] > a[begin])
		{
			return mid;
		}
		else if(a[begin]>a[end])
		{
			return end;
		}
		else
		{
			return begin;
		}
	}
	else
	{
		if (a[begin] > a[mid])
		{
			return mid;
		}
		else if(a[end]>a[begin])
		{
			return end;
		}
		else
		{
			return begin;
		}
	}
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)//递归结束
	{
		return;
	}
	//小区间优化
	if ((end - begin + 1) < 15)
    {
	// // 	// 小区间用直接插入替代，减少递归调用次数
		InsertSort(a+begin, end - begin + 1);
	}
	else
	{
		int mid=GetMidIndex(a,begin,end);
        swap(&a[mid],&a[begin]);
        int left=begin;
        int right=end;
        int keyi=a[begin];
        int cur=begin+1;
        while(cur<=right)
        {
            if(a[cur]>keyi)
            {
                swap(&a[cur],&a[right]);
                //cur++;
                right--;
            }
            else if(a[cur]<keyi)
            {
                swap(&a[cur],&a[left]);
                cur++;
                left++;
            }
            else
            {
                cur++;
            }
        }
		QuickSort(a, begin, left - 1);
		QuickSort(a, right + 1, end);
	}
}

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

归并排序

基本思想：归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：
请添加图片描述
递归写法：

void _MergeSort(int* a,int begin,int end,int *tmp)
{
	if (begin >= end)
	{
		return;
	}
	int mid = (begin + end) / 2;
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid+1, end, tmp);

	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin;
	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++];
	}

	memcpy(a+begin,tmp+begin,sizeof(int)*(end-begin+1));
}

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int)*n);
	if (tmp == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	_MergeSort(a,0,n-1,tmp);

	free(tmp);
	tmp = NULL;
}

非递归写法：

上面已经介绍完递归的写法，因为一提到递归的问题首先就应该想到的栈溢出的问题，所以就介绍了非递归的写法。
非递归思路：这里我们借用到了rangeN变量来控制每次归并的数量，这里还要解决的一个问题就是当数据的个数不是2的几次方的情况下就会出现随机数的问题，所以每次在归并前都要进行一下是否需要修正的判断。每次进行归并的间距是begin1，end1和begin2,end2进行归并，而出现随机数的情况只有三种，就是end1到最后，begin2到最后，end2到最后，只有这三种情况，将这三种情况控制住就可以实现非递归的归并了。
控制随机数的方法也是有两种：一是整体拷贝。二是部分拷贝。

整体拷贝

//整体拷贝
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * (n));
	if (tmp == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	int rangeN = 1;

	while (rangeN < n)
	{
		for (int j = 0; j < n; j += rangeN * 2)
		{
			int begin1 = j, end1 = j + rangeN - 1;
			int begin2 = j + rangeN, end2 = j + 2 * rangeN - 1;
			int i = j;
			//修正
			if (end1 >= n)
			{
				end1 = n - 1;
				//不存在的区间
				begin2 = n;
				end2 = n - 1;
			}
			else if (begin2 >= n)
			{
				begin2 = n;
				end2 = n - 1;
			}
			else if (end2 >= n)
			{
				end2 = n - 1;
			}
			//归并
			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++];
			}
		}

		//整体拷贝
		memcpy(a, tmp, sizeof(int) * n);

		rangeN *= 2;
	}
	free(tmp);
	tmp = NULL;
}

部分拷贝


//部分拷贝
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * (n));
	if (tmp == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	int rangeN = 1;

	while (rangeN < n)
	{
		for (int j = 0; j < n; j += rangeN * 2)
		{
			int begin1 = j, end1 = j + rangeN - 1;
			int begin2 = j + rangeN, end2 = j + 2 * rangeN - 1;
			int i = j;
			//修正
			if (end1 >= n)
			{
				break;
			}
			else if (begin2 >= n)
			{
				break;
			}
			else if (end2 >= n)
			{
				end2 = n - 1;
			}
			//归并
			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++];
			}
			//部分拷贝
			memcpy(a+j, tmp+j, sizeof(int) * (end2-j+1));
		}
		rangeN *= 2;
	}
	free(tmp);
	tmp = NULL;
}

归并排序的特性总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

七大排序之间的对比

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。在这里插入图片描述

最后：文章有什么不对的地方或者有什么更好的写法欢迎大家在评论区指出
现在是2022年12月29日也是22年的最后一天，在这里也简单进行一下2022年的小总结。我是从暑假的时候开始学习的，虽说是学习到了东西，但是大部份时间还是在进行摆烂，在学校的日子还算可以身边人也能带动我学习但是一回到家还是没有自控力，说白了还是太懒了。在新的一年里希望更加的自律，坚持完成每一天的任务，少想多做，要让自己看到行动，要动起来！！！！！ 在22年的最后一天，对23年的自己说一声加油！！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/131592.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

高性能web网关之Openresty相关基础知识

高性能web网关之Openresty相关基础知识

高性能web网关之Openresty一、Openresty 简介二、Openresty 应用场景三、lua-nginx-module3.1、Lua 模块指令顺序3.2、Lua嵌入nginx四、责任链五、cosocket后言一、Openresty 简介 openresty 是一个基于 nginx 与 lua 的高性能 web 平台&#xff0c;其内部集成了大量精良的 lu…
阅读更多...
148.排序链表

148.排序链表

148.排序链表 题目&#xff1a; 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4]示例 2&#xff1a; 输入&#xff1a;head [-1,5,3,4,0] 输出&#xff1a;…
阅读更多...
【论文阅读】CVPR2018-深度材料感知跨光谱立体匹配

【论文阅读】CVPR2018-深度材料感知跨光谱立体匹配

深度材料感知跨光谱立体匹配 摘要 跨光谱成像对识别和检测任务很有帮助。通常&#xff0c;多个相机用于跨光谱成像&#xff0c;因此需要图像对齐或双目系统中的视差估计。多相机跨光谱系统逐渐被嵌入到有源RGB-D设备中&#xff08;例如Kinect和iPhone X中的RGB-NIR相机&#…
阅读更多...
2022 年度回忆

2022 年度回忆

2022 年度回忆 过了今天就是2023年了&#xff0c;记录一下在这一年里发生的点点滴滴吧。 年度总结2022 年度回忆1.石家庄实习2.准备秋招&#xff0c;然后去沈阳实习3.回学校4.来北京实习了总结今年大体且分为四条故事线 1.22年上半年石家庄实习 2.实习结束回家准备秋招&#…
阅读更多...
句子表征（各项异性等偏差）：PromptBERT: Improving BERT Sentence Embeddings with Prompts

句子表征（各项异性等偏差）：PromptBERT: Improving BERT Sentence Embeddings with Prompts

一、核心 句子表征存在不足之处&#xff0c;可能面临各向异性、可能受到词频的影响、可能受到子词、大小写等的影响等等。 Gao et al.(2019)和Wang et al.(2020)指出&#xff0c;对于语言建模&#xff0c;使用最大似然训练通常会产生一个各向异性的词嵌入空间。“各向异性”是…
阅读更多...
BabaSSL：支持半同态加密算法 EC-ElGamal

BabaSSL：支持半同态加密算法 EC-ElGamal

01 背 景 随着大数据与人工智能的快速发展&#xff0c;个人隐私数据泄露和滥用时有发生&#xff0c;隐私安全问题也越来越被重视。 国家于 2020 年施行密码法、2021 年施行个人信息保护法&#xff0c;对个人隐私数据和数据安全加密有更高的要求。 因此&#xff0c;隐私计算也…
阅读更多...
2022年博客之路总结

2022年博客之路总结

今年是不平凡的一年&#xff0c;IT行业 开卷 的一年&#xff0c;今年大多数人 都 因种种原因 被迫换了工作&#xff0c;再次 先感谢CSDN 这个平台&#xff0c;在这里 给自己了一块可以展示自己才华的空间&#xff0c;通过CSDN平台的各项运营数据&#xff0c;让我有幸 拿到了 更…
阅读更多...
flv.js播放flv视频

flv.js播放flv视频

flv.js是FLV视频播放器&#xff0c;纯JS开发&#xff0c;无需Flash。 <!DOCTYPE html> <html><head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content"IEedge"><meta name"viewport"…
阅读更多...
【虚幻引擎UE】UE5 制作一个元旦烟花短视频的小案例（使用sequence制作视频案例）

【虚幻引擎UE】UE5 制作一个元旦烟花短视频的小案例（使用sequence制作视频案例）

祝愿大家元旦快乐&#xff01; 效果预览 一、创建粒子烟花特效 可以使用现成的Niagara烟花粒子特效&#xff0c;直接跳过这一步。 1、 通过Niagara系统创建粒子特效 选择现有发射器素材。 或者也可新建空白特效&#xff0c;将发射器拖入轨道&#xff08;素材包含闪光、拖…
阅读更多...
基于TP6+Uni-app框架开发的多端圈子社区论坛小程序H5系统,带数据库和安装教程

基于TP6+Uni-app框架开发的多端圈子社区论坛小程序H5系统,带数据库和安装教程

正文&#xff1a; 前台uni-app后台tp6开发的多端圈子社区论坛小程序H5系统,带数据库和安装教程。 系统基于TP6Uni-app框架开发&#xff1b;客户移动端采用uni-app开发&#xff0c;管理后台TH6开发。 系统支持微信公众号端、微信小程序端、H5端、PC端多端账号同步&#xff0c…
阅读更多...
CSDN的2022和2023

CSDN的2022和2023

前言 今天是2022年12月31日&#xff0c;今年的最后一天&#xff0c;年关已至。 又到了&#xff1a;回头看路&#xff0c;低头赶路&#xff0c;抬头望路的时候。 回顾2022 疫情中的2022 今年应该算是疫情的高峰期吧&#xff0c;各种新冠变异株横行&#xff0c;从严控到一夜…
阅读更多...
Day845.Fork/Join -Java 并发编程实战

Day845.Fork/Join -Java 并发编程实战

Fork/Join Hi&#xff0c;我是阿昌&#xff0c;今天学习记录的是关于Fork/Join的内容。 线程池、Future、CompletableFuture 和 CompletionService&#xff0c;仔细观察会发现这些工具类都是在帮助站在任务的视角来解决并发问题&#xff0c;而不是让纠缠在线程之间如何协作的…
阅读更多...
深度学习：05 卷积神经网络介绍（CNN）

深度学习：05 卷积神经网络介绍（CNN）

目录 卷积神经网络简介 为什么要用卷积神经网络 网络结构组成 卷积层 卷积计算 卷积核大小 f 边界填充 (p)adding 步长 (s)tride 计算公式 卷积层 激活函数 池化层&#xff08;pooling&#xff09; dropout层 全连接层 卷积神经网络简介 卷积神经网络由一个或多个…
阅读更多...
DoIP协议从入门到精通系列——车载网络安全

DoIP协议从入门到精通系列——车载网络安全

现代社会慢慢步入数字时代，在这个时代，网络安全已经成为最重要的关注点。自从1980年第一次出现电脑病毒，网络威胁和攻击持续不断，给社会（经济）带来巨大影响。随着汽车的数字化和互联化发展，自然而然会联想到汽车也将为成为黑客攻击的目标。导致的问题除了单纯的不便（攻…
阅读更多...
数据结构 | 十大排序超硬核八万字详解【附动图演示、算法复杂度性能分析】

数据结构 | 十大排序超硬核八万字详解【附动图演示、算法复杂度性能分析】

写在前面 2023年的第一篇博客&#xff0c;在这里先祝大家兔年快乐&#x1f430; 本文从学习到搜寻各种资料&#xff0c;整理成博客的形式展现足足花了一个月的时间&#xff0c;慢工出细活&#xff0c;希望本篇文章可以真正带你学懂排序&#xff0c;不再为写排序算法而苦恼 博主…
阅读更多...
MQTT协议的工作原理

MQTT协议的工作原理

一、MQTT概述 MQTT由IBM的Andy Stanford-Clark博士和Arcom&#xff08;现为Eurotech&#xff09;的Arlen Nipper于1999年发明。 MQTT 是物联网 &#xff08;IoT&#xff09; 最常用的消息传递协议。MQTT 代表 MQ 遥测传输。该协议是一组规则&#xff0c;用于定义物联网设备如何…
阅读更多...
二叉树16：找树左下角的值

二叉树16：找树左下角的值

主要是我自己刷题的一些记录过程。如果有错可以指出哦&#xff0c;大家一起进步。 转载代码随想录 原文链接&#xff1a; 代码随想录 leetcode链接&#xff1a;513.找树左下角的值 题目&#xff1a; 给定一个二叉树的 根节点 root&#xff0c;请找出该二叉树的 最底层 最左边…
阅读更多...
Android每周一轮子：Nvwa（热修复）

Android每周一轮子：Nvwa（热修复）

前言 &#xff08;废话&#xff09; 最近发现了一个问题&#xff0c;一些平时博客写的很多的程序员&#xff0c;反倒在日常的工作中&#xff0c;却是业务写的很一般&#xff0c;只会摆理论的人&#xff0c;甚至还跑出来教别人如何找工作&#xff0c;如何做架构&#xff0c;其实…
阅读更多...
2022年终总结：少年不惧岁月长，彼方尚有荣光在。

2022年终总结：少年不惧岁月长，彼方尚有荣光在。

2022年终总结&#xff1a;少年不惧岁月长&#xff0c;彼方尚有荣光在。 &#x1f3ac; 博客主页&#xff1a;王同学要努力 &#x1f3ac;个人简介&#xff1a;大三小白&#xff0c;喜欢前端 &#xff0c;热爱分享 &#x1f3a5; 本文由 王同学要努力 原创&#xff0c;首发于…
阅读更多...
Eureka 注册中心

Eureka 注册中心

Eureka 注册中心目录概述需求&#xff1a;设计思路实现思路分析1.快速上手2.增加 Maven 依赖3.Client端配置注册中心Server端配置注册中心参考资料和推荐阅读Survive by day and develop by night. talk for import biz , show your perfect code,full busy&#xff0c;skip ha…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023