【数据结构和算法】--- 基于c语言排序算法的实现（2）

目录

  • 一、交换排序
    • 1.1 冒泡排序
    • 1.2 快速排序
      • 1.2.1 hoare法
      • 1.2.2 挖坑法
      • 1.2.3 前后指针法
    • 1.3 快速排序优化
      • 1.3.1 三数取中法选key
      • 1.3.2 递归到小的子区间使用插入排序
    • 1.4 快排非递归版
  • 二、归并排序
    • 2.1 归并排序
      • 2.1.1 递归版
      • 2.1.2 非递归版

一、交换排序

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置。交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

1.1 冒泡排序

说起冒泡排序，这也算是在我们学习编程时遇到的第一个排序算法，总体逻辑就是从待排序数组第一个一直向后遍历，遇到比自己大的就记录该值，遇到比自己小的就交换，直到到达待排序数组结尾，此时待排序数组长度--，依此逻辑每次都能将最大值移动到最后。直到待排序数组长度为0，此时数组已有序。

冒泡排序动态演示：

在这里插入图片描述

在实现代码时，还可以增加一个变量bool exchange = true，如果一趟遍历下来，没有任何数据进行交换，则exchange不变，代表此时数组已有序，那么便直接结束排序(if(exchange == true) break;)；如果发生数据交换，则改变exchange值为false，那么排序任然继续下一趟。 代码如下：

//冒泡排序
void BubbleSort(int* a, int n)
{
    //排序趟数
	for(int i = 0; i < n - 1; ++i)
	{
		bool exchange = true;
		//每趟需要排的元素
		for(int j = 0; j < n - 1 - i; ++j)
		{
			//左大于右就交换
			if(a[j] > a[j + 1])
			{
				Swap(&a[j], &a[j + 1])
				exchange = false;
			}
		}
		if(exchange == true)
			break;
	}
}

冒泡排序的特性总结：

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

1.2 快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

那么具体是如何实现的呢？可以参考如下过程：
在这里插入图片描述
事实上整体逻辑就是二叉树的前序遍历，即先处理当前数组，取基准值，以基准值为标准划分左右两部分，然后递归基准值左部分([begin, div - 1])，最后在递归基准值右部分([div + 1, end])。 将begin >= end作为结束条件，说明当前已经递归到的部分的数据个数<= 1，return回到上层递归。

整个递归逻辑的主体部分为partion()函数，用来划分基准值左右两部分，并返回当前基准值的下标。 可以使用三种方法来实现partion()函数，即初版hoare法，挖坑法，前后指针法，后两者是对hoare法的改进，下面将逐一介绍！

递归框架：

