二分法查找有序表的通用算法（可查链表，数组，字符串...等等）

find_binary函数 

注意事项：

（1）你设计的迭代器模板中必须有using value_type = T，且有加减运算功能，其本上能与C++标准库std中一样。

（2）集合必须是有序的。

下面是函数代码：

/// <summary>
/// 二分法查找有序表的通用算法（可查链表，数组，字符串...等等）
/// 例子：
///  vector<int> v;
///  find_binary(b.begin(),v.end(),3);  // Inde返回 (-1, *Iterator == ?)
/// 
///  vector<int> v = {3};
///  find_binary(b.begin(),v.end(),3);  // 返回  (Index == 0, *Iterator == 3)
///  
///  const char* sz = "abcdefgb";
///  auto f3 = lf::find_binary(sz, sz + 8, 'c');  //返回  (Index == 2, *Iterator == c)
/// </summary>
/// <typeparam name="IteratorType">迭代器类型</typeparam>
/// <typeparam name="value_type">值类型</typeparam>
/// <param name="itBegin">开始位置</param>
/// <param name="itEnd">结束位置</param>
/// <param name="vtFindValue">查找值</param>
/// <returns>返回索引与指向vtFindValue的迭代器</returns>
/// 创建时间： 2024-07-03     最后一修改时间：2024-07-03  (基本上已经测试）
template<typename IteratorType,typename value_type = IteratorType::value_type>
FindResult<IteratorType> find_binary(const IteratorType& itBegin, 
	const IteratorType& itEnd, const value_type& vtFindValue)
{

	FindResult<IteratorType> fr;  

	auto beg = itBegin;
	auto end = itEnd;
	int nCount = end - beg;

	if (nCount == 0) return fr;


	if (*(itEnd-1) > *itBegin) {//从小到大排列

		auto mid = beg + nCount / 2;

		while (mid != itEnd){

			if(*mid == vtFindValue){
				fr.Iter = mid;
				fr.Index = mid - itBegin;

				return fr;
			}

			if (vtFindValue < *mid)
				end = mid;
			else
				beg = mid + 1;  //在mid之后查找

			mid = beg + (end - beg) / 2;   //新的中间点
		}	 

	}else{ //从大到小排列 
 
		auto mid = beg + nCount / 2;

		while (mid != itEnd) {

			if (*mid == vtFindValue) {
				fr.Iter = mid;
				fr.Index = mid - itBegin;

				return fr;
			}

			if (vtFindValue > *mid)
				end = mid;
			else
				beg = mid + 1;  //在mid之后查找

			mid = beg + (end - beg) / 2;   //新的中间点
		}
	}

	return fr;
}

例子代码：

 
int main()
{
 
	std::vector<int> v1 = { 1,2,3,4,5,6 ,7,8,9,10 };
	_DList<int> d1 = { 1,2,3,4,5,6 ,7,8,9,10 };
	const char* sz = "abcdefgb";

	auto f1 = lf::find_binary(v1.begin(), v1.end(), 3);

	cout << *(f1.Iter) << "\n";
	cout << f1.Index << "\n";
	cout << "----------" << "\n";

	auto f2 = lf::find_binary(d1.begin(), d1.end(), 3);

	cout << *(f2.Iter) << "\n";
	cout << f2.Index << "\n";
	cout << "----------" << "\n";

	auto f3 = lf::find_binary(sz, sz + 8, 'c');

	cout << *(f3.Iter) << "\n";
	cout << f3.Index << "\n";

	cout << "----------" << "\n";

	std::vector<int> v2 = { 10,9,8,7,6,5,4,3,2,1 };

	auto f4 = lf::find_binary(v2.begin(), v2.end(), 3);

	cout << *(f4.Iter) << "\n";
	cout << f4.Index << "\n";

	cout << "----------" << "\n";
 
}

输出：

完整代码如下：

