map和set的封装

于 2024-08-08 16:45:04 发布
阅读量132 收藏 3
点赞数 3
文章标签： 算法 服务器 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79274600/article/details/141028696
版权

文章目录

1.红黑树相关迭代器的实现

1.1operator++

在自增/减时要满足红黑树中序遍历的顺序：左子树、根、右子树（符合递增或递减）
++时：
右子树存在，找到右子树中的最左节点
右子树不存在，向上层遍历，直到当前节点是其父节点的左节点，取父节点（左、中）

Self& operator++()
{
	if (_node->_right)
	{
		// 下一个，右树最左节点
		Node* leftMin = _node->_right;
		while (leftMin->_left)
		{
			leftMin = leftMin->_left;
		}

		_node = leftMin;
	}
	else
	{
		// 下一个，孩子等于父亲左的那个祖先
		Node* cur = _node;
		Node* parent = cur->_parent;
		while (parent && cur == parent->_right)
		{
			cur = parent;
			parent = parent->_parent;
		}

		_node = parent;
	}

	return *this;
}

–时同理：
左子树存在，找到左子树中的最右节点
左子树不存在，找到孩子是父亲右节点的祖先节点

1.2operator[]

[k]返回v，map是kv模型，可以实现[],set不能,这里的operator[]在map的封装中实现。

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

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

1.3其他接口

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

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

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

Iterator Begin()
{
	Node* leftMin = _root;
	while (leftMin && leftMin->_left)
	{
		leftMin = leftMin->_left;
	}

	return Iterator(leftMin);
}

Iterator End()
{
	return Iterator(nullptr);
}

ConstIterator End() const
{
	return ConstIterator(nullptr);
}

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

	return ConstIterator(leftMin);
}

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

	return End();
}
// 20:10
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* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		// K
		// pair<K, V>
		// kot对象，是用来取T类型的data对象中的key
		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;
	cur->_col = RED; // 新增节点给红色
	if (kot(parent->_data) < kot(data))
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	// parent的颜色是黑色也结束
	while (parent && parent->_col == RED)
	{
		// 关键看叔叔
		Node* grandfather = parent->_parent;
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			// 叔叔存在且为红，-》变色即可
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				// 继续往上处理
				cur = grandfather;
				parent = cur->_parent;
			}
			else // 叔叔不存在，或者存在且为黑
			{
				if (cur == parent->_left)
				{
					//     g  
					//   p   u
					// c 
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//      g  
					//   p     u
					//      c 
					RotateL(parent);
					RotateR(grandfather);
					cur->_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 // 叔叔不存在，或者存在且为黑
			{
				// 情况二：叔叔不存在或者存在且为黑
				// 旋转+变色
				//      g
				//   u     p
				//            c
				if (cur == parent->_right)
				{
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//		g
					//   u     p
					//      c
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}

				break;
			}
		}
	}

	_root->_col = BLACK;

	return make_pair(Iterator(newnode), true);
}

2.KeyOfT

map和set的底层都是红黑树，但map是kv模型，而set是k模型。在取key值时，set能直接取，但map要取kv.first。这时候我们可以用一个KeyOfT的类去获得map和set里面的k值。
在这里插入图片描述
在底层红黑树取k值时分别通过set和map中KetOfT的仿函数取到对应k值。

3.map 封装

#pragma once

#include"RBT.h"
#include<iostream>
using namespace std;
namespace bit
{
	template<class K, class V>
	class Mymap
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::Iterator iterator;
		typedef typename RBTree<K, const K, MapKeyOfT>::ConstIterator const_iterator;

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

		const_iterator end() const
		{
			return _t.End();
		}

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

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

		iterator find(const K& key)
		{
			return _t.Find(key);
		}

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

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

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

	void test_map()
	{
		Mymap<string, int> m;
		m.insert({ "苹果",1 });
		m.insert({ "菠萝",5 });
		m.insert({ "香蕉",2 });
		m.insert({ "西瓜",3 });

		Mymap<string, int>::iterator it = m.begin();
		while (it != m.end())
		{
			it->second += 1;

			//cout << it.operator->()->first << ":" << it->second << endl;
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;
	}

}

4.set封装

#pragma once

#include"RBT.h"
#include<iostream>
using namespace std;

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

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

