【C++】使用红黑树进行封装map和set

news2024/11/24 18:31:03

🌇个人主页：平凡的小苏
📚学习格言：命运给你一个低的起点，是想看你精彩的翻盘，而不是让你自甘堕落，脚下的路虽然难走，但我还能走，比起向阳而生，我更想尝试逆风翻盘。
🛸C++专栏：C++内功修炼基地
> 家人们更新不易，你们的👍点赞👍和⭐关注⭐真的对我真重要，各位路 过的友友麻烦多多点赞关注。 欢迎你们的私信提问，感谢你们的转发！ 关注我，关注我，关注我，你们将会看到更多的优质内容！！

一、STL库中的set和map源码

​ 本文难点：使用红黑树封装set和map，必须保证两种数据结构复用同一棵红黑树；且满足set和map的性质，set的value不可被改变，而map的value可以被改变。

在这里插入图片描述

二、利用模板区分map和set

template<class T>
struct RedBlackTreeNode
{
	T _data;
	RedBlackTreeNode<T>* _left;//该节点的左孩子
	RedBlackTreeNode<T>* _right;//该节点的右孩子
	RedBlackTreeNode<T>* _parent;//该节点是父亲节点
	Color _col;

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

map和set的区别在于value的不同，红黑树模板参数T，代表value用以区分set和map。

三、利用仿函数比较大小

我们会发现红黑树的插入等接口会对key值进行比较大小，像set直接对key进行比较，这没问题，但是map中的节点装的是pair<K,V>,pair的比较规则是first比完之后可能会再去比较second（而我们仅仅想要比较first，该比较规则不适用）。

通过源码启发，我们可以对红黑树新增一个模板参数：
仿函数KeyOfT，在set和map类中完善该仿函数的比较对象，
用于区分set和map的比较：

struct MapKeyOfT
{
    const K& operator()(const pair<K, V>& kv)
    {
        return kv.first;
    }
};

struct SetKeyOfT
{
    const K& operator()(const K& key)
    {
        return key;
    }
};

注：这里为什么只是返回key的数值，而不是在仿函数里面进行比较大小呢？

因为我们调用find的函数的时候不是传入两个数值进行比较的，而只是传一个。

使用红黑树封装的find

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;
	}

四、set和map的迭代器

STL源码采用下图结构，多搞了一个头结点。迭代器begin()可以指向header的左，迭代器end()指向header。

在这里插入图片描述

而小编使用的是无头结点进行封装的map和set，将nullptr作为结束

1、红黑树的begin()和end()

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

    return iterator(leftMin);
}

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

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

    return const_iterator(leftMin);
}

const_iterator end() const
{
    return const_iterator(nullptr);
}

封装了const是为了适配const的map和set

2、operator++

1、如果_node的右不为空，找右孩子的最左节点

2、如果_node的右为空，如果孩子是父亲的左就返回父亲，否则就继续向上遍历，如果走到nullptr那就是遍历完成

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 && cur == parent->_right)//parent不为空
        {
            cur = parent;
            parent = parent->_parent;
        }
        _node = parent;
    }
    return *this;
}

3、operator–

1、如果_node的左不为空，找左孩子的最右节点

2、如果_node的左为空，如果孩子是父亲的右就返回父亲，否则就继续向上遍历，如果走到nullptr那就是遍历完成

Self& operator--()
{
    if (_node->_left)
    {
        Node* subright = _node->_left;
        while (subright->_right)
        {
            subright = subright->_right;
        }

        _node = subright;
    }
    else
    {
        Node* cur = _node;
        Node* parent = cur->_parent;
        while (parent && cur == parent->_left)
        {
            cur = parent;
            parent = parent->_parent;
        }

        _node = parent;
    }
    return *this;
}

五、set的迭代器

对于set和map，它们的key都是不能改的。set的value不能修改，map的value可以修改。

因为set的value是不能改的，所以它的底层将普通迭代器和const迭代器全部封装成const迭代器来“解决”：

//注意这里是const_iterator变为iterator，在插入的时候会出现问题
typedef typename RedBlackTree<K, K, SetKeyOfT>::const_iterator iterator;
typedef typename RedBlackTree<K, K, SetKeyOfT>::const_iterator const_iterator;

