数据结构篇十：红黑树

文章目录

  • 前言
  • 1. 红黑树的概念
  • 2. 红黑树的性质
  • 3. 红黑树节点的定义
  • 4. 红黑树的插入
    • 4.1 情况一： cur为红，p为红，g为黑，u存在且为红
    • 4.2 情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑。
      • 4.2.1 u不存在
      • 4.2.2 u存在且为黑
    • 4.3 情况三
  • 5. 红黑树的验证
    • 5.1 检测其是否满足二叉搜索树
    • 5.2 检测其是否满足红黑树的性质
  • 6. 红黑树的删除
  • 7. 红黑树与AVL树的比较
  • 8. 代码实现
    • 8.1 RBTree.h
    • 8.2 Test.cpp
  • 9. 总结

前言

  红黑树是解决单支树问题的另一种解决方法，它相比较AVL树减少了调整的次数，AVL是一格绝对平衡的树，而红黑树只要求最长路径不超过最短路径的二倍，相比较大大减少了调整次数。在实际中更多的也是使用红黑树，就比如后面的map和set，我们就是以红黑树进行封装的。

1. 红黑树的概念

  红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。
在这里插入图片描述

2. 红黑树的性质

  1. 每个结点不是红色就是黑色 。
  2. 根节点是黑色的 。
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 。
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 。
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)。

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

  按照上面的性质，最短路径应该是全为黑色节点，而在每条路径黑色节点数量相同并且不难出现连续红色节点的的情况下，最长路径应该是一红一黑，红黑相间的方式，所以最长路径是不会超过最短路径的二倍的，

3. 红黑树节点的定义

enum Colour
{
	RED,
	BLACK
};

template<class K,class V>
struct RBTreeNode
{
	RBTreeNode<K,V>* _left;
	RBTreeNode<K,V>* _right;
	RBTreeNode<K,V>* _parent;
	pair<K, V> _kv;

	Colour _col;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_col(RED)
	{}
};

  思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？

  这是因为有一个性质是要求每条路径的黑色节点数目相同，如果我们将新插入节点的颜色默认给成黑色，就会影响全部路径，那么就会在全局破坏这一性质。而如果我们将节点颜色给成红色，我们可能会破坏不能出现连续的红色节点这一性质，也只是影响了这一条路径，也仅仅只是在局部破坏了红黑树的性质，相比较前一种更容易进行处理。

4. 红黑树的插入

  红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

  1. 按照二叉搜索的树规则插入新节点
bool insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		
		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		
		//调整
		…………
  • 检测新节点插入后，红黑树的性质是否造到破坏
      因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论。（约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点）

4.1 情况一： cur为红，p为红，g为黑，u存在且为红

  • 情况一: cur为红，p为红，g为黑，u存在且为红

在这里插入图片描述
  解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

4.2 情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑。

  • 情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑。
    在这里插入图片描述

  • p为g的左孩子，cur为p的左孩子，则进行右单旋转。

  • p为g的右孩子，cur为p的右孩子，则进行左单旋转。

  • p、g变色–p变黑，g变红。

4.2.1 u不存在

  光看上面的图有人可能会不理解为什么还需要旋转，我们来单独拿出一个例子：
在这里插入图片描述
  当u不存在时，它是违反最长路径超过最短路径的二倍的，因此需要先进行旋转再变色。

4.2.2 u存在且为黑

  先新插入一个节点，目前是情况一，直接变色处理就可以了。
在这里插入图片描述
  处理完后就是此时所讲的情况二： cur为红，p为红，g为黑，u存在且为黑。我们发现此时违反了最长路径不能超过最短路径的二倍，因此需要先旋转，再变色。
在这里插入图片描述
  此时再回归到我们一开始的图解，上下图结合，也就是cur的孩子就是下图中的a：
在这里插入图片描述
  这样就可以完美的解决问题了。

4.3 情况三

  • 情况三: cur为红，p为红，g为黑，u不存在/u存在且为黑。

