【C++进阶】：红黑树

news2024/11/29 4:34:45

红黑树

  • 一.红黑树简单实现
    • 1.性质
    • 二.更新颜色
      • 1.情况一
      • 2.情况二
      • 3.情况三
    • 3.完整代码(代码有注释，稍微画图很容易理解,旋转部分可以看我的AVL树博客)
  • 二.map和set
    • 1.基本实现
    • 2.迭代器

本篇的前置条件是AVL树的旋转和搜索树，如果不了解可以看看我的AVL树博客

一.红黑树简单实现

1.性质

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

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

创建节点

在这里插入图片描述

在这里插入图片描述

二.更新颜色

1.情况一

插入一个节点，它的父亲是红色的并且它有叔叔且叔叔也是红色的。

在这里插入图片描述

2.情况二

如果叔叔不存在

在这里插入图片描述
此时单纯的变色是无法解决问题的，需要进行旋转，在此情况是右旋。

在这里插入图片描述

3.情况三

叔叔存在且为黑，注意此时插入的点是在最下面，cur经过上面的转变后到达图示的位置。

在这里插入图片描述

在这里插入图片描述

3.完整代码(代码有注释，稍微画图很容易理解,旋转部分可以看我的AVL树博客)

测试

#include"RBTree.h"
#include<vector>

int main()
{
	RBTree<int, int> t;
	srand(time(0));
	vector<int>a;
	for (int i = 0; i < 100; i++)
	{
		int x = rand();
		a.push_back(x);
	}
	
	for (auto x : a)
		t.Insert(make_pair(x, x));
	cout << t.IsBalance() << endl;
	return 0;
}

树

#include<iostream>
#include<assert.h>
using namespace std;



enum Color
{
	RED,
	BLACK
};

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

	RBTreeNode(const pair<K,V>& kv)//初始化节点
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_col(RED)
	{}

	Color _col;
};


template<class K,class V>
class RBTree
{
public:
	typedef RBTreeNode<K, V> Node;

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;//根为黑色
			return true;
		}

		Node* parent = _root;
		Node* cur = _root;
		//一般的搜索二叉树插入
		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);
		cur->_parent = parent;
		
		if (parent->_kv > kv) parent->_left = cur;
		else parent->_right = cur;

		//进行颜色更新
		while (parent && parent->_col == RED)
		{
			Node* grandparent = parent->_parent;
			Node* uncle;
			//找到叔叔
			if (grandparent->_left == parent)
				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
			{
				//parent是左，cur是左，进行右单旋
				if (grandparent->_left == parent && parent->_left == cur)
				{
					RotateR(grandparent);
					grandparent->_col = RED;
					parent->_col = BLACK;
				}
				//parent是左，cur是右，进行左右旋
				else if (grandparent->_left == parent && parent->_right == cur)
				{
					RotateL(parent);
					RotateR(grandparent);

					cur->_col = BLACK;
					grandparent->_col = RED;
				}
				//parent是右,cur是右,进行左单旋
				else if (grandparent->_right == parent && parent->_right == cur)
				{
					RotateL(grandparent);

					grandparent->_col = RED;
					parent->_col = BLACK;
				}
				//parent是右，cur是左,进行右左旋
				else
				{
					RotateR(parent);
					RotateL(grandparent);

					cur->_col = BLACK;
					grandparent->_col = RED;
				}
			}
		}
		_root->_col = BLACK;
	}
	//旋转函数
	void RotateL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;
		Node* ppnode = parent->_parent;//记录父节点的父节点

		//父节点的右孩子变成curleft
		parent->_right = curleft;
		if (curleft)//细节注意curleft为空时不能操作
			curleft->_parent = parent;
		//父节点变为cur的左孩子
		cur->_left = parent;
		parent->_parent = cur;

		//如果原来父节点是根节点
		if (parent == _root)
		{
			_root = cur;
			cur->_parent = nullptr;
		}
		else//如果不是根节点判断它应该是左儿子还是右儿子
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				ppnode->_right = cur;

			}
			cur->_parent = ppnode;
		}
	}
	void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;
		Node* pphead = parent->_parent;

		//父节点到cur右边
		cur->_right = parent;
		parent->_parent = cur;
		//父节点的左孩子变成curright
		parent->_left = curright;
		if (curright)
			curright->_parent = parent;
		//cur的父节点变为原来父节点的父节点
		if (pphead)//如果不是根节点
		{
			if (pphead->_left == parent)
				pphead->_left = cur;
			else
				pphead->_right = cur;
			cur->_parent = pphead;
		}
		else
		{
			_root = cur;
			cur->_parent = nullptr;
		}
	}
	void RotateRL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		RotateR(parent->_right);
		RotateL(parent);
	}
	void RotateLR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;

		RotateL(parent->_left);
		RotateR(parent);
	}


	//测试是否出问题
	bool IsBalance()
	{
		return IsBalance(_root);
	}
	bool IsBalance(Node* root)
	{
		//根是否为黑色
		if (_root->_col != BLACK)
		{
			cout << "根不是红色"<<endl;
			return false;
		}

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

		//判断是否有两个连续的红色和每条路径的黑色是否相同
		return CheckColor(_root,blackcheck,0);
	}

	bool CheckColor(Node*root,int blackcheck,int blacknum)
	{
		if (root == nullptr)
		{
			//检查是否每条路径的黑色相同
			if (blackcheck != blacknum)
			{
				cout << "路径上黑色个数不同" << ' ';
				return false;
			}
			return true;
		}

		//判断是否有两个连续的红色
		Node* parent = root->_parent;
		if (root->_col == RED)
		{
			if (parent && parent->_col == RED)
			{
				cout << "有连续的红色" << ' ';
				return false;
			}
		}
		if (root->_col == BLACK) blacknum++;

		return CheckColor(root->_left, blackcheck, blacknum)
			&& CheckColor(root->_right, blackcheck, blacknum);
	}