这里iterator使用了const 的迭代器后，begin()和end()后面都需要加上const来解决问题；

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

这时使用迭代器调用上方函数会发现红黑树返回了普通迭代器类型的迭代器，类型不匹配。

在红黑树中补齐const版本的迭代器函数解决：

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

    return const_iterator(leftMin);
}

const_iterator end() const
{
    return const_iterator(nullptr);
}

六、map的迭代器

map的value是可以改的，所以需要分别设计普通迭代器和const迭代器

typedef typename RedBlackTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
typedef typename RedBlackTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;

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

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

const_iterator begin() const
{
    return _t.begin();
}

七、迭代器的拷贝构造

STL库中的普通迭代器都可以转换为const迭代器，这是迭代器类的拷贝构造所支持的。

这个拷贝构造有点特殊：

struct __TreeIterator
{
	typedef RedBlackTreeNode<T> Node;
	Node* _node;
	typedef __TreeIterator<T,Ref,Ptr> Self;
	typedef __TreeIterator<T, T&, T*> iterator;

	__TreeIterator(const iterator& it)
		:_node(it._node)
	{}

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

1、当这个模板的的Ref和PTR被实例化为T&和T*时，__RBTreeIterator(const iterator& it)就是一个拷贝构造(没啥意义)

2、当这个模板的的Ref和PTR被实例化为const T&和const T*时，__RBTreeIterator(const iterator& it)就是一个构造函数，

支持用普通迭代器去构造const迭代器。此时const迭代器的拷贝构造函数则由编译器自动生成，刚好满足迭代器值拷贝的特点。

八、源码

1、set.h

#include "9.14RedBlackTree.h"

namespace sqy
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename RedBlackTree<K, K, SetKeyOfT>::const_iterator iterator;//注意这里是const_iterator变为iterator，在插入的时候会出现问题
		typedef typename RedBlackTree<K, K, SetKeyOfT>::const_iterator const_iterator;

		pair<iterator,bool> insert(const K& key)
		{
			pair<typename RedBlackTree<K, K, SetKeyOfT>::iterator,bool> ret = _t.Insert(key);//这里调用insert返回的是普通迭代器
			return pair<iterator, bool>(ret.first, ret.second);//这里需要用普通迭代器拷贝构造const的迭代器
		}
		iterator begin()const 
		{
			return _t.begin();
		}

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

	private:
		RedBlackTree<K, K, SetKeyOfT> _t;
	};
}

2、map.h

#include "9.14RedBlackTree.h"
namespace sqy
{
	template<class K,class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RedBlackTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
		typedef typename RedBlackTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;

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

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

		const_iterator begin() const
		{
			return _t.begin();
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool>ret = _t.Insert(make_pair(key, V()));
			return ret.first->second;
		}

		const_iterator end()const
		{
			return _t.end();
		}
		pair<iterator,bool> insert(const pair<K,V>& kv)
		{
			return _t.Insert(kv);
		}
	private:
		RedBlackTree<K, pair<const K,V>, MapKeyOfT> _t;
	};
}

3、RedBlackTree.h

#include <iostream>
#include <cassert>
using namespace std;

enum Color
{
	RED,
	BLACK
};


template<class T>
struct RedBlackTreeNode
{
	T _data;
	RedBlackTreeNode<T>* _left;//该节点的左孩子
	RedBlackTreeNode<T>* _right;//该节点的右孩子
	RedBlackTreeNode<T>* _parent;//该节点是父亲节点
	Color _col;

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

template<class T,class Ref,class Ptr>
struct __TreeIterator
{
	typedef RedBlackTreeNode<T> Node;
	Node* _node;
	typedef __TreeIterator<T,Ref,Ptr> Self;
	typedef __TreeIterator<T, T&, T*> iterator;

	__TreeIterator(const iterator& it)
		:_node(it._node)
	{}

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

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

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

	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 && cur == parent->_right)//parent不为空
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			Node* subright = _node->_left;
			while (subright->_right)
			{
				subright = subright->_right;
			}

			_node = subright;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}

	bool operator!=(const Self& s)const
	{
		return _node != s._node;
	}

	bool operator==(const Self& s)const
	{
		return _node == s._node;
	}
};