/*******************************************************************************************
文件名						： _AlgorithmLibrary.h

功能							： 算法库

作者							： 李锋

手机							： 13828778863

Email						： ruizhilf@139.com

创建时间						： 2024年07月02日

最后一次修改时间				:  2024年07月02日
*********************************************************************************************/
#pragma once


//Algorithm library  算法库

#include "_Macro.h"

 
/*****************************************************************************
	
								排序


 ****************************************************************************/

//排序
//参考：https://blog.csdn.net/qq_45615577/article/details/115257685

//排序的概念
/*
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次 序保持不变，即在原序列中，r[i] = r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排 序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
————————————————

版权声明：本文为博主原创文章，遵循 CC 4.0 BY - SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https ://blog.csdn.net/qq_45615577/article/details/115257685
*/
_LF_BEGIN_

/// <summary>
/// 选择排序---直接选择排序
/// 每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，
/// 直到全部待排序的 数据元素排完 。
/// 找出序列中的最小关键字，然后将这个元素与序列首端元素交换位置。例如，序列前i个
/// 元素已经有序，从第i + 1到第n个元素中选择关键字最小的元素，假设第j个元素为最小
/// 元素，则交换第j个元素与第i + 1个元素的位置。依次执行此操作，直到第n - 1个元素
/// 也被确定。
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="pData">开始位置</param>
/// <param name="nCount">元素个数</param>
/// <param name="so">排序顺序，默认从小到大</param>
/// 创建时间： 2024-07-01     最后一修改时间：2024-07-01
/// 参考网址：https://blog.csdn.net/qq_45615577/article/details/115257685 
template<class T>
void sort_selection(T* pData, const size_t& nCount, const bool& bMinMax = true)
{

	/*
		7 4 5 9 8 2 1
		1 4 5 9 8 2 7
		  2 5 9 8 4 7
			4 9 8 5 7
			  5 8 9 7
				7 9 8
				  8 9


		在 [0 , n-1] 中找出最小的放在第一位
		在 [1 , n-1] 中找出最小的放在第二位
		...


	*/

	if (pData == null || nCount == 0) return;

	int nSortedCount = 0;  //已排序好的个数

	if (bMinMax) {

		while (nSortedCount < nCount) {

			int  minIndex = nSortedCount;

			//在[nStart, nCount-1] 中找出最小值
			for (int n = nSortedCount + 1; n < nCount; ++n) {

				if (*(pData + n) < *(pData + minIndex)) {

					minIndex = n;
				}
			}

			if (minIndex != nSortedCount) {

				T tmp = *(pData + minIndex);
				*(pData + minIndex) = *(pData + nSortedCount);
				*(pData + nSortedCount) = tmp;
			}

			++nSortedCount;
		}

	}
	else {

		while (nSortedCount < nCount) {

			int  maxIndex = nSortedCount;

			//在[nStart, nCount-1] 中找出最大值
			for (int n = nSortedCount + 1; n < nCount; ++n) {

				if (*(pData + n) > *(pData + maxIndex)) {
					maxIndex = n;
				}
			}

			if (maxIndex != nSortedCount) {

				T tmp = *(pData + maxIndex);
				*(pData + maxIndex) = *(pData + nSortedCount);
				*(pData + nSortedCount) = tmp;
			}
			++nSortedCount;
		}
	}

}


/// <summary>
/// 返回最小值的位置
///		lf::_DList<int> d1 = { 1,3,5,8,2,0 };
///		lf::_DList<int> d2 = { 1 };
///		lf::_DList<int> d3 = { };
///		vector<int> v = { 1,3,5,8,2,0 };
///
///		_pin(*lf::Min(d1.begin(), d1.end()));  //输出： 0
///		_pin(*lf::Min(d2.begin(), d2.end()));  //输出： 1
///		_pin(*lf::Min(d3.begin(), d3.end()));  //报错，最少一个元素
///
///		_pin(*lf::Min(v.begin(), v.end()));  //输出： 0
/// 
/// 	_string s = _t("sdwsffa");
///		_pin(*lf::Min(s.begin(), s.end()));  //输出： a