// 假设按照升序对a数组中[bedin, end]区间中的元素进行排序
void QuickSort(int* a, int begin, int end)
{
 	if(begin >= end)
 		return;
 
 	// 按照基准值对a数组的 [begin, end]区间中的元素进行划分
 	int div = partion(a, begin, end);
 
 	// 划分成功后以div为边界形成了左右两部分 [begin, div - 1] 和 [div + 1, end]
 	// 递归排[begin, div - 1]
 	QuickSort(a, begin, div - 1);
 
 	// 递归排[div + 1, end]
 	QuickSort(a, div + 1, end);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，我们可以参照二叉树前序遍历（如有疑问请参考：【数据结构和算法】— 二叉树（3）–二叉树链式结构的实现（1））规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

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

1.2.1 hoare法

hoare法 动态演示：
在这里插入图片描述
hoare法主要思想：定义两个变量分别对应待排序数组首元素下标int left = begin，待排序数组尾元素下标int right = end。右边先向左找小于a[keyi]的值，找到后，左边在向右找大于a[keyi]的值，然后交换两数Swap(&a[left], &a[right])。需要注意的是，在寻找过程中要保证left < right。最后直到left == right，将基准值和相遇点的值交换Swap(&a[keyi], &a[left])，并返回基准值下标return keyi。

hoare法代码：

//hoare法
int partion(int* a, int begin, int end)
{
	int left = begin, right = end;
	//设基准值为首元素，keyi记录下标
	int keyi = begin;
	while(left < right)
	{
		//右向左 找小于a[keyi]的值
		while(left < right && a[keyi] <= a[right]
			--right;
		//左向右 找大于a[keyi]的值
		while(left < right && a[keyi] >= a[left]
			++left;
		//找完一次便交换，
		Swap(&a[left], &a[right]);
	}
	//left 和 right 相遇交换基准值和 < a[keyi] 的值(即a[left])
	Swap(&a[left], &a[keyi]);
	return left;
}

相信看完上面上面代码和演示，会有这么一个问题：为什么相遇的位置比a[keyi]要小呢？

因为左边做keyi，右边right先走：

  • 情况1：right先遇到left。此时right没有找到比a[keyi]小的，一直走，直到遇到left，相遇位置是a[left]，一定比a[keyi]小；
  • 情况2：left先遇到right。因为是right先走，找到小于a[keyi]的元素便会停下，接着left找大，没有找到，遇到了right停下来了，相遇点是right，比a[keyi]要小。

当然如果右边做基准值，那么必须要左边left先走，才能确保相遇点都大于a[keyi]。

1.2.2 挖坑法

挖坑法 动态演示：
在这里插入图片描述
挖坑法主要思想：先取出基准值，并将其赋值给key ，此时这个位置就空出来了，称之为坑位，用holei来记录坑位的下标。 紧接着右边向左找小（即小于key的元素），若找到就将该元素填入坑位中a[holei] = a[end]，并改变坑位为替换元素的下标holei = end，然后左边向右找大（即大于key的元素），同样填入坑位，并更新坑位。依次循环，直到左右相遇begin == end，这时将基准值填入坑中(a[holei] = key)，并返回坑位return holei;。

挖坑法代码：

//挖坑法
int partion(int* a, int begin, int end)
{
    //基准值记录
	int key = a[begin];
	//坑位记录
	int holei = begin;
	while(begin < end)
	{
		//右边找小，填左坑，更新坑位
		while(begin < end && a[end] >= key)
			--end;
		a[holei] = a[end];
		holei = end;
		//左边找小，填右坑，更新坑位
		while(begin < end && a[begin] <= key)
			++begin;
		a[holei] = a[begin];
		holei = begin;
	}
	//基准值填入坑位
	a[holei] = key;
	return holei;
}

1.2.3 前后指针法

前后指针法 动态演示：
在这里插入图片描述
前后指针法主要思想：事实上这里定义的并不是真正的指针，而是整形来模拟指针。 将初始位置定义为前指针int prev = begin;，后一个位置定义为后指针int cur = begin + 1;，并记录基准值int key = a[begin];。当后指针指向的元素大于key时，++cur;若找到了小于key的值，那么就++prev，在判断prev != cur之后，就交换前后指针对应的值(Swap(&a[prev], &a[cur]))；若相等则跳过。最后在交换基准值和前指针对应的元素(Swap(&a[prev], &a[keyi]))，并返回前指针对应元素下标(return prev;)。

  • cur遇到比key大的值，++cur；
  • cur遇到比key小的值，Swap(&a[prev], &a[cur])，++cur，++prev。

前后指针法代码：

//前后指针法
int partion(int* a, int begin, int end)
{
	int prev = begin, cur = begin + 1;
	int keyi = begin;
	//注意此处 <=
	while(cur <= end)
	{
	    //将两种逻辑合二为一
		if(a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[prev], &a[cur]);
		++cur;
	}
	Swap(&a[prev], &a[keyi]);
	return prev;
}

1.3 快速排序优化

1.3.1 三数取中法选key

考虑下面这种情况：当数组已经有序或者极其接近有序时，再使用递归法写快速排序，时间复杂度如何？

此时基准值如果还选择待排序数组第一个元素的话，那么每层递归便缺少基准值左部分的递归(即begin >= end)，只有右部分， 这样待排序的数组只减少了一个元素，递归深度由原来的log(N)变成了N，时间复杂度也随之变成了O(N^2)。

于是乎，一般会选择三数取中法来确定基准值，这样选出来的数既不会是最大值，也不会是最小值。三数指的是：待排序数组第一个元素a[begin]，待排序数组最后一个元素a[end]，待排序数组中间那个数a[(begin + end) / 2]；取中指：取这三个数的中位数。 取到之后与初始值交换 Swap(&a[midi], &a[begin]);，确保第一个值为中位数。实现代码如下：

//三数取中
int GetMidi(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	//begin  midi  end  三个数选中位数
	if(a[begin] < a[midi])
	{
		if(a[midi] < a[end])
			return midi;
		else if(a[begin] > a[end])
			return begin;
		else
			return end;
	}
	else //a[begin] >= a[midi]
	{
		if(a[midi] > a[end])
			return midi;
		else if(a[end] > a[bedin])
			return begin;
		else
			return end;
	}
}

int midi = GetMidi(a, begin, end);
Swap(&a[midi], &a[begin]);

1.3.2 递归到小的子区间使用插入排序

为什么说递归到小的子区间要使用插入排序呢？ 根据这里写的递归的特性，可以看出整体的逻辑是一棵二叉树。说到二叉树，二叉树最后一层的节点数大约占整个二叉树的节点数的一半，这样一来时间复杂度便会升高。那么我们只需要想办法将最后两三层递归逻辑，使用其他效率高的排序给替换掉即可。 这样一来如果替换掉两层，就减少了大约75%的递归，替换三层,大约就减少了87.5%的递归。

小区间优化代码如下：

//小区间优化
void QuickSort(int* a, int begin, int end)
{
	if(begin >= end)
		return;
	if(end - begin + 1 <= 10)
	{
		//end - begin + 1 <= 10 此逻辑大约优化了三层
		//插入排序
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int keyi = partion(a, begin, end);
		QuickSort(a, begin, keyi - 1);
		QuickSort(a, keyi + 1, end);
	}
}

事实上，在如今的编译器上，此优化是微乎其微的，因为编译器已经帮助我们进行了很多优化，特别是在release版编译程序时。那么此处为什么选择直接插入排序？根据其特性，元素集合越接近有序，直接插入排序算法的时间效率越高。且此时待排序数组的元素个数较少，不适合希尔排序，且他是一种稳定的排序算法。

1.4 快排非递归版

根据递归版快排的特性，相当于二叉树的前序遍历，那么我们便可利用栈后进先出的特性，来模拟递归并实现排序，栈的实现还请参考：【数据结构和算法】— 栈。快排非递归整体逻辑大致如下：

在这里插入图片描述

在实现时我们要先创建栈并初始化，然后进栈一对数据（整个待排序数组的下标范围）， 以!STEmpty(&s)作为循环条件，当栈中无节点时，便会结束。每进栈一次，便出栈顶两元素作为此次排序的范围，然后进栈div左右两部分的范围，当然只有范围中有一个数据以上才会进栈（即left < div - 1或right > div + 1）。

//非递归，栈模拟
void QuickSortNonR(int* a, int begin, int end)
{
	ST s;
	STInit(&s);
	//先进栈一对数据
	STPush(&s, end);
	STPush(&s, begin);
	while(!STEmpty(&s))
	{
		//出栈一对数据，为此次排序范围
		int left = STTop(&s);
		STPop(&s);
		int right = STTop(&s);
		STPop(&s);
		int div = partion(a, begin, end);
		//div 右部分进栈
		if(right > div + 1)
		{
			STPush(&s, right);
			STPush(&s, div + 1);
		}
		//div 左部分进栈
		if(left < div - 1)
		{
			STPush(&s, div - 1);
			STPush(&s, left);
		}
	}
}

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序；

  2. 时间复杂度： O(N*logN)
    在这里插入图片描述

  3. 空间复杂度： O(logN)

  4. 稳定性： 不稳定

二、归并排序

2.1 归并排序

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

在这里插入图片描述

归并排序 动态演示：

在这里插入图片描述

2.1.1 递归版

递归版的归并排序，逻辑上与二叉树的后序遍历十分相似。可先找到待排序数组的中间那个数的下标int mid = (begin + end) / 2;，将左部分[begin, mid]作为左子树，右部分[mid + 1, end]作为右子树，继续递归，直到begin >= end（即当前元素个数小于等于一个）结束并返回，当左右部分递归完便开始合并。

此处合并即为两待排序数组[begin, mid]和[mid + 1, end]，向动态开辟的数组tmp中拷贝并排序。 至于合并的逻辑就十分简单，两待排序数组元素依次比较，小的拷贝进tmp，直到一方拷贝完begin1 > end1或begin2 > end2，然后直接拷贝未拷贝完的一方，最后再使用memcpy()函数将tmp中数据（此时tmp中元素已有序）拷回a中。

代码如下：

//递归版 归并排序
void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if(begin >= end)
		return;
	int mid = (begin + end) / 2;
	//[begin, mid]  [mid + 1, end]
	_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 fail");
		return;
	}
	_MergeSort(a, 0, n - 1, tmp);
	free(tmp);
}

2.1.2 非递归版

归并排序非递归版与递归相似，使用循环来模拟递归的合并逻辑。定义变量int gap来表示所需合并的两数组的长度，动态开辟长度为n的数组来存储合并后的数组，用i来控制待合并数组的初始下标for(size_t i = 0; i < n; i += 2*gap)（长度小于数组长度，一次跳过两gap）。

在这里插入图片描述

根据i确定好两待合并数组的首元素下标begin，尾元素下标end，然后将两个数组合并为一个，并排为升序。在确定begin和end时要注意边界条件的处理（即最后一对待排序数组下标可能超出n），大致分为以下几种情况：

在这里插入图片描述
当情况1时，因为只有一个待排序数组[begin1, end1]，且此数组已有序所以无需进行合并排序操作，直接break即可；而情况2，是两个待排序数组，需要合并，但第二个数组可能超出了a数组的范围，所以要缩小end2（即end2 = n - 1）。

代码如下：

//递归版 归并排序
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int)* n);
	if(tmp == NULL)
	{
		perror("malloc fail");
		return;
	}
	int gap = 1;
	while(gap < n)
	{
		for(size_t i = 0; i < n; i += 2*gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2*gap - 1;
			//边界处理
			if(end1 >= n || begin2 >= n)
				break;
			if(end2 >= n)
				end2 = n - 1;
			//[begin1, end1]  [begin2, end2]  归并
			int j = begin1;
			//将两个数组合并为一个，并排为升序
			while(begin1 <= end1 && begin2 <= end2)
			{
				if(a[begin1] < a[begin2])
					tmp[j++] = a[begin1++];
				else
					tmp[j++] = a[begin2++];
			}
			//拷贝剩余数据
			while(begin1 <= end1)
				tmp[j++] = a[begin1++];
			while(begin2 <= end2)
				tmp[j++] = a[begin2++];
			//拷贝回原数组
			memcpy(a + i, tmp + i, sizeof(int)* (end2 - i + 1));
		}
		gap *= 2;
	}
	free(tmp);
}