template<class K, class T, class KeyOfT>
class RedBlackTree
{
	typedef RedBlackTreeNode<T> Node;
public:
	typedef __TreeIterator<T, T&, T*> iterator;
	typedef __TreeIterator<T, const T&, const T*> const_iterator;

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

		return iterator(leftMin);
	}

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

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

		return const_iterator(leftMin);
	}

	const_iterator end() const
	{
		return const_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;
	}
	pair<iterator,bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root),true);
		}
		KeyOfT kot;
		Node* cur = _root;
		Node* parent = nullptr;
		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 make_pair(iterator(cur), false);
			}
		}

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

		cur->_parent = parent;

		// ... 控制平衡
		while (parent && parent->_col == RED)//parent不为空并且为红进循环
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				if (parent->_left == cur)
				{
					Node* uncle = grandfather->_right;
					if (uncle && uncle->_col == RED)//叔叔节点为红
					{
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;
						cur = grandfather;
						parent = cur->_parent;
					}
					else //叔叔节点为空或者为黑的情况
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
						break;
					}
				}
				else
				{
					Node* uncle = grandfather->_right;
					if (uncle && uncle->_col == RED)//叔叔存在并且叔叔节点为红
					{
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;
						cur = grandfather;
						parent = cur->_parent;
					}
					else //叔叔节点为空或者为黑的情况
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
						break;
					}
				}
			}
			else
			{
				if (parent->_right == cur)
				{
					Node* uncle = grandfather->_left;
					if (uncle && uncle->_col == RED)//叔叔节点为红
					{
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;
						cur = grandfather;
						parent = cur->_parent;
					}
					else //叔叔节点为空或者为黑的情况
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
						break;
					}
				}
				else
				{
					Node* uncle = grandfather->_left;
					if (uncle && uncle->_col == RED)//叔叔节点为红
					{
						parent->_col = uncle->_col = BLACK;
						grandfather->_col = RED;
						cur = grandfather;
						parent = cur->_parent;
					}
					else //叔叔节点为空或者为黑的情况
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
						break;
					}
				}
			}
		}
		_root->_col = BLACK;
		return make_pair(iterator(newnode), true);
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	bool checkColour(Node* root, int blacknum, int beachmark)
	{
		if (root == nullptr)
		{
			if (blacknum != beachmark)
			{
				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, beachmark) && 
				checkColour(root->_right, blacknum, beachmark);
	}
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		if (root->_col != BLACK)
		{
			return false;
		}

		//基准值
		int beanchmark = 0;
		Node* cur = root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++beanchmark;
			}
			cur = cur->_left;
		}

		return checkColour(root, 0, beanchmark);
	}
	void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curRight = cur->_right;

		parent->_left = curRight;
		cur->_right = parent;
		Node* ppNode = parent->_parent;
		if (curRight)
		{
			curRight->_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 RotateL(Node* parent)
	{
		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;
		}

	}
private:
	Node* _root = nullptr;
};

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

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

相关文章

【IEEE 13 节点分配系统中的THD降低】系统的谐波分析给出了各种总线上电流和电压的谐波频谱和THD（Simulink实现）

【IEEE 13 节点分配系统中的THD降低】系统的谐波分析给出了各种总线上电流和电压的谐波频谱和THD（Simulink实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
phantomjs插件---实现通过链接生成网页截图

phantomjs插件---实现通过链接生成网页截图

Phantomjs | PhantomJS 配置要求 windows下&#xff0c;安装完成phantomJS 设置phantomjs环境变量【也可直接使用phantomjs目录下的执行文件】 直接通过访问php文件执行/通过cmd命令行执行【phantomjs phantom_script.js】 linux下,安装完成phantomJS 设置phantomjs环境变量 直…
阅读更多...
模拟实现链式二叉树及其结构学习——【数据结构】

模拟实现链式二叉树及其结构学习——【数据结构】

W...Y的主页 &#x1f60a; 代码仓库分享 &#x1f495; 之前我们实现了用顺序表完成二叉树(也就是堆)&#xff0c;顺序二叉树的实际作用就是解决堆排序以及Topk问题。 今天我们要学习的内容是链式二叉树&#xff0c;并且实现链式二叉树&#xff0c;这篇博客与递归息息相关&a…
阅读更多...
前端JavaScript中requestAnimationFrame：优化动画和渲染的利器