		const_iterator end() const
		{
			return _t.End();
		}

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

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

		iterator find(const K& key)
		{
			return _t.Find(key);
		}

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

	private:
		RBTree<K, const K, SetKeyOfT> _t;
	};

	void PrintSet(const set<int>& s)
	{
		for (auto e : s)
		{
			cout << e << endl;
		}
	}

	void test_set()
	{
		set<int> s;
		s.insert(4);
		s.insert(2);
		s.insert(5);
		s.insert(15);
		s.insert(7);
		s.insert(1);
		s.insert(5);
		s.insert(7);

		PrintSet(s);

		set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			//*it += 5;

			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : s)
		{
			cout << e << " ";
		}
		cout << endl;

		set<int> copy = s;
		for (auto e : copy)
		{
			cout << e << " ";
		}
		cout << endl;
		//cout << copy._t.IsBalance() << endl;
	}
}

5.测试

#include"mymap.h"
#include"myset.h"
int main()
{
	bit::test_map();
	bit::test_set();
	return 0;
}

在这里插入图片描述

6.源码

6.1RBT.h

#pragma once
#include<vector>
#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, class Ref, class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;

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

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

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

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

	Self& operator++()
	{
		if (_node->_right)
		{
			// 下一个，右树最左节点
			Node* leftMin = _node->_right;
			while (leftMin->_left)
			{
				leftMin = leftMin->_left;
			}

			_node = leftMin;
		}
		else
		{
			// 下一个，孩子等于父亲左的那个祖先
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}
};

template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;

public:
	typedef __RBTreeIterator<T, T&, T*> Iterator;
	typedef __RBTreeIterator<T, const T&, const T*> ConstIterator;

	RBTree() = default;

	RBTree(const RBTree<K, T, KeyOfT>& t)
	{
		_root = Copy(t._root);
	}

	// t2 = t1
	RBTree<K, T, KeyOfT>& operator=(RBTree<K, T, KeyOfT> t)
	{
		swap(_root, t._root);
		return *this;
	}

	~RBTree()
	{
		Destroy(_root);

		_root = nullptr;
	}

	Iterator Begin()
	{
		Node* leftMin = _root;
		while (leftMin && leftMin->_left)
		{
			leftMin = leftMin->_left;
		}

		return Iterator(leftMin);
	}

	Iterator End()
	{
		return Iterator(nullptr);
	}

	ConstIterator End() const
	{
		return ConstIterator(nullptr);
	}

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

		return ConstIterator(leftMin);
	}

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

		return End();
	}
	// 20:10
	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* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			// K
			// pair<K, V>
			// kot对象，是用来取T类型的data对象中的key
			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;
		cur->_col = RED; // 新增节点给红色
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		// parent的颜色是黑色也结束
		while (parent && parent->_col == RED)
		{
			// 关键看叔叔
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				// 叔叔存在且为红，-》变色即可
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else // 叔叔不存在，或者存在且为黑
				{
					if (cur == parent->_left)
					{
						//     g  
						//   p   u
						// c 
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//      g  
						//   p     u
						//      c 
						RotateL(parent);
						RotateR(grandfather);
						cur->_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 // 叔叔不存在，或者存在且为黑
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					//      g
					//   u     p
					//            c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//		g
						//   u     p
						//      c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

		_root->_col = BLACK;

		return make_pair(Iterator(newnode), true);
	}

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

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

		subL->_right = parent;

		Node* ppNode = parent->_parent;
		parent->_parent = subL;

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

			subL->_parent = ppNode;
		}
	}

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

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

		subR->_left = parent;
		Node* ppNode = parent->_parent;

		parent->_parent = subR;

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

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

	bool IsBalance()
	{
		if (_root->_col == RED)
		{
			return false;
		}

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

			cur = cur->_left;
		}

		return Check(_root, 0, refNum);
	}