在这里插入图片描述

  • p为g的左孩子，cur为p的右孩子，则针对p做左单旋转。
  • p为g的右孩子，cur为p的左孩子，则针对p做右单旋转。
  • 则转换成了情况2。

  情况三的原理与情况二一致，只不过是换成了双旋的问题。（记忆窍门：单旋是的情况是一条直线，双旋的情况是一条折线）。
在这里插入图片描述

  情况二就是新插入节点是属于直线的情况，只需要旋转一次，情况三是新插入节点属于折线的情况，需要旋转一次变成情况二，再旋转一次解决问题，实际上也就是双旋。（还有一个记忆敲门：左边高往右边旋，右边高往左边旋）
  更具体的情况大家可以像我讲解情况二那样画出详细的图来理解。
  需要格外注意到最后要将根节点改为黑色， 因为在调整过程中有可能将根节点改为红色。
  左右子树的旋转在上一篇AVL树中有纤细的讲解，不懂的小伙伴可以去阅读。

5. 红黑树的验证

  红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)。
  2. 检测其是否满足红黑树的性质。

5.1 检测其是否满足二叉搜索树

  写一个中序遍历就可以了。

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

5.2 检测其是否满足红黑树的性质

  最主要的是检验每条路径的黑色节点数目是否一样，是否有连续的红色节点。
  对于检验每条路径的黑色节点数目是否一样，我们可以先遍历一条路径记录黑色节点的数目，再通过递归遍历每条路径记录黑色节点的数目，当遍历到nullptr时说明一条路径遍历完了，再与我们一开始记录的黑色节点数目进行比较，相同就返回true，不同就返回false。（注意：传参时需要传值传递，不能引用传递，否则在统计黑色节点数目时，左子树的黑色节点数目会累加到右子树上）
  对于是否有连续的红色节点，在递归时对于一个节点，我们如果是拿这个节点与它的孩子节点比较会很麻烦，因为要比较两个。我们不如换个思路，与该节点的父亲节点比较，如果该节点为红色，它的父亲也为红色，就返回false。

bool Check(Node* root, int blackNum, const int refVal)
{
	if (root == nullptr)
	{
		//cout << balcknum << endl;
		if (blackNum != refVal)
		{
			cout << "存在黑色节点数量不相等的路径" << endl;
			return false;
		}

		return true;
	}

	if (root->_col == RED && root->_parent->_col == RED)
	{
		cout << "有连续的红色节点" << endl;

		return false;
	}

	if (root->_col == BLACK)
	{
		++blackNum;
	}
	
	return Check(root->_left, blackNum, refVal)
		&& Check(root->_right, blackNum, refVal);
}

bool IsBalance()
{
	//树为空认为符合红黑树的性质
	if (_root == nullptr)
		return true;
	
	//根节点必须为黑
	if (_root->_col == RED)
		return false;

	//记录黑色节点数目
	int refVal = 0;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_col == BLACK)
			refVal++;

		cur = cur->_left;
	}

	int blackNum = 0;

	return Check(_root,blackNum,refVal);
}

6. 红黑树的删除

  红黑树的删除本节不做讲解，有兴趣的小伙伴可参考：《算法导论》或者《STL源码剖析》。

7. 红黑树与AVL树的比较

  红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O( l o g 2 N log_2 N log2​N)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

8. 代码实现

8.1 RBTree.h

#pragma once
#include<iostream>
#include<vector>
using namespace std;

enum Colour
{
	RED,
	BLACK
};

template<class K,class V>
struct RBTreeNode
{
	RBTreeNode<K,V>* _left;
	RBTreeNode<K,V>* _right;
	RBTreeNode<K,V>* _parent;
	pair<K, V> _kv;

	Colour _col;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_col(RED)
	{}
};