在非递归的归并排序中，有这么两个问题值得思考：

  1. 对比栈实现快排的非递归，归并排序为什么不可以使用栈？
    两种排序的非递归写法，本质上与二叉树遍历极其相似。区别在于快速排序的非递归相当于二叉树的前序遍历，可以利用栈后进先出的特性来实现；而归并排序相当于二叉树的后序遍历，只能用循环来模拟实现。

  2. 上面代码中memcpy()函数的拷贝操作与放在for循环外对比！
    放在for循环内（即每归并一小段，就放回原数组a中），这样避免了随机值。因为当情况1时，break了，后面的数据（最后一组）并没有放到动态开辟的数组tmp中，从而导致访问到随机值（即因为拷贝操作放在for循环外，全部数据，统一拷贝，最后一对数据memcpy()时，会遇到随机值）

归并排序的特性总结：

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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

hexo 博客搭建以及踩雷总结

hexo 博客搭建以及踩雷总结

搭建时的坑 文章置顶 安装一下这个依赖 npm install hexo-generator-topindex --save然后再文章的上面设置 top: number&#xff0c;数字越大&#xff0c;权重越大&#xff0c;也就是越靠顶部 hexo 每次推送 nginx 都访问不到 宝塔自带的 nginx 的 config 里默认的角色是 …
阅读更多...
磁盘分区和挂载