private:
	Node* _root = nullptr;
};

二.map和set

1.基本实现

map和set虽然功能不同，但在库里都是使用红黑树实现的，接下来对红黑树的代码进行改造。在库里，set和map走的是泛型，也就是map和set可以使用同一份红黑树代码。

对红黑树进行泛化处理，方便之后传参

在这里插入图片描述

这里有一个问题：对于data，如果是set那么我们可以直接比较，但如果是map呢？map的T是一个pair，我们是不能直接比较的，为了解决这个问题，我们可以使用仿函数（如果不了解可以看看我的仿函数这篇博客）。

map里返回pair的firist
在这里插入图片描述

set为了保持一致，直接返回key
在这里插入图片描述

在树里创建一个对象，用该对象的规则进行比较
在这里插入图片描述

分别对map和set加入插入操作

在这里插入图片描述

在这里插入图片描述

2.迭代器

首先需要明确迭代器的功能，就是能够将整棵树进行中序遍历。

在这里插入图片描述

我们需要++，*，–，!=等操作。对于++操作，我们需要进行中序遍历。

在这里插入图片描述

在这里插入图片描述

其他一些小功能就不细说，下面是完整代码

RBTree.h

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

enum Colour
{
	RED,
	BLACK
};

template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	
	T _data;
	Colour _col;

	RBTreeNode(const T& data)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(data)
		,_col(RED)
	{}
};

template<class T>
struct __TreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __TreeIterator<T> Self;
	Node* _node;

	__TreeIterator(Node* node)
		:_node(node)
	{}

	T& operator*()
	{
		return _node->_data;
	}

	T* operator->()
	{
		return &_node->_data;
	}

	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
	Self& operator++()
	{
		if (_node->_right)
		{
			// 右树的最左节点(最小节点)
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}

			_node = subLeft;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			// 找孩子是父亲左的那个祖先节点，就是下一个要访问的节点
			while (parent)
			{
				if (cur == parent->_left)
				{
					break;
				}
				else
				{
					cur = cur->_parent;
					parent = parent->_parent;
				}
			}

			_node = parent;
		}

		return *this;
	}
};