template<class K,class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	bool insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		
		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_col == RED)
		{
			Node* uncle = nullptr;
			Node* grandparent = parent->_parent;

			if (parent == grandparent->_left)
			{
				uncle = grandparent->_right;
			}
			else
			{
				uncle = grandparent->_left;
			}

			//叔叔存在且为红
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandparent->_col = RED;

				cur = grandparent;
				parent = cur->_parent;
			}
			//叔叔不存在或者存在且为黑
			else
			{
				if (parent == grandparent->_left && cur == parent->_left)
				{
					//右旋
					RotateR(grandparent);
					parent->_col = BLACK;
					grandparent->_col = RED;
				}
				else if (parent == grandparent->_left && cur == parent->_right)
				{
					//先左旋，再右旋
					RotateL(parent);
					RotateR(grandparent);
					cur->_col = BLACK;
					grandparent->_col = RED;
				}
				else if (parent == grandparent->_right && cur == parent->_right)
				{
					//左旋
					RotateL(grandparent);
					parent->_col = BLACK;
					grandparent->_col = RED;
				}
				else
				{
					//先右旋，再左旋
					RotateR(parent);
					RotateL(grandparent);
					cur->_col = BLACK;
					grandparent->_col = RED;
				}
				break;
			}
		}
		_root->_col = BLACK;
		return true;
	}

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* ppNode = parent->_parent;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			subR->_parent = nullptr;
			_root = subR;
		}
		else
		{
			if (parent == ppNode->_left)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}

	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* ppNode = parent->_parent;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			subL->_parent = nullptr;
			_root = subL;
		}
		else
		{
			if (parent == ppNode->_left)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}


	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	bool Check(Node* root, int blackNum, const int refVal)
	{
		if (root == nullptr)
		{
			//cout << balcknum << endl;
			if (blackNum != refVal)
			{
				cout << "存在黑色节点数量不相等的路径" << endl;
				return false;
			}

			return true;
		}

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "有连续的红色节点" << endl;

			return false;
		}

		if (root->_col == BLACK)
		{
			++blackNum;
		}

		/*return Check(_root->_left, blackNum, refVal)
			&& Check(_root->_right, blackNum, refVal);*/

		return Check(root->_left, blackNum, refVal)
			&& Check(root->_right, blackNum, refVal);
	}

	bool IsBalance()
	{
		if (_root == nullptr)
			return true;

		if (_root->_col == RED)
			return false;

		int refVal = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				refVal++;

			cur = cur->_left;
		}

		int blackNum = 0;

		return Check(_root,blackNum,refVal);
	}

private:
	Node* _root = nullptr;
};

8.2 Test.cpp

int main()
{
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	RBTree<int, int> t;
	for (auto e : a)
	{
		t.insert(make_pair(e, e));
	}
	t.InOrder();

	//cout << t.IsBalance() << endl;

	return 0;
}

int main()
{
	const int N = 1000;
	vector<int> v;
	v.reserve(N);
	//srand(time(0));

	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);
	}

	//size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		if (e == 506)
		{
			int i = 0;
		}
		t.insert(make_pair(e, e));
		cout << "insert:" << e << "->" << t.IsBalance() << endl;
	}
	//size_t end2 = clock();

	//cout << "Insert:" << end2 - begin2 << endl;

	cout << t.IsBalance() << endl;
	return 0;
}

9. 总结

  红黑树比AVL树更加复杂一些，关于二叉树这部分的内容我建议还是多多画图来加深自己的理解，忌讳眼高手低。希望大家都能有所收获。
  如果大家发现有什么错误的地方，可以私信或者评论区指出喔。我会继续深入学习C++，希望能与大家共同进步，那么本期就到此结束，让我们下期再见！！觉得不错可以点个赞以示鼓励！！

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

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

相关文章

C++：内存管理|new和delete

C++：内存管理|new和delete

创作不易&#xff0c;感谢三连支持&#xff01; 一、内存分布 为什么需要内存管理呢&#xff1f;&#xff1f;因为我们在程序的运行过程中会需要各种各样的数据&#xff0c;而我们根据数据的不同存储在不同的区域里面&#xff0c;是为了更高效地处理数据。而C语言相比Java来说…
阅读更多...
Docker与虚拟机比较

Docker与虚拟机比较

在对比Docker和虚拟机前&#xff0c;先简单了解下虚拟化&#xff0c;明确Docker和虚拟机分别对应的虚拟化级别&#xff0c;然后对Docker和虚拟机进行比较。需要注意的是&#xff0c;Docker和虚拟机并没有什么可比性&#xff0c;而是Docker使用的容器技术和虚拟机使用的虚拟化技…
阅读更多...
Linux 基础之 sar 工具详解