磁盘分区和挂载

一、分区概念 1、基本概念 (1) 一块硬盘最多只能有4个主分区 (2) 其中一个(且最多只能有一个)主分区能作为扩展分区,而扩展分区不能写入数据,只能包含逻辑分区 2、格式化 分区之后的磁盘并不能直接使用&#xff0c;而是需要先进行格式化&#xff0c;又称为逻辑格式化。它是指…
阅读更多...
掌握Go的加密技术：crypto/rsa库的高效使用指南

掌握Go的加密技术：crypto/rsa库的高效使用指南

掌握Go的加密技术&#xff1a;crypto/rsa库的高效使用指南 引言crypto/rsa 库概览RSA 加密算法基本原理crypto/rsa 库的功能和应用 安装和基本设置在 Go 项目中引入 crypto/rsa 库基本环境设置和配置 密钥生成与管理生成 RSA 密钥对密钥存储和管理 加密和解密操作使用 RSA 加密…
阅读更多...
【HTML+CSS】使用CSS中的Position与z-index轻松实现一个简单的自定义标题栏效果

【HTML+CSS】使用CSS中的Position与z-index轻松实现一个简单的自定义标题栏效果

&#x1f680; 个人主页 极客小俊 ✍&#x1f3fb; 作者简介&#xff1a;web开发者、设计师、技术分享博主 &#x1f40b; 希望大家多多支持一下, 我们一起学习和进步&#xff01;&#x1f604; &#x1f3c5; 如果文章对你有帮助的话&#xff0c;欢迎评论 &#x1f4ac;点赞&a…
阅读更多...
【数据结构与算法】【小白也能学的数据结构与算法】递归 分治 迭代 动态规划 无从下手？一文通！！！