前端JavaScript中requestAnimationFrame：优化动画和渲染的利器

&#x1f3ac; 岸边的风&#xff1a;个人主页 &#x1f525; 个人专栏 :《 VUE 》 《 javaScript 》 ⛺️ 生活的理想&#xff0c;就是为了理想的生活 ! 目录 引言 1. requestAnimationFrame简介 2. requestAnimationFrame的属性 3. requestAnimationFrame的应用场景 3.1…
阅读更多...
在Copernicus Data Space Ecosystem下载Sentinel数据及使用脚本检索和下载数据

在Copernicus Data Space Ecosystem下载Sentinel数据及使用脚本检索和下载数据

文章目录 1.前言2.Copernicus Data Space Ecosystem使用介绍3.使用脚本检索和下载Sentinel数据4.最后 建了一个QQ群&#xff0c;大家可以在里边聊聊水色遥感数据下载和数据处理方面的事情&#xff1a;1087024529 1.前言 最近使用Sentinelsat库在Copernicus Open Access Hub下载…
阅读更多...
线性代数的本质(三)——线性方程组

线性代数的本质(三)——线性方程组

文章目录 线性方程组高斯消元法初等行变换线性方程组的解向量方程齐次线性方程组的解非齐次线性方程组的解 线性方程组 高斯消元法 客观世界最简单的数量关系是均匀变化的关系。在均匀变化问题中&#xff0c;列出的方程组是一次方程组&#xff0c;我们称之为线性方程组(Linea…
阅读更多...
语音识别算法设计-基于MFCC+DTW算法-Matlab+C代码版本

语音识别算法设计-基于MFCC+DTW算法-Matlab+C代码版本

语音识别算法设计-基于MFCCDTW算法-MatlabC代码&#xff08;全定点加速&#xff09;版本 语音识别算法主要涉及特征提取、统计建模和识别技术等几个关键方面。在此使用MFCCDTW算法的方式给出语音识别的代码&#xff0c;首先进行简单介绍。 Matlab版本代码地址&#xff1a;http…
阅读更多...
基于STC15单片机温度光照检测系统-proteus仿真-源程序

基于STC15单片机温度光照检测系统-proteus仿真-源程序

一、系统方案 1、本设计采用STC15单片机作为主控器。 2、光敏电阻采集光照值送到液晶1602和串口显示。 3、DS18B20采集温度值&#xff0c;送到液晶1602和串口显示。 二、硬件设计 原理图如下&#xff1a; 三、单片机软件设计 1、首先是系统初始化 /-----------------------…
阅读更多...
Vector 模拟实现

Vector 模拟实现

前言 本文将会向您介绍如何模拟实现vector 引入 Vector是一种动态数组&#xff0c;也是C标准库中的容器之一。它提供了一种存储和操作一系列元素的方式&#xff0c;类似于数组&#xff0c;但具有更多的功能和灵活性。 Vector可以存储不同类型的元素&#xff0c;并且可以根据…
阅读更多...
关于老项目从JDK8升级到JDK17所需要注意的细节

关于老项目从JDK8升级到JDK17所需要注意的细节

文章目录 ☀️1.关于老项目从JDK8升级到JDK17所需要注意的细节&#x1f338;1.1.更新JDK&#x1f338;1.2.修改Idea中的JDK版本&#x1f338;1.3.关于修改过程中遇到的异常&#x1f338;1.4.IDEA工具栏操作Maven正常&#xff0c;但使用mvn命令运行就报错 ☀️1.关于老项目从JDK…
阅读更多...
烧结金属材料和硬质合金弹性模量的测定

烧结金属材料和硬质合金弹性模量的测定

声明 本文是学习GB-T 5166-2023 烧结金属材料和硬质合金弹性模量的测定. 而整理的学习笔记,分享出来希望更多人受益,如果存在侵权请及时联系我们 1 范围 本文件描述了烧结金属材料和硬质合金弹性模量的测定方法。 本文件适用于采用纵向振动法测定烧结金属材料和硬质合金的动…
阅读更多...
Windows 10任务栏点不动了，右下角wifi、音量也都消失了，只剩下个时间

Windows 10任务栏点不动了，右下角wifi、音量也都消失了，只剩下个时间