/// </summary>
/// <typeparam name="IteratorClass"></typeparam>
/// <param name="itBegin"></param>
/// <param name="itEnd"></param>
/// <returns></returns>
/// 创建时间： 2024-07-02     最后一修改时间：2024-07-02
template<typename IteratorClass>
IteratorClass Min(IteratorClass itBegin, IteratorClass itEnd) {

	assert(itBegin != itEnd);

	IteratorClass result = itBegin;

	while (itBegin != itEnd) {

		if (*result > *itBegin)
			result = itBegin;
		++itBegin;
	}

	return result;
}


/// <summary>
/// 
/// </summary>
/// <typeparam name="IteratorClass"></typeparam>
/// <param name="itBegin"></param>
/// <param name="itEnd"></param>
/// <returns></returns>
/// 创建时间： 2024-07-02     最后一修改时间：2024-07-02
template<typename IteratorClass>
IteratorClass Max(IteratorClass itBegin, IteratorClass itEnd) {

	assert(itBegin != itEnd);

	IteratorClass result = itBegin;

	while (itBegin != itEnd) {
		if (*result < *itBegin)
			result = itBegin;

		++itBegin;
	}
	return result;
}



/// <summary>
/// 
/// </summary>
/// <typeparam name="IteratorClass"></typeparam>
/// <param name="it1"></param>
/// <param name="it2"></param>
/// 创建时间： 2024-07-02     最后一修改时间：2024-07-02
template<typename IteratorClass>
void Swap(IteratorClass it1, IteratorClass it2) {

	//std::cout << "===================================\n";
	//_pin(*it1);
	//_pin(*it2);

	auto tmp = *it1;  //如果*it2是 int& 则，tmp 的类型是int, 并不是int&。

	*it1 = *it2;
	*it2 = tmp;

	//_pin(*it1);
	//_pin(*it2);
	//std::cout << "===================================\n";
}


/// <summary>
/// 	lf::_DList<int> d4 = {1,2,3,6,5,4};
///		lf::sort_selection(d4.begin(), d4.end(), _SortOrder::s_Minmax);
///		_pcn(d4);  //输出：d4={1,2,3,4,5,6}
///		lf::sort_selection(d4.begin(), d4.end(), _SortOrder::s_Maxmin);
///		_pcn(d4); //输出：d4={6,5,4,3,2,1}
/// 
///		_string s2 = _t("_DListNodeIterator,abcd,efg");
///		_pcn(s2); //s2=_DListNodeIterator,abcd,efg
///		lf::sort_selection(s2.begin(), s2.end(), _SortOrder::s_Minmax);
///		_pcn(s2); //s2=,,DILN_aabcddeeefgioorrsttt
///		lf::sort_selection(s2.begin(), s2.end(), _SortOrder::s_Maxmin);
///		_pcn(s2); //s2=tttsrrooigfeeeddcbaa_NLID,,
/// </summary>
/// <typeparam name="IteratorClass"></typeparam>
/// <param name="itBegin"></param>
/// <param name="itEnd"></param>
/// <param name="so"></param>
/// 创建时间： 2024-07-01     最后一修改时间：2024-07-02（已测试）
template<typename IteratorClass>
void sort_selection(IteratorClass itBegin, IteratorClass itEnd, const bool& bMinMax = true)
{

	/*
		7 4 5 9 8 2 1
		1 4 5 9 8 2 7
		  2 5 9 8 4 7
			4 9 8 5 7
			  5 8 9 7
				7 9 8
				  8 9

		7 2 2 2 2 2 2
		2 7 2 2 2 2 2
		  2 7 2 2 2 2
			2 7 2 2 2
			  2 7 2 2
				2 7 2
				  2 7

		在 [0 , n-1] 中找出最小的放在第一位
		在 [1 , n-1] 中找出最小的放在第二位
		...


	*/

	if (bMinMax) {

		while (itBegin != itEnd) {
			//在[itBegin + 1, itEnd] 中找出最小值,与itBegin交换		 
			Swap(itBegin, Min(itBegin, itEnd));
			++itBegin;
		}
	}
	else {
		while (itBegin != itEnd) {
			//在[itBegin + 1, itEnd] 中找出最小值,与itBegin交换
			Swap(itBegin, Max(itBegin, itEnd));
			++itBegin;
		}
	}
}