【数据结构与算法】【小白也能学的数据结构与算法】递归 分治 迭代 动态规划 无从下手？一文通！！！

&#x1f389;&#x1f389;欢迎光临&#x1f389;&#x1f389; &#x1f3c5;我是苏泽&#xff0c;一位对技术充满热情的探索者和分享者。&#x1f680;&#x1f680; &#x1f31f;特别推荐给大家我的最新专栏《数据结构与算法&#xff1a;初学者入门指南》&#x1f4d8;&am…
阅读更多...
【计算机网络】Web HTTP

【计算机网络】Web HTTP

Web和HTTP HTTP 超文本传输协议 HyperText Transfer Protocol HTTP使用TCP作为支撑传输协议 由一个客户程序和一个服务器程序实现一些常见名词。。。无状态协议 stateless protocol 不保存关于客户的任何信息非持续/持续链接 non-persistent con…
阅读更多...
【十三】【C++】vector简单实现

【十三】【C++】vector简单实现

代码实现 /*vector类简单实现*/ #if 1 #define _CRT_SECURE_NO_WARNINGS#include <iostream> using namespace std; #include <vector> #include <algorithm> #include <crtdbg.h> #include <assert.h> #include <string.h>namespace MyVe…
阅读更多...
寒假作业2024.2.11

寒假作业2024.2.11

请使用递归实现n! #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #include <unistd.h> int fun(int n) {if (n0) {return 1;} else {return n*fun(n-1);} } int main(int argc, const char *argv[]) {int n…
阅读更多...
嵌入式系统学习指南：从入门到精通

嵌入式系统学习指南：从入门到精通

如今嵌入式系统已经广泛应用于工控、消费电子、汽车电子、医疗设备等多个领域。越来越多的IT工程师选择进入嵌入式系统行业。那么作为新手,如何系统地学习嵌入式知识,从入门到精通呢?本文将为大家提供一份简单的自学路线。&#xff08;个人观点&#xff0c;仅供参考&#xff0…
阅读更多...
代码随想录 Leetcode55. 跳跃游戏

代码随想录 Leetcode55. 跳跃游戏

题目&#xff1a; 代码(首刷自解 2024年2月9日&#xff09;&#xff1a; class Solution { public:bool canJump(vector<int>& nums) {int noz 0;for (int i nums.size() - 2; i > 0; --i) {if (nums[i] 0) {noz;continue;} else {if (nums[i] > noz) noz …
阅读更多...
vtkActor 设置特定图层 显示及置顶显示

vtkActor 设置特定图层 显示及置顶显示

问题&#xff0c;有时我们需要显示某个 Actor 在相机最前面&#xff0c;可以遮盖后面的物体;显示在顶层有点不准确&#xff1b;因为这个还相机位置也有关系&#xff1b; 这里讲三种情况&#xff1a; 1. 设置 Mapper 顶层&#xff0c;尝试了一下&#xff0c;可以用于某些场景&…
阅读更多...
《PCI Express体系结构导读》随记 —— 第II篇 第4章 PCIe总线概述（12）

《PCI Express体系结构导读》随记 —— 第II篇 第4章 PCIe总线概述（12）