// set->RBTree<K, K, SetKeyOfT> _t;
// map->RBTree<K, pair<K, V>, MapKeyOfT> _t;

template<class K, class T, class KeyOfT>
struct RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef __TreeIterator<T> iterator;
	// const_iterator

	iterator begin()
	{
		Node* leftMin = _root;
		while (leftMin && leftMin->_left)
		{
			leftMin = leftMin->_left;
		}

		return iterator(leftMin);
	}

	iterator end()
	{
		return iterator(nullptr);
	}


	Node* Find(const K& key)
	{
		Node* cur = _root;
		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_data) < key)
			{
				cur = cur->_right;
			}
			else if (kot(cur->_data) > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	bool Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;

		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(data);
		cur->_col = RED;

		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				// u存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else // u不存在 或 存在且为黑
				{
					if (cur == parent->_left)
					{
						//     g
						//   p
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g
						//   p
						//		c
						RotateL(parent);
						RotateR(grandfather);

						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else // parent == grandfather->_right
			{
				Node* uncle = grandfather->_left;
				// u存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						// g
						//	  p
						//       c
						RotateL(grandfather);
						grandfather->_col = RED;
						parent->_col = BLACK;
					}
					else
					{
						// g
						//	  p
						// c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;

		return true;
	}

	void RotateL(Node* parent)
	{
		++_rotateCount;

		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;

		Node* ppnode = parent->_parent;

		parent->_parent = cur;


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

			}

			cur->_parent = ppnode;
		}
	}


	void RotateR(Node* parent)
	{
		++_rotateCount;

		Node* cur = parent->_left;
		Node* curright = cur->_right;

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

		Node* ppnode = parent->_parent;
		cur->_right = parent;
		parent->_parent = cur;

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

			cur->_parent = ppnode;
		}
	}
	

	bool CheckColour(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
				return false;

			return true;
		}

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

		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "出现连续红色节点" << endl;
			return false;
		}

		return CheckColour(root->_left, blacknum, benchmark)
			&& CheckColour(root->_right, blacknum, benchmark);
	}

	bool IsBalance()
	{
		return IsBalance(_root);
	}

	bool IsBalance(Node* root)
	{
		if (root == nullptr)
			return true;

		if (root->_col != BLACK)
		{
			return false;
		}

		// 基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				++benchmark;

			cur = cur->_left;
		}

		return CheckColour(root, 0, benchmark);
	}

	int Height()
	{
		return Height(_root);
	}

	int Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

private:
	Node* _root = nullptr;

public:
	int _rotateCount = 0;
};

Map.h

#include"RBTree.h"

namespace Mine
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<K, V>, MapKeyOfT>::iterator iterator;
		iterator begin()
		{
			return _t.begin();
		}

		iterator end()
		{
			return _t.end();
		}

		V& operator[](const K& key);

		bool insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}

	private:
		RBTree<K, pair<K, V>, MapKeyOfT> _t;
	};
}

Set.h

#include"RBTree.h"

namespace Mine
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename RBTree<K, K, SetKeyOfT>::iterator iterator;

		iterator begin()
		{
			return _t.begin();
		}

		iterator end()
		{
			return _t.end();
		}

		bool insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};
}

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

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

相关文章

机器学习（13）---降维实例

机器学习（13）---降维实例

目录 一、人脸识别降维1.1 查看原图1.2 降维后的图像 二、迷你案例2.1 用人脸识别看PCA降维后的信息保存量2.2 噪音过滤2.3 手写数字降维&#xff08;随机森林&#xff09;2.4 手写数字降维&#xff08;KNN&#xff09;2.4 案例总结 一、人脸识别降维 1.1 查看原图 注意&#…
阅读更多...
vue3 自定义Hooks

vue3 自定义Hooks

文章目录 前言一、Hooks是什么&#xff1f;二、图片转换Base641.Hooks2.使用 三、监听元素宽高&#xff08;自定义指令Hooks&#xff09;1.Hooks2.使用 总结 前言 本文主要记录了vue3学习中自定义Hooks和vue2中Mixins的使用与案例。 一、Hooks是什么&#xff1f; Hooks用来处…
阅读更多...
html给下拉框添加搜索、分页功能（通过ajax从服务器获取搜索数据）