/*****************************************************************************

								查找

顺序查找

二分查找

插值查找、

斐波那契查找

分块查找


哈希查找


树表查找
 ****************************************************************************/
template<typename IteratorType>
struct FindResult
{
	/// <summary>
	/// 如果没找到 Index == -1
	/// </summary>
	int Index;
	IteratorType Iter;

public:

	inline FindResult()
	{
		Index = -1;
	}

	inline FindResult(const FindResult& r)
	{
		Index = r.Index;
		Iter = r.Iter;
	}
};


/// <summary>
/// 顺序查找
/// 
/// 注意：
///		如果是向后查找，则返回的索引是以itFirst开始算来，第一个为 0，即itFirst为0。
///		如果是向前揸找，则返回的索引是以itLast开始算起，第一个，即itLast为0。
///		 
/// </summary>
/// <typeparam name="IteratorType"></typeparam>
/// <typeparam name="DataType"></typeparam>
/// <param name="itBegin"></param>
/// <param name="itEnd"></param>
/// <param name="tValue"></param>
/// <param name="bBackward"></param>
/// <returns></returns>
/// 创建时间： 2024-07-03     最后一修改时间：2024-07-03
template<typename IteratorType, typename DataType>
FindResult<IteratorType> find_sequential(IteratorType itFirst, IteratorType itLast,
	const DataType& tFindValue, const bool& bBackward = true)
{

	FindResult<IteratorType> fr;
	fr.Index = -1;

	int n = 0;

	
	if (bBackward) {  //向后
		while (true)
		{
			if (*itFirst == tFindValue) {
				fr.Index = n;
				fr.Iter = itFirst;
				break;
			}
			++n;
			++itFirst;
			if (itFirst == itLast) break;
		}
	}
	else {

		while (true)
		{
			if (*itLast == tFindValue) {
				fr.Index = n;
				fr.Iter = itLast;
				break;
			}
			++n;
			--itLast;
			if (itFirst == itLast) break;
		}

	}


	return fr;
}