接前一篇文章&#xff1a;《PCI Express体系结构导读》随记 —— 第II篇 第4章 PCIe总线概述&#xff08;11&#xff09; 4.2 PCIe体系结构的组成部件 PCIe总线作为处理器系统的局部总线&#xff0c;其作用与PCI总线类似&#xff0c;主要目的是为了连接处理器系统中的外部设备…
阅读更多...
前后端分离nodejs+vue流浪狗宠物领养公益网站

前后端分离nodejs+vue流浪狗宠物领养公益网站

1.发现公益&#xff1a;主要是根据社会上的调研&#xff0c;来收集的社会上有关流浪狗的公益活动&#xff0c;发布在公益网站上能被更多人发现&#xff0c;主要让更多人能参与到公益活动中来&#xff0c;并调动群众的同情心和爱心&#xff0c;借此希望在养宠物的主人能避免自己…
阅读更多...
直播app开发，技术驱动的实时互动新纪元

直播app开发，技术驱动的实时互动新纪元

随着互联网技术的快速发展&#xff0c;直播已成为我们日常生活的重要组成部分。从娱乐、教育到商业活动&#xff0c;直播的广泛应用正在改变着我们的生活和工作方式。在这一变革中&#xff0c;直播开发扮演着至关重要的角色。本文将探讨直播开发的核心理念、技术挑战以及未来的…
阅读更多...
【EAI 017】Interactive Language: Talking to Robots in Real Time

【EAI 017】Interactive Language: Talking to Robots in Real Time

论文标题&#xff1a;Interactive Language: Talking to Robots in Real Time 论文作者&#xff1a;Corey Lynch, Ayzaan Wahid, Jonathan Tompson Tianli Ding, James Betker, Robert Baruch, Travis Armstrong, Pete Florence 作者单位&#xff1a;Robotics at Google 论文原…
阅读更多...
林浩然与杨凌云的Java世界奇遇记：垃圾回收大冒险

林浩然与杨凌云的Java世界奇遇记：垃圾回收大冒险

林浩然与杨凌云的Java世界奇遇记&#xff1a;垃圾回收大冒险 The Java Adventure Chronicles of Lin Haoran and Yang Lingyun: Garbage Collection Odyssey 在一个充满0和1代码森林的世界里&#xff0c;住着两位勇敢的程序员侠侣——林浩然和杨凌云。林浩然是个身怀Java绝技的…
阅读更多...
k8s -ingress

k8s -ingress

概念 Ingress 公开了从集群外部到集群内服务的 HTTP 和 HTTPS 路由&#xff0c;ingress能代理集群为内部的网络&#xff0c;将集群外部的HTTP/HTTPS网络请求转发至不同的service&#xff0c;其本质就是创建一个NodePort类型的svc,和一个nginx 组成 k8s中的ingress 其实是指…
阅读更多...
【万题详解】洛谷P1282 多米诺骨牌

【万题详解】洛谷P1282 多米诺骨牌

题目 链接——题目在这里&#xff01;&#xff01;&#xff01; 多米诺骨牌由上下 22 个方块组成&#xff0c;每个方块中有 1∼6 个点。现有排成行的上方块中点数之和记为 S1​&#xff0c;下方块中点数之和记为 S2​&#xff0c;它们的差为 ∣∣S1​−S2​。如图S161119&…
阅读更多...
提升MySQL访问性能

提升MySQL访问性能

1. 读写分离 设置多个从数据库&#xff0c;从数据库可能在多个机器中。写操作在主数据库进行主数据库提供数据的主要依据 缓解了MySQL的读压力。 主从复制原理图如下 如果对于读操作有一致性要求&#xff0c;那么读操作去主数据库即可。 2. 连接池 因为一个请求必须要…
阅读更多...
SpringCloud-Nacos服务分级存储模型

SpringCloud-Nacos服务分级存储模型

Nacos 服务分级存储模型是 Nacos 存储服务注册信息和配置信息的核心模型之一。它通过将服务和配置信息按照不同级别进行存储&#xff0c;实现了信息的灵活管理和快速检索&#xff0c;为微服务架构下的服务发现和配置管理提供了高效、可靠的支持。本文将对 Nacos 服务分级存储模…
阅读更多...
最新文章

Copyright @ 2022~2023