html给下拉框添加搜索、分页功能（通过ajax从服务器获取搜索数据）

文章目录 下拉框搜索分页功能开发功能使用源码和Demo&#xff08;点个赞再走咯&#xff09;test.htmlsearchable-select.csssearchserver-select.js 下拉框搜索分页功能开发 最近需要开发一个下拉框从服务器通过Ajax请求搜索数据库并且分页的组件&#xff0c;源码和demo放在下面…
阅读更多...
【微信小程序开发】宠物预约医疗项目实战-开发功能介绍

【微信小程序开发】宠物预约医疗项目实战-开发功能介绍

【微信小程序开发】宠物医院项目实战-开发功能介绍 前言 本项目主要带领大家学习微信小程序开发技术&#xff0c;通过一个完整的项目系统的学习微信小程序的开发过程。鉴于一些同学对视频教学跟不上节奏&#xff0c;为此通过图文描述的方式&#xff0c;完整的将系统开发过程记…
阅读更多...
【Redis】Redis常见面试题

【Redis】Redis常见面试题

【Redis】Redis常见面试题&#xff08;3&#xff09; 文章目录 【Redis】Redis常见面试题&#xff08;3&#xff09;1. 特性&应用场景1.1 Redis能实现什么功能1.2 Redis支持分布式的原理1.3 为什么Redis这么快1.4 Redis实现分布式锁1.5 Redis作为缓存 2. 数据类型2.1 Redis…
阅读更多...
C# 委托学习1

C# 委托学习1

委托的标准定义是&#xff0c;委托是一种引用类型&#xff0c;表示对具有特定参数列表和返回类型的方法的引用&#xff1b; 在实例化委托时&#xff0c;你可以将其实例与任何具有兼容签名和返回类型的方法相关联&#xff1b; 还有一种定义看上去也是正确的&#xff1a;委托是…
阅读更多...
ModuleNotFoundError: No module named ‘gevent‘

ModuleNotFoundError: No module named ‘gevent‘

1、先确定pip版本&#xff1a; pip3 list: 看到没有gevent包 如果pip版本不是最新版可以使用命令python -m pip install --upgrade pip进行更新&#xff0c; 2、安装 pip3 install gevent 安装完成
阅读更多...
联合国教科文发布，ChatGPT等生成式AI教育应用指南

联合国教科文发布，ChatGPT等生成式AI教育应用指南

联合国教科文组织&#xff08;UNESCO&#xff09;在官网发布了&#xff0c;全球首个《生成式AI与教育未来》的应用指南。呼吁各国实施适当的政策&#xff0c;以确保在教育中应用以人为本的方法来使用生成式AI。&#xff08;指南下载地址&#xff1a;https://unesdoc.unesco.org…
阅读更多...
排序(希尔、快速、归并排序)

排序(希尔、快速、归并排序)

文章目录 1.排序的概念及其运用 2.插入排序 3.选择排序 文章内容 1.排序的概念及其运用 1.1排序的概念 排序&#xff1a;所谓排序&#xff0c;就是使一串记录&#xff0c;按照其中的某个或某些关键字的大小&#xff0c;递增或递减的排列起来的操作。 稳定性&#xff1a;假定在…
阅读更多...
K8s上安装gitlab-ce

K8s上安装gitlab-ce

文章目录 K8s上安装gitlab-ce操作如下gitlab-deployment.yml K8s上安装gitlab-ce 前言   使用pv-pvc来持久化gitlab的数据&#xff0c;配置&#xff0c;日志文件。   pod启动后需要需要修改external_url然后重启pod。 操作如下 mkdir -p /mnt/data01/gitlab ctr -n k8s.…
阅读更多...
C# Onnx Yolov8 Cls 分类

C# Onnx Yolov8 Cls 分类

效果 项目 代码 using Microsoft.ML.OnnxRuntime; using Microsoft.ML.OnnxRuntime.Tensors; using OpenCvSharp; using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System…
阅读更多...
sql server 触发器的使用