/// <summary>
/// 集合类必须带有 begin() 和 end() 函数
/// 例子：
///		std::vector<int> v = { 1,2,3,23,435,4646,34 };
///		lf::_DList<int> d = { 1,2,3,23,435,4646,34 };
///		if (lf::IsExists(d, 23))
///		{
///		cout << "存在23.\n";
///		}
///		if (lf::IsExists(v, 55))
///		{
///			cout << "存在55.\n";
///		}
/// </summary>
/// <typeparam name="value_type"></typeparam>
/// <typeparam name="CollectionClass"></typeparam>
/// <param name="col"></param>
/// <param name="value"></param>
/// <returns></returns>
/// 创建时间： 2024-07-03     最后一修改时间：2024-07-03
template<typename CollectionClass, typename value_type = CollectionClass::value_type>
bool IsExists(const CollectionClass& col, const value_type& value)
{
	auto itbegin = col.begin();
	auto itend = col.end();

	while (itbegin != itend)
	{
		if (*itbegin == value)
			return true;

		++itbegin;
	}

	return false;
}


 
/// <summary>
/// 二分法查找有序表的通用算法（可查链表，数组，字符串...等等）
/// 例子：
///  vector<int> v;
///  find_binary(b.begin(),v.end(),3);  // Inde返回 (-1, *Iterator == ?)
/// 
///  vector<int> v = {3};
///  find_binary(b.begin(),v.end(),3);  // 返回  (Index == 0, *Iterator == 3)
///  
///  const char* sz = "abcdefgb";
///  auto f3 = lf::find_binary(sz, sz + 8, 'c');  //返回  (Index == 2, *Iterator == c)
/// </summary>
/// <typeparam name="IteratorType">迭代器类型</typeparam>
/// <typeparam name="value_type">值类型</typeparam>
/// <param name="itBegin">开始位置</param>
/// <param name="itEnd">结束位置</param>
/// <param name="vtFindValue">查找值</param>
/// <returns>返回索引与指向vtFindValue的迭代器</returns>
/// 创建时间： 2024-07-03     最后一修改时间：2024-07-04  (初步测试）
template<typename IteratorType,typename value_type = IteratorType::value_type>
FindResult<IteratorType> find_binary(const IteratorType& itBegin, 
	const IteratorType& itEnd, const value_type& vtFindValue)
{

	FindResult<IteratorType> fr;  

	auto beg = itBegin;
	auto end = itEnd;
	int nCount = end - beg;

	if (nCount == 0) return fr;


	if (*(itEnd-1) > *itBegin) {//从小到大排列

		auto mid = beg + nCount / 2;

		while (mid != itEnd){

			if(*mid == vtFindValue){
				fr.Iter = mid;
				fr.Index = mid - itBegin;

				return fr;
			}

			if (vtFindValue < *mid)
				end = mid;
			else
				beg = mid + 1;  //在mid之后查找

			mid = beg + (end - beg) / 2;   //新的中间点
		}	 

	}else{ //从大到小排列 
 
		auto mid = beg + nCount / 2;

		while (mid != itEnd) {

			if (*mid == vtFindValue) {
				fr.Iter = mid;
				fr.Index = mid - itBegin;

				return fr;
			}

			if (vtFindValue > *mid)
				end = mid;
			else
				beg = mid + 1;  //在mid之后查找

			mid = beg + (end - beg) / 2;   //新的中间点
		}
	}

	return fr;
}






_LF_END_

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

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

相关文章

土豆炒肉做法

土豆炒肉做法

菜单&#xff1a;土豆、葱、铁辣子、纯瘦肉、淀粉、生抽、酱油、刀、案板、十三香、盐巴、擦板 流程&#xff1a; 洗土豆&#xff0c;削皮&#xff0c;擦成条&#xff0c;用凉水过滤两遍淀粉&#xff0c;顺便放个燥里洗肉&#xff0c;切成条&#xff0c;按照生抽、酱油、淀粉、…
阅读更多...
react dangerouslySetInnerHTML将html字符串以变量方式插入页面，点击后出现编辑状态

react dangerouslySetInnerHTML将html字符串以变量方式插入页面，点击后出现编辑状态

1.插入变量 出现以下编辑状态 2.解决 给展示富文本的标签添加css样式 pointerEvents: none
阅读更多...
JAVA之（方法的重载与重写、this关键字、super关键字）

JAVA之（方法的重载与重写、this关键字、super关键字）

方法的重载与重写 一、方法的重载与重写1、回顾方法的定义2、重载的概念3、重写 二、this关键字1、何为this方法2、使用方法&#xff08;1&#xff09;在构造方法中指构造器所创建的新对象&#xff08;2&#xff09; 方法中指调用该方法的对象&#xff08;3&#xff09; 在类本…
阅读更多...
【植物大战僵尸杂交版】获取+存档插件

【植物大战僵尸杂交版】获取+存档插件

文章目录 一、还记得《植物大战僵尸》吗&#xff1f;二、在哪下载&#xff0c;怎么安装&#xff1f;三、杂交版如何进行存档功能概述 一、还记得《植物大战僵尸》吗&#xff1f; 最近&#xff0c;一款曾经在15年前风靡一时的经典游戏《植物大战僵尸》似乎迎来了它的"文艺复…
阅读更多...
自用款 复制粘贴工具 Paste macOS电脑适配

自用款 复制粘贴工具 Paste macOS电脑适配