Linux 基础之 sar 工具详解

文章目录 一、前言二、配置说明三、使用说明&#xff08;一&#xff09;sar语法&#xff08;二&#xff09;sar选项&#xff08;三&#xff09;示例示例1示例2示例3示例4示例5示例6示例7示例8示例9示例10其他示例11其他示例12用于排查性能常用的命令 一、前言 sar(System Acti…
阅读更多...
【无标题】TMGM官网平台切尔西足球俱乐部合作

【无标题】TMGM官网平台切尔西足球俱乐部合作

TMGM作为一家在三大洲均设有办事处的行业领导者&#xff0c;TMGM 被视为可靠的差价合约交易提供商&#xff0c;其重点是监管合规、技术创新与他联系➕&#x1f6f0;️TMGM818卓越的客户服务。 切尔西足球俱乐部在亚太地区拥有庞大的球迷群体&#xff0c;并在该地区建立了多种亚…
阅读更多...
Java中==与equals()的区别

Java中==与equals()的区别

关于“对比”类型的面试题，建议回答时包括： 多个对比项有什么相同/相似之处 多个对比项的区别 在应用中应该如何选取 可能的话，加入一些扩展。 变量与对象是2个不同的概念 Object a = new Object(); 以上代码中的a就是变量，在内存中实际存在的数据就是对象。 所有引…
阅读更多...
五大跨平台桌面应用开发框架：Electron、Tauri、Flutter等

五大跨平台桌面应用开发框架：Electron、Tauri、Flutter等

hello&#xff0c;我是贝格前端工场&#xff0c;本次介绍跨平台开发的框架&#xff0c;欢迎大家评论、点赞。 一、什么是跨平台桌面应用开发框架 跨平台桌面应用开发框架是一种工具或框架&#xff0c;它允许开发者使用一种统一的代码库或语言来创建能够在多个操作系统上运行的…
阅读更多...
使用 frp 实现 windows 远程

使用 frp 实现 windows 远程

前提条件&#xff1a; 拥有一台公网 ip 的服务器&#xff1b; 被远程控制的 windows 系统为专业版&#xff08;家庭版的其它方式没有尝试过&#xff09;&#xff1b; frp 下载包及使用说明 frp release 包的下载网址&#xff1a;https://github.com/fatedier/frp/releases 中…
阅读更多...
人工智能基础——模型部分：模型介绍、模型训练和模型微调 ！！

人工智能基础——模型部分：模型介绍、模型训练和模型微调 ！！

文章目录 前言 一、什么是模型 二、什么是模型训练 三、什么是模型微调 前言 本文将从什么是模型&#xff1f;什么是模型训练&#xff1f;什么是模型微调&#xff1f;三个问题&#xff0c;来展开介绍人工智能基础的模型部分。 模型族谱 一、什么是模型 模型是一个函数&#x…
阅读更多...
set和multiset

set和multiset

1. set基本概念 简介&#xff1a; 所有元素都会在插入时自动被排序 本质&#xff1a; set/multiset属于关联式容器&#xff0c;底层结构是用二叉树实现。 set和multiset区别&#xff1a; set不允许容器中有重复的元素 multiset允许容器中有重复的元素 2. set构造和赋值 功能描述…
阅读更多...
MySql安全加固：配置不同用户不同账号禁止使用旧密码禁止MySql进程管理员权限

MySql安全加固：配置不同用户不同账号禁止使用旧密码禁止MySql进程管理员权限

MySql安全加固&#xff1a;配置不同用户不同账号&禁止使用旧密码&禁止MySql进程管理员权限 1.1 检查是否配置不同用户不同账号1.2 检查是否禁止使用旧密码1.3 禁止MySql进程管理员权限 &#x1f496;The Begin&#x1f496;点点关注&#xff0c;收藏不迷路&#x1f496…
阅读更多...
uview2中上传文件和若依前后端分离配合的代码

uview2中上传文件和若依前后端分离配合的代码

uview2中的上传文件需要配合着自己后端的上传的代码 uview2 代码&#xff1a; uploadFilePromise(url) {return new Promise((resolve, reject) > {// 后续自己封装let a uni.uploadFile({//自己的请求路径url: that.$baseURL /uploadAvater, //上传的文件filePath: tha…
阅读更多...
4.1.CVAT——目标检测的标注详细步骤