Windows 10任务栏点不动了&#xff0c;右下角wifi、音量也都消失了&#xff0c;只剩下个时间 解决方法图例如下 解决方法 快捷键Ctrlaltdelete&#xff0c;选择任务管理器打开&#xff0c;选择“文件”-“运行新任务”&#xff1a;就会打开运行窗口&#xff0c;输入&#xff1…
阅读更多...
动态规划：子序列问题（C++）

动态规划：子序列问题（C++）

动态规划&#xff1a;子序列问题 前言子序列问题1.最长递增子序列&#xff08;中等&#xff09;2.摆动序列&#xff08;中等&#xff09;3.最长递增子序列的个数&#xff08;中等&#xff09;4.最长数对链&#xff08;中等&#xff09;5.最长定差子序列&#xff08;中等&#x…
阅读更多...
SQL优化--排序优化（order by）

SQL优化--排序优化（order by）

Using filesort : 通过表的索引或全表扫描&#xff0c;读取满足条件的数据行&#xff0c;然后在排序缓冲区sort buffer中完成排序操作&#xff0c;所有不是通过索引直接返回排序结果的排序都叫 FileSort 排序。 Using index : 通过有序索引顺序扫描直接返回有序数据&#xff0c…
阅读更多...
linux驱动开发day6--(epoll实现IO多路复用、信号驱动IO、设备树以及节点和属性解析相关API使用)

linux驱动开发day6--(epoll实现IO多路复用、信号驱动IO、设备树以及节点和属性解析相关API使用)

一、IO多路复用--epoll实现 1.核心&#xff1a; 红黑树、一张表以及三个接口、 2.实现过程及API 1&#xff09;创建epoll句柄/创建红黑树根节点 int epfdepoll_create(int size--无意义&#xff0c;>0即可)----------成功&#xff1a;返回根节点对应文件描述符&#xf…
阅读更多...
计算机二级python基础题刷题笔记（二）

计算机二级python基础题刷题笔记（二）

1、等比数列 1、获得用户输入的以逗号分隔的三个数字&#xff0c;记为a,b,c,以a为起始数值&#xff0c;b为前后相邻数的比值&#xff0c;c为数列长度 &#xff0c;产生一个等比数列&#xff0c;将这个数列以逗号分隔的形式输出&#xff0c;最后一个元素输出后无逗号 等比数列公…
阅读更多...
匿名管道-

匿名管道-

因为父子进程是共享文件描述符的环形队列&#xff0c;只能读一次 会被后面覆盖 /*#include <unistd.h>int pipe(int pipefd[2]);功能&#xff1a;创建一个匿名管道&#xff0c;用于进程间通信参数&#xff1a;int 类型数组 &#xff0c;是传出参数pipefd[0]是管道读端 p…
阅读更多...
企业级SpringBoot单体项目模板 ——整合MySQL和Mybatis-plus

企业级SpringBoot单体项目模板 ——整合MySQL和Mybatis-plus

&#x1f61c;作 者&#xff1a;是江迪呀✒️本文关键词&#xff1a;Springboot、数据库、Git、项目☀️每日 一言&#xff1a;野心是对梦想最好的致敬&#xff01; 上回我们已经成功的创建了一个SpringBoot的单体项目并测试启动并了&#xff0c;但是光有个空架子是…
阅读更多...
【独立全开源】点大商城V2-2.5.2 新增 微信小程序隐私协议弹窗

【独立全开源】点大商城V2-2.5.2 新增 微信小程序隐私协议弹窗

独立全开源版本&#xff1a;点大商城V2小程序公众号模块&#xff0c;版本更新至2.5.2&#xff0c;前端为UNiapp、这个是源码后端开源&#xff0c;购买包更新&#xff0c;包修复、 更新为覆盖升级&#xff0c;源码更新了&#xff1a;新增 微信小程序隐私协议弹窗 测试环境&…
阅读更多...
肖sir__mysql之多表练习题__007

肖sir__mysql之多表练习题__007

已知2张基本表&#xff1a;部门表&#xff1a;dept &#xff08;部门号&#xff0c;部门名称&#xff09;;员工表 emp&#xff08;员工号&#xff0c;员工姓名&#xff0c;年龄&#xff0c;入职时间&#xff0c;收入&#xff0c;部门号&#xff09; 1&#xff1a;dept表中有4条…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023