sql server 触发器的使用

看数据库下的所有触发器及状态 SELECT a.name 数据表名 , sysobjects.name AS 触发器名 , sysobjects.crdate AS 创建时间 , sysobjects.info , sysobjects.status FROM sysobjects LEFT JOIN ( SELECT * FROM sysobjects WHERE xtype U ) AS a ON sysobjects.parent_obj a.…
阅读更多...
Git: 工作区、暂存区、本地仓库、远程仓库

Git: 工作区、暂存区、本地仓库、远程仓库

参考链接&#xff1a; Git: 工作区、暂存区、本地仓库、远程仓库 https://blog.csdn.net/weixin_36750623/article/details/96189838
阅读更多...
阿里云通义千问向全社会开放，近期将开源更大参数规模大模型

阿里云通义千问向全社会开放，近期将开源更大参数规模大模型

9月13日&#xff0c;阿里云宣布通义千问大模型已首批通过备案&#xff0c;并正式向公众开放&#xff0c;广大用户可登录通义千问官网体验&#xff0c;企业用户可以通过阿里云调用通义千问API。 通义千问在技术创新和行业应用上均位居大模型行业前列。IDC最新的AI大模型评估报告…
阅读更多...
腾讯云AI超级底座新升级：训练效率提升幅度达到3倍

腾讯云AI超级底座新升级：训练效率提升幅度达到3倍

大模型推动AI进入新纪元&#xff0c;对计算、存储、网络、数据检索及调度容错等方面提出了更高要求。在9月7日举行的2023腾讯全球数字生态大会“AI超级底座专场”上&#xff0c;腾讯云介绍异构计算全新产品矩阵“AI超级底座”及其新能力。 腾讯云副总裁王亚晨在开场致辞中表示&…
阅读更多...
创建第一个MyBatis框架--保姆级教学

创建第一个MyBatis框架--保姆级教学

文章目录 前言一、创建一个空的mybatis项目二、创建一个Maven模块三、各个文件的配置四、总结 前言 在idea上创建我的第一个MyBatis框架 一、创建一个空的mybatis项目 1、new一个新的项目 2、选择最下面&#xff0c;创建一个空项目 3、为空项目取一个名字,位置可以自己选 4、点…
阅读更多...
TCP 和 UDP 的 Socket 调用

TCP 和 UDP 的 Socket 调用

在网络层&#xff0c;Socket 函数需要指定到底是 IPv4 还是 IPv6&#xff0c;分别对应设置为 AF_INET 和 AF_INET6。另外&#xff0c;还要指定到底是 TCP 还是 UDP。TCP 协议是基于数据流的&#xff0c;所以设置为 SOCK_STREAM&#xff0c;而 UDP 是基于数据报的&#xff0c;因…
阅读更多...
java的集合进阶学习

java的集合进阶学习

1.集合类 集合类的特点&#xff1a;提供一种存储空间可变的存储模型&#xff0c;存储的数据容量可以随时发生改变 2.集合体系结构 3.Collection集合 Collection集合常用方法 Collection集合的遍历 4.List集合特点 LinkedList集合的特有功能 数组和链表数据结构 栈&#xff…
阅读更多...
数据分析三剑客之Pandas

数据分析三剑客之Pandas

1.引入 前面一篇文章我们介绍了numpy&#xff0c;但numpy的特长并不是在于数据处理&#xff0c;而是在它能非常方便地实现科学计算&#xff0c;所以我们日常对数据进行处理时用的numpy情况并不是很多&#xff0c;我们需要处理的数据一般都是带有列标签和index索引的&#xff0…
阅读更多...
MCU软核 1. Altera FPGA上运行8051

MCU软核 1. Altera FPGA上运行8051

0. 环境 - Quartus 13 - EP4CE6E22开发板 - keil c51 - ag10kl144h&#xff08;本工程兼容AGM&#xff09; 下载8051源码&#xff1a;https://www.oreganosystems.at/products/ip-cores/8051-ip-core 1. Create Project File --> New Project Wizard 位置&#xff1a;E…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023