Paste是一款专为Mac和iOS用户设计的剪贴板管理工具&#xff0c;它提供了强大的剪贴板增强功能。Paste能够实时记录用户复制和剪切的内容&#xff0c;包括文本、图片、链接等多种数据类型&#xff0c;并形成一个可视化的剪贴板历史记录&#xff0c;方便用户随时访问和检索。此外…
阅读更多...
嵌入式鸿蒙系统openharmony编译方法详解

嵌入式鸿蒙系统openharmony编译方法详解

大家好，时光如梭，今天主要给大家分享一下，鸿蒙系统的使用方法，以及源码该如何编译，其中要注意的细节有哪些？ 第一：OpenHarmony系统简介 OpenHarmony 是由开放原子开源基金会（OpenAtom Foundation）孵化及运营的开源项目， 目标是面向全场景、全连接、全智能时代，基于…
阅读更多...
vite简介

vite简介

vite是新一代前端构建工具&#xff0c;vite具有优势如下&#xff1a; 轻量快速的热重载&#xff08;HMR&#xff09;&#xff0c;能实现快速的服务启动。对TypeScript、JSX、CSS等支持开箱即用。真正的按需编译&#xff0c;不再等待整个应用编译完成。webpack构建与vite构建对…
阅读更多...
html+css+JavaScript 实现两个输入框的反转动画

html+css+JavaScript 实现两个输入框的反转动画

开发时遇到了一个输入框交换的动画 做完之后觉得页面上加些许过渡或动画&#xff0c;其变化虽小&#xff0c;却能极大的提升页面质感&#xff0c;给人一种顺畅、丝滑的视觉体验。它的实现过程主要是通过css中的transition和animation来实现的。平时在开发的时候增加一些动画效…
阅读更多...
PYTHON自学笔记（一）vscode配置

PYTHON自学笔记（一）vscode配置

安装python 自行官网下载 安装vscode 自行官网下载 环境变量设置 把python和scripts的文件路径&#xff0c;添加到环境变量的path中&#xff0c;如图&#xff1a; 此项不弄&#xff0c;在命令行模式中系统不会认为你装了python和pip&#xff0c;你的输入相关命令shell不会…
阅读更多...
Python实现ABC人工蜂群优化算法优化随机森林回归模型(RandomForestRegressor算法)项目实战

Python实现ABC人工蜂群优化算法优化随机森林回归模型(RandomForestRegressor算法)项目实战

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档视频讲解&#xff09;&#xff0c;如需数据代码文档视频讲解可以直接到文章最后获取。 1.项目背景 人工蜂群算法(Artificial Bee Colony, ABC)是由Karaboga于2005年提出的一种新颖的基于群智能的全局优化…
阅读更多...
Day59 动态规划part12

Day59 动态规划part12

LC115不同的子序列&#xff08;未掌握&#xff09; 递推公式与LC392类似&#xff0c;但是初始化略有不同 LC392的dp数组含义为相同字符个数而本体的dp数组含义为出现的次数&#xff0c;因此dp[i][0]1 两种情况 s[i-1]t[j-1] dp[i][j] dp[i-1][j-1]dp[i][j] dp[i-1][j] s[…
阅读更多...
python等级考试——一级知识点汇总（turtle画图部分）

python等级考试——一级知识点汇总（turtle画图部分）

&#xff08;本篇文章是针对中国电子学会青少年编程等级考试的&#xff0c;适合初学者以及青少年编程学习者&#xff09; 本篇文章主要介绍turtle画图部分&#xff0c;其他一级考试知识点请移步下方链接&#xff1a;python等级考试——一级知识点汇总&#xff08;不包含turtle…
阅读更多...
科大讯飞-群聊对话角色要素提取：不微调范式模拟官网评分

科大讯飞-群聊对话角色要素提取：不微调范式模拟官网评分