4.1.CVAT——目标检测的标注详细步骤

文章目录 1. 进入任务1. 创建任务2. 已创建的task3. 进入标注界面 2. 选择标注类型2.1 选择标注类型2.2 进行标注2.3 遮挡 2.快捷键3.导出标注结果 1. 进入任务 登录后会看到如下图界面&#xff0c;CVAT的标注最小单位是Task&#xff0c;每个Task为一个标注任务。点击Task按钮…
阅读更多...
数据安全无忧，SQL Server 2014数据库定时备份解密

数据安全无忧，SQL Server 2014数据库定时备份解密

一、为什么要执行数据库定时备份 在SQL Server数据库中&#xff0c;完整备份和差异备份是常见的备份策略组合。它们的目的是提供数据的备份和恢复能力&#xff0c;以确保数据的可靠性和可恢复性。 完整备份&#xff08;Full Backup&#xff09; 完整备份是对整个数据库进行备份…
阅读更多...
为什么要在业务系统中引入大宽表？

为什么要在业务系统中引入大宽表？

在高度系统化驱动的业务中&#xff0c;查看业务报表已经是一个很常见的需求了。在分工非常明确的大型企业里&#xff0c;往往有专门的数据分析团队 BI 或者数据开发团队&#xff0c;他们能够胜任此类需求&#xff08;但也未必是轻松的&#xff0c;或者说高效的&#xff09;。 …
阅读更多...
‘conda‘ 不是内部或外部命令，也不是可运行的程序 或批处理文件

‘conda‘ 不是内部或外部命令，也不是可运行的程序 或批处理文件

如果你在运行 conda 命令时收到了 ‘conda’ 不是内部或外部命令&#xff0c;也不是可运行的程序或批处理文件。 的错误消息&#xff0c;这可能意味着 Anaconda 并没有正确地添加到你的系统路径中。 1.你可以尝试手动添加 Anaconda 到系统路径中。以下是在 Windows 系统上添加…
阅读更多...
前端按钮动画

前端按钮动画

效果示例 代码示例 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content"IEedge"><meta name"viewport" content"widthdevic…
阅读更多...
自测-2 素数对猜想

自测-2 素数对猜想

文章预览&#xff1a; 题目算法 题目 算法 本题用python写不能用一般的算法去求会超时&#xff0c;应该采用欧拉素数筛选法去求&#xff0c;算法复杂度为O&#xff08;n&#xff09;比其他的算法优秀的多&#xff0c; 算法思想: &#xff08;1&#xff09;我们安排一个数组或者…
阅读更多...
AJAX 学习笔记（Day1）

AJAX 学习笔记（Day1）

「写在前面」 本文为黑马程序员 AJAX 教程的学习笔记。本着自己学习、分享他人的态度&#xff0c;分享学习笔记&#xff0c;希望能对大家有所帮助。 目录 0 课程介绍 1 AJAX 入门 1.1 AJAX 概念和 axios 使用 1.2 认识 URL 1.3 URL 查询参数 1.4 常用请求方法和数据提交 1.5 HT…
阅读更多...
华为笔记本自带windows11如何改为win10

华为笔记本自带windows11如何改为win10

目录 一、前言 二、遇到问题 三、问题解决 一、前言 新购买的华为笔记本电脑自带windows11系统&#xff0c;虽然是正版系统&#xff0c;但还是希望能重新装Windows10版本。一是我已经习惯此系统&#xff0c;二是该系统上运行的开发工具比较稳定。 二、遇到问题 说干就干&…
阅读更多...
idea,pycharm等的ai assistant已成功激活，可以提高写代码的效率了

idea,pycharm等的ai assistant已成功激活，可以提高写代码的效率了

ai assistant成功激活了&#xff0c;可以提高写代码的效率了 https://web.52shizhan.cn/activate https://web.52shizhan.cn/activity/ai-assistant 你不妨也试试 激活成功后如图
阅读更多...
最新文章

Copyright @ 2022~2023