private:
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* newroot = new Node(root->_data);
		newroot->_col = root->_col;

		newroot->_left = Copy(root->_left);
		if (newroot->_left)
			newroot->_left->_parent = newroot;

		newroot->_right = Copy(root->_right);
		if (newroot->_right)
			newroot->_right->_parent = newroot;

		return newroot;
	}

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

		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
		root = nullptr;
	}

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

			return true;
		}

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

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

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

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

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

private:
	Node* _root = nullptr;
	//size_t _size = 0;
};
gsfl
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
c++——map和set的封装
Britney_dark的博客
11-20 790
如果结果不如你所愿，就在尘埃落定前奋力一搏！
c++ map，set封装
2301_78323041的博客
05-12 875
map 是一个 kv 结构， set 是 k结构。我们前面模拟实现了 红黑树，但是我们实现的红黑树把 kv 结构写死了，怎么样才能用泛型编程的思想来实现map和set呢我们先简单看一下原码中是怎么实现的。
map和set 的封装
潜心钻研技术
03-03 755
这些问题在没有学习map和set之前并没有很好的解决方法（但是map和set并不是唯一的解决方法），第二个问题：之前我们解决的方法一般就开辟一个新数组tmp，遍历arr中所有元素，对于arr中任意元素遍历tmp数组如果元素在tmp中未出现就插入。这时就会报错，因为是非const对象，调用的begin是非const成员函数，返回的是普通迭代器，所以报错的原因是缺乏普通迭代器到const迭代器的转化！我们对于map和set封装始终是在红黑树的基础上进行封装的，红黑树的代码可以参考blog。
C++进阶之map与set
cls的博客
05-23 2421
stl中将数据结构叫做容器。 容器分为 序列式容器：vector/list... 就类似线性表 关联史容器：map/set.. 数据之间有强烈的关联性，底层是搜索树 栈和队列是适配器 set底层就是搜索树。 void test_set1() { //排序＋去重 set<int> s; s.insert(3); s.insert(1); s.insert(8); s.insert(2); s.insert(5); s.insert(5); s.insert(5)
C++中map和set的使用与区别
u011089523的博客
10-24 1680
setset的数据结构set的操作函数erasefindcount重载操作符multisetmapmap的数据结构map的构造函数map的操作函数erasecleanfind重载运算符其他操作函数multimap ) set set是一种关联式容器，其特性如下： set以RBTree作为底层容器 所得元素的只有key没有value，value就是key 不允许出现键值重复 所有的元素都会被自动排...
C++之map和set 的封装
qq_74732628的博客
05-13 914
文章详细讲解了map和set 的封装过程和底层原理
map和set的异同
爱橙子的OK绷的专栏
03-12 7786
异同分析MAP的节点是一对数据. SET的节点是一个数据.map使用关键值Key来唯一标识每一个成员, map的value值可以重复。 set存储已排序的无重复的元素。都属于关联容器 ，形式不同：map的形式 map<type1, type2> mymap; set的形式 set<type> myset; set（集合）——包含了经过排序了的数据，这些数据的值(v
map与set的封装
m0_73919066的博客
11-19 529
红黑树的结点 与 红黑树的迭代器 红黑树的实现： 迭代器： 红黑树的查找： 红黑树的插入： 检查红色结点：红黑树的左旋 红黑树的右旋 红黑树的双旋 Map的封装 set的封装
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 2749
红黑树详解
C++语法——map与set的封装原理
weixin_61857742的博客
12-01 906
list迭代器是用类封装，迭代器内部定义一个指针指向节点，对迭代器的操作底层是对迭代器内部指针的操作。迭代器的begin和end只能在rb_tree中实现，对于begin而言，返回红黑树最左节点的迭代器，end返回root的父节点迭代器（空节点迭代器）。其原理就是如果是父节点的左子节点，那么说明父节点在自己之后，如果是右子节点那么说明在父节点之后。对比3号和5号节点，都是叶子节点，但是3号节点++后是1号节点，5号++后是6号节点。对比节点3和节点5，节点3--之后是节点2，节点5--之后是节点4。
map和set的模拟实现
06-06
本文将深入探讨如何通过封装红黑树来模拟实现Map和Set。 红黑树是一种自平衡二叉查找树，它的主要特性是每个节点都带有颜色属性（红色或黑色），并且遵循以下性质： 1. 每个节点要么是黑色，要么是红色。 2. 根节点...
哈希map以及set的封装
04-05
在这个场景中，我们讨论的是C++中的哈希表实现，即`哈希map`和`哈希set`的封装，它们是STL（标准模板库）的一部分，由`unordered_map`和`unordered_set`两个容器来表示。 首先，我们来看`哈希map`。`std::unordered...
红黑树封装实现map和set
06-20
封装红黑树实现map和set解决方案
c++容器list、vector、map、set区别与用法详解
08-19
"c++容器list、vector、map、set区别与用法详解" c++容器是c++标准模板库（STL）中的一个重要组件，提供了多种数据结构的实现，包括list、vector、map、set等。这些容器的使用可以大大提高开发效率和代码可读性。 ...
红黑树封装map&&set源代码
06-01
封装红黑树的Map和Set源代码通常会包括以下关键部分： 1. **节点定义**：首先，需要定义红黑树的节点结构，包括键、值、颜色属性、左子节点和右子节点。例如： ```java class Node { Key key; Value value; ...
CSP 2020 第三题：表达式
m0_46183615的博客
08-03 536
CSP 2020 第三题：表达式
VRF 算法流程及代码实现
smilejiasmile的博客
08-03 230
Verifiable Random Functions (VRFs) 是一种密码学原语，能够为给定输入生成一个随机输出，并提供一个可以验证的证明，证明输出是由特定输入生成的。VRFs 具有许多应用，包括区块链、分布式系统和安全协议。使用secp256k1曲线可以产生确定性签名，适用于 VRF 实现。通过使用 HMAC-SHA256 生成确定性随机数k，可以确保签名过程对相同的输入始终产生相同的结果，从而满足 VRF 的要求。
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 121
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
【算法】动态规划解决背包问题
2302_78914800的博客
08-04 441
1.动态规划算法的核心是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法2.动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解3.与分治算法不同的是，适合于用动态规划求解的问题，经分解得到的子问题往往不是相互独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）4.动态规划可以通过填表的方式来逐步推进，得到最优解。
SolrTemplate query 返回结果封装为map集合
03-25
SolrTemplate中的query方法返回的结果是List<T>类型，可以通过遍历List来获取每个Document对象，然后再把每个Document对象的字段封装到Map集合中。 以下是一个示例代码： ```java List<Map<String, Object>> resultList = new ArrayList<>(); String keyword = "apple"; Query query = new SimpleQuery(new Criteria("title").contains(keyword)); query.setRows(10); // 设置返回结果的最大数量为10 query.setSort(Sort.by("price").ascending()); // 设置按照价格升序排序 query.setFields("id", "title", "price"); // 设置要返回的字段 QueryResponse response = solrTemplate.query(query); for (SolrDocument document : response.getResults()) { Map<String, Object> resultMap = new HashMap<>(); resultMap.put("id", document.get("id")); resultMap.put("title", document.get("title")); resultMap.put("price", document.get("price")); resultList.add(resultMap); } ``` 在上面的代码中，我们先定义了一个List<Map<String, Object>>类型的结果集，然后创建了一个Query对象，设置了查询条件、返回结果数量、排序方式和返回字段等参数。通过调用solrTemplate.query方法执行查询操作，得到QueryResponse对象。然后遍历QueryResponse中的SolrDocument对象，将每个Document对象的id、title、price字段封装到Map集合中，最终将Map集合添加到结果集中。 需要注意的是，SolrDocument中的字段值类型可能是Object类型，需要根据实际情况进行类型转换。如果有多个Document对象需要封装，建议使用Java8的Stream API来简化代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gsfl

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值