不微调范式模拟官网评分 step1: 模型api配置及加载测试step2: 数据加载与数据分析&#xff1a;测试集分析:step3: prompt设计:step4 :大模型推理&#xff1a;step 5: 结果评分测试&#xff1a;评分细则&#xff1a;评估指标 参考&#xff1a; 比赛说明&#xff1a; #AI夏令营 #…
阅读更多...
uniapp如何隐藏默认的页面头部导航栏，uniapp开发小程序如何隐藏默认的页面头部导航栏

uniapp如何隐藏默认的页面头部导航栏，uniapp开发小程序如何隐藏默认的页面头部导航栏

uniapp如何隐藏默认的页面头部导航栏 隐藏后 在pages.json文件中插入 在uni-app中&#xff0c;设置navigationStyle为custom来自定义导航栏&#xff0c;可以隐藏默认的头部了。 {"path": "pages/index/index","name": "index",&qu…
阅读更多...
【SpringCloud应用框架】Nacos集群架构说明

【SpringCloud应用框架】Nacos集群架构说明

第六章 Spring Cloud Alibaba Nacos之集群架构说明 文章目录 前言一、Nacos支持三种部署模式二、集群部署说明三、预备环境 前言 到目前为止&#xff0c;已经完成了对Nacos的一些基本使用和配置&#xff0c;接下来还需要了解一个非常重要的点&#xff0c;就是Nacos的集群相关的…
阅读更多...
【MySQL基础篇】多表查询

【MySQL基础篇】多表查询

1、多表关系 概述&#xff1a;项目开发中&#xff0c;在进行数据库表结构操作设计时&#xff0c;会根据业务需求及业务模板之间的关系&#xff0c;分析并设计表结构&#xff0c;由于业务之间相互关联&#xff0c;所以各个表结构之间也存在着各种联系&#xff0c;基本上分为三种…
阅读更多...
关于新装Centos7无法使用yum下载的解决办法

关于新装Centos7无法使用yum下载的解决办法

起因 之前也写了一篇类似的文章&#xff0c;但感觉有漏洞&#xff0c;这次想直接把漏洞补齐。 问题描述 在我们新装的Centos7中&#xff0c;如果想要用C编程&#xff0c;那就必须要用到yum下载&#xff0c;但是&#xff0c;很多新手&#xff0c;包括我使用yum下载就会遇到一…
阅读更多...
WEB05Web开发HTMLCSS

WEB05Web开发HTMLCSS

Web前端开发 什么是 Web &#xff1f; Web&#xff1a;全球广域网&#xff0c;也称为万维网(www World Wide Web)&#xff0c;能够通过浏览器访问的网站。 Web 网站的工作流程 W3C 万维网联盟&#xff08; World Wide Web Consortium &#xff09;&#xff0c;创建于1994年1…
阅读更多...
PD虚拟机不能复制Mac的文件怎么回事 PD虚拟机不能复制Mac的文件怎么办 Parallels Desktop怎么用

PD虚拟机不能复制Mac的文件怎么回事 PD虚拟机不能复制Mac的文件怎么办 Parallels Desktop怎么用

PD虚拟机不仅能提供跨系统协作的服务&#xff0c;还能进行虚拟机系统与原生系统间的文件共享、文本复制、文件复制等操作&#xff0c;让系统间的资源可以科学利用。但在实际操作过程中&#xff0c;PD虚拟机不能复制Mac的文件怎么回事&#xff1f;PD虚拟机不能复制Mac的文件怎么…
阅读更多...
甘肃黄米粽子：香甜软糯的塞上美食

甘肃黄米粽子：香甜软糯的塞上美食

甘肃黄米粽子是甘肃地区具有特色的传统美食。黄米粽子选用优质的黄米作为主要原料&#xff0c;黄米相较于糯米&#xff0c;有着独特的谷物香气和口感。在制作过程中&#xff0c;将黄米浸泡一段时间&#xff0c;使其充分吸收水分&#xff0c;变得饱满。馅料方面&#xff0c;通常…
阅读更多...
最新文章

Copyright @ 2022~2023