【C++】stack、queue和priority_queue的模拟实现

news2024/9/21 22:11:33

在本篇博客中，作者将会讲解STL中的stack、queue和priority_queue的模拟实现，同时还会带大家了解一下deque这个容器。

一.什么是适配器

STL中一共有6大组件：容器，适配器，空间配置器，仿函数，迭代器，算法。

其中像vector、list这种数据结构叫做容器，而像stack、queue这种数据结构叫做适配器。

为什么呢？

因为stack和queue是通过deque这个容器转换过来的，也就是说，将deque容器的成员函数转换成stack和queue的成员函数

通过查看C++的手册，发现stack和queue类中有一个模板，其中第二个模板参数就是deque，即在stack和queue类中，是通过deque这个容器来实现的。

可能看到这里，还有同学不懂适配器到底是什么，那么在这里通过几张图来解释一下。 

在解释之前，我们来看看deque这个容器的具体的成员函数。

可以发现，deque这个容器的成员函数特别的多。 

接下来我们再看看stack和queue的成员函数。 

 

可以发现deque的成员函数特别的多，而stack和queue的成员函数特别的少，但是在stack和queue的实现中又用到了deque，所以要减少deque的成员函数来实现stack和queue。

如下图：

二.stack的模拟实现 

在C++库中，stack和queue都是通过使用deque容器来实现的，但是为了能够便于大家理解，在stack的模拟实现中，我们使用vector这个容器来实现，而在queue的模拟实现中，我们使用list这个容器来实现，实现完后，我们再来简单的了解一下deque。

stack的基本成员函数

首先我们来梳理一下stack的基本成员函数，看看这个数据结构需要用到那些功能。

empty：判断是否为空

size：求数据个数

top：取栈顶数据

push：入栈

pop：出栈

剩下的两个暂时不讲解。

stack模拟实现

梳理完stack的基本成员函数后，我们就可以来实现一下了。 

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

namespace My_Stack
{
	//使用模板来给一个vector参数
	template<class T,class Container=vector<T>>
	class stack
	{
	public:
		stack()
		{}

		//入栈
		void push(const T& val)
		{
			_s.push_back(val);
		}

		//出栈
		void pop()
		{
			_s.pop_back();
		}

		//判断是否为空
		bool empty() const
		{
			return _s.empty();
		}

		//获取数据个数
		size_t size() const
		{
			return _s.size();
		}

		//取栈顶数据
		T& top()
		{
			return _s.back();
		}

		//const类型取栈顶数据
		const T& top() const
		{
			return _s.back();
		}

	private:
		Container _s;
	};

	void Test1()
	{
		stack<int> s1;
		s1.push(1);
		s1.push(2);
		s1.push(3);
		s1.push(4);

		while (!s1.empty())
		{
			cout << s1.top() << " ";
			s1.pop();
		}
	}
}

三.queue的模拟实现

在模拟实现queue时，我们使用list这个容器来实现它，因为list提供的成员函数比较适合queue。 

queue的基本成员函数 

在实现queue之前，同样的，我们先来看看queue的基本成员函数。

empty：判断队列是否为空

size：获取数据个数

front：获取队头数据

back：获取队尾数据

push：入队列

pop：出队列

queue的模拟实现 

#pragma once
#include<iostream>
#include<list>

namespace My_queue
{
    //模板参数给一个list容器
	template<class T,class Container=list<T>>
	class queue
	{
	public:
		queue()
		{}

		//入队列
		void push(const T& val)
		{
			_l.push_back(val);
		}

		//出队列
		void pop()
		{
			_l.pop_front();
		}

		//取对头
		T& front()
		{
			return _l.front();
		}

		const T& front() const
		{
			return _l.front();
		}

		//取队尾
		T& back()
		{
			return _l.back();
		}

		const T& back() const
		{
			return _l.back();
		}

		//判断是否为空
		bool empty() const
		{
			return _l.empty();
		}

		//获取数据个数
		size_t size() const
		{
			return _l.size();
		}

	private:
		Container _l;
	};

	void Test1()
	{
		queue<int> q1;
		q1.push(1);
		q1.push(2);
		q1.push(3);
		q1.push(4);

		cout << q1.size() << endl;

		while (!q1.empty())
		{
			cout << q1.front() << " ";
			q1.pop();
		}
	}
}

代码写到这里，stack和queue的模拟实现就基本完成了，但是在c++的STL中，实现stack和queue是通过使用deque这个容器来实现的

四.deque的简单介绍

在上面提到，stack和queue其实是通过使用deque这个容器来实现的，但是我们实现的时候为了便于大家理解，所以使用了vector和list来实现，那么现在，我们先来简单的了解一下的deque这个容器。

deque的基本介绍

首先，deque是一个顺序的存储结构，和vector和list一样，都是顺着顺序来存储数据的，那么它们有什么区别吗，又或者说，为什么会出现deque这种数据结构？

在讲解之前，我们先来看看vector和list的缺点

vector和list的缺点

vector：头插头删效率低（因为要挪动数据）。

list：不能支持随机访问（在访问某个结点前，要先去遍历list去找到它）。

deque的出现

所以为了解决这两个容器的缺点，人们发明出了deque这种数据结构，也叫双端队列，这种队列头插头删和尾插尾删的时间效率为O（1），同时还能支持随机访问（但是它并不是真正意义上的随机访问）。

deque的结构

那么deque是如何实现的呢？deque通过数组指针和指针数组来实现的。

通过这样的结构来实现，使deque的头插头删和尾插尾删的效率非常的高，但是deque不适合遍历，因为deque是分开的连续空间，导致在其遍历时非常麻烦，具体的细节在这里不做讲解。 

deque实现stack和queue

所以为什么stack和queue要使用deque这个容器来实现，因为stack只用到了尾插尾删，queue只用到了尾插和头删，正好都利用到了deque的优点，而deque的缺点没有涉及到，所以stack和queue的实现用到了deque这个容器。 

以下是使用deque来实现stack和queue。

namespace deque_stack
{
	template<class T, class Container = deque<T>>
	class stack
	{
	public:
		stack(){}
		//入栈
		void push(const T& val){_s.push_back(val);}
		//出栈
		void pop(){_s.pop_back();}
		//判断是否为空
		bool empty() const{return _s.empty();}
		//获取数据个数
		size_t size() const{return _s.size();}
		//取栈顶数据
		T& top(){return _s.back();}
		//const类型取栈顶数据
		const T& top() const{return _s.back();}
	private:
		Container _s;
	};

	void Test1()
	{
		stack<int> s1;
		s1.push(1);
		s1.push(2);
		s1.push(3);
		s1.push(4);
		while (!s1.empty())
		{
			cout << s1.top() << " ";
			s1.pop();
		}
	}
}
namespace deque_queue
{
	template<class T,class Container = deque<T>>
	class queue
	{
	public:
		queue(){}
		//入队列
		void push(const T& val){_l.push_back(val);}
		//出队列
		void pop(){_l.pop_front();}
		//取对头
		T& front(){return _l.front();}
		const T& front() const{return _l.front();}
		//取队尾
		T& back(){return _l.back();}
		const T& back() const{return _l.back();}
		//判断是否为空
		bool empty() const{return _l.empty();}
		//获取数据个数
		size_t size() const{return _l.size();}
	private:
		Container _l;
	};

	void Test1()
	{
		queue<int> q1;
		q1.push(1);
		q1.push(2);
		q1.push(3);
		q1.push(4);
		while (!q1.empty())
		{
			cout << q1.front() << " ";
			q1.pop();
		}
	}
}

五.priority_queue的模拟实现

接下来，我们进入到priority_queue的模拟实现。

如果你查过queue的手册，会发现queue下面还有一个priority_queue的东西。

这个叫优先队列，简单的说也就是堆。

对于堆的结构和各种操作，可以参考下面这篇博客

【C语言】堆的实现（建堆、堆的基本操作、堆排序、TOK问题）详解_堆 编程-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/EWIAW_ilove/article/details/135045451?spm=1001.2014.3001.5501

这篇博客详细的讲解了堆的实现，以及各种讲解，在这里，我们直接给出priority_queue的模拟实现并做简单的解释。

默认生成大堆

在实现之前，我们来看看priority_queue的成员函数。

默认情况下，我们生成的堆都是大堆，但是有时候也会用到小堆，大堆和小堆的区别就是，在代码中的比较反过来就行了，但是具体怎么实现呢？

这个时候要用到STL中的仿函数来实现。

在具体讲解建小堆前，我们先来看看大堆的实现。

#pragma once
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
namespace My_priority
{
	template<class T,class Container = vector<T>>
	class priority_queue
	{
	public:
		priority_queue()
		{}
		//从尾部插入数据
		void push(const T& val)
		{
			_pq.push_back(val);//先在vector的尾部插入新数据

			//后进行一个向上调整
			AdjustUp();
		}
		void AdjustUp()//向上调整算法
		{
			int child = size() - 1;
			int parent = (child - 1) / 2;

			while (parent >= 0 && _pq[child] > _pq[parent])
			{
				swap(_pq[child], _pq[parent]);
				child = parent;
				parent = (child - 1) / 2;
			}
		}
		//删除堆顶数据
		void pop()
		{
			assert(size());
			swap(_pq[0], _pq[size() - 1]);//交换堆顶和尾部数据
			_pq.pop_back();//删除尾部数据

			//向下调整
			AdjustDown();
		}
		void AdjustDown()//向下调整算法
		{
			int parent = 0;
			int child = parent * 2 + 1;//默认child给左孩子

			while (child < size())
			{
				if ((child + 1) < size() && (_pq[child] < _pq[child + 1]))//如果右孩子存在并且大于左孩子，则child给右孩子
				{
					child += 1;
				}

				if (_pq[child] > _pq[parent])
				{
					swap(_pq[child], _pq[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
		//判断是否为空
		bool empty() const
		{
			return _pq.empty();
		}
		//求数据个数
		size_t size() const
		{
			return _pq.size();
		}
		//取堆顶数据
		const T& top() const
		{
			assert(size());
			return _pq[0];
		}
	private:
		Container _pq;
	};
}

仿函数 

在上面的实现中，默认情况下能生成只大堆，那么如果我们想要生成小堆，该怎么办呢？

在解释之前，我们先来看看仿函数这个东西。

仿函数如字面意思，是一个模仿的函数，即仿函数不是真正意义上的函数，其实它是一个由一个类通过重载（）来实现的。如下我实现了一个用于比较小于的仿函数。

 同样的，大于的比较我们也可以通过这种方式实现。

如下：        

 

 模拟实现大小堆

有了这两个仿函数，我们就可以通过模板的方式来控制生成的是大堆还是小堆了。 

#pragma once
#include<iostream>
#include<vector>
#include<assert.h>

using namespace std;

namespace My_priority
{
	//用于比较小于的仿函数
	template<class T>
	struct less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}	 
	};

	//用于比较大于的仿函数
	template<class T>
	struct greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	//模板参数有三个：类型参数、堆底层的容器、仿函数，仿函数默认给less
	template<class T,class Container = vector<T>,class Compare = less<T>>
	class priority_queue
	{
	public:
		priority_queue()
		{}

		//从尾部插入数据
		void push(const T& val)
		{
			_pq.push_back(val);//先在vector的尾部插入新数据

			//后进行一个向上调整
			AdjustUp();
		}

		void AdjustUp()//向上调整算法
		{
			Compare com;//创建仿函数对象
			int child = size() - 1;
			int parent = (child - 1) / 2;

			while (parent >= 0 && com(_pq[parent],_pq[child]))
			{
				swap(_pq[child], _pq[parent]);
				child = parent;
				parent = (child - 1) / 2;
			}
		}

		//删除堆顶数据
		void pop()
		{
			assert(size());
			swap(_pq[0], _pq[size() - 1]);//交换堆顶和尾部数据
			_pq.pop_back();//删除尾部数据

			//向下调整
			AdjustDown();
		}

		void AdjustDown()//向下调整算法
		{
			Compare com;//创建仿函数对象
			int parent = 0;
			int child = parent * 2 + 1;//默认child给左孩子

			while (child < size())
			{
				if ((child + 1) < size() && com(_pq[child] , _pq[child + 1]))//如果右孩子存在并且大于左孩子，则child给右孩子
				{
					child += 1;
				}

				if (com(_pq[parent] , _pq[child]))
				{
					swap(_pq[child], _pq[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		//判断是否为空
		bool empty() const
		{
			return _pq.empty();
		}

		//求数据个数
		int size() const
		{
			return _pq.size();
		}

		//取堆顶数据
		const T& top() const
		{
			assert(size());
			return _pq[0];
		}

	private:
		Container _pq;
	};
}

 六.所以源代码

stack.h

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

namespace My_Stack
{
	//使用模板来给一个vector参数
	template<class T,class Container=vector<T>>
	class stack
	{
	public:
		stack()
		{}

		//入栈
		void push(const T& val)
		{
			_s.push_back(val);
		}

		//出栈
		void pop()
		{
			_s.pop_back();
		}

		//判断是否为空
		bool empty() const
		{
			return _s.empty();
		}

		//获取数据个数
		size_t size() const
		{
			return _s.size();
		}

		//取栈顶数据
		T& top()
		{
			return _s.back();
		}

		//const类型取栈顶数据
		const T& top() const
		{
			return _s.back();
		}

	private:
		Container _s;
	};

	void Test1()
	{
		stack<int> s1;
		s1.push(1);
		s1.push(2);
		s1.push(3);
		s1.push(4);

		while (!s1.empty())
		{
			cout << s1.top() << " ";
			s1.pop();
		}
		cout << endl;
	}

	void Test2()
	{
		stack<int> s1;
		s1.push(1);
		s1.push(2);
		s1.push(3);
		s1.push(4);

		int a = s1.top();
		s1.pop();
		s1.push(10);
	
		cout << a << endl;
	}
}

namespace deque_stack
{
	template<class T, class Container = deque<T>>
	class stack
	{
	public:
		stack(){}
		//入栈
		void push(const T& val){_s.push_back(val);}
		//出栈
		void pop(){_s.pop_back();}
		//判断是否为空
		bool empty() const{return _s.empty();}
		//获取数据个数
		size_t size() const{return _s.size();}
		//取栈顶数据
		T& top(){return _s.back();}
		//const类型取栈顶数据
		const T& top() const{return _s.back();}
	private:
		Container _s;
	};

	void Test1()
	{
		stack<int> s1;
		s1.push(1);
		s1.push(2);
		s1.push(3);
		s1.push(4);
		while (!s1.empty())
		{
			cout << s1.top() << " ";
			s1.pop();
		}
		cout << endl;
	}
}

queue.h

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

namespace My_queue
{
	template<class T,class Container=list<T>>
	class queue
	{
	public:
		queue()
		{}

		//入队列
		void push(const T& val)
		{
			_l.push_back(val);
		}

		//出队列
		void pop()
		{
			_l.pop_front();
		}

		//取对头
		T& front()
		{
			return _l.front();
		}

		const T& front() const
		{
			return _l.front();
		}

		//取队尾
		T& back()
		{
			return _l.back();
		}

		const T& back() const
		{
			return _l.back();
		}

		//判断是否为空
		bool empty() const
		{
			return _l.empty();
		}

		//获取数据个数
		size_t size() const
		{
			return _l.size();
		}

	private:
		Container _l;
	};

	void Test1()
	{
		queue<int> q1;
		q1.push(1);
		q1.push(2);
		q1.push(3);
		q1.push(4);

		cout << q1.size() << endl;

		while (!q1.empty())
		{
			cout << q1.front() << " ";
			q1.pop();
		}
		cout << endl;
	}
}

namespace deque_queue
{
	template<class T,class Container = deque<T>>
	class queue
	{
	public:
		queue(){}
		//入队列
		void push(const T& val){_l.push_back(val);}
		//出队列
		void pop(){_l.pop_front();}
		//取对头
		T& front(){return _l.front();}
		const T& front() const{return _l.front();}
		//取队尾
		T& back(){return _l.back();}
		const T& back() const{return _l.back();}
		//判断是否为空
		bool empty() const{return _l.empty();}
		//获取数据个数
		size_t size() const{return _l.size();}
	private:
		Container _l;
	};

	void Test1()
	{
		queue<int> q1;
		q1.push(1);
		q1.push(2);
		q1.push(3);
		q1.push(4);
		while (!q1.empty())
		{
			cout << q1.front() << " ";
			q1.pop();
		}
		cout << endl;
	}
}

priority.h

#pragma once
#include<iostream>
#include<vector>
#include<assert.h>

using namespace std;

namespace My_priority
{
	//用于比较小于的仿函数
	template<class T>
	struct less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}	 
	};

	//用于比较大于的仿函数
	template<class T>
	struct greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

	//模板参数有三个：类型参数、堆底层的容器、仿函数
	template<class T,class Container = vector<T>,class Compare = less<T>>
	class priority_queue
	{
	public:
		priority_queue()
		{}

		//从尾部插入数据
		void push(const T& val)
		{
			_pq.push_back(val);//先在vector的尾部插入新数据

			//后进行一个向上调整
			AdjustUp();
		}

		void AdjustUp()//向上调整算法
		{
			Compare com;
			int child = size() - 1;
			int parent = (child - 1) / 2;

			while (parent >= 0 && com(_pq[parent],_pq[child]))
			{
				swap(_pq[child], _pq[parent]);
				child = parent;
				parent = (child - 1) / 2;
			}
		}

		//删除堆顶数据
		void pop()
		{
			assert(size());
			swap(_pq[0], _pq[size() - 1]);//交换堆顶和尾部数据
			_pq.pop_back();//删除尾部数据

			//向下调整
			AdjustDown();
		}

		void AdjustDown()//向下调整算法
		{
			Compare com;
			int parent = 0;
			int child = parent * 2 + 1;//默认child给左孩子

			while (child < size())
			{
				if ((child + 1) < size() && com(_pq[child] , _pq[child + 1]))//如果右孩子存在并且大于左孩子，则child给右孩子
				{
					child += 1;
				}

				if (com(_pq[parent] , _pq[child]))
				{
					swap(_pq[child], _pq[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		//判断是否为空
		bool empty() const
		{
			return _pq.empty();
		}

		//求数据个数
		int size() const
		{
			return _pq.size();
		}

		//取堆顶数据
		const T& top() const
		{
			assert(size());
			return _pq[0];
		}

	private:
		Container _pq;
	};

	void Test1()
	{
		//priority_queue<int> pq;
		priority_queue<int,vector<int>,greater<int>> pq;
		pq.push(15);
		pq.push(10);
		pq.push(8);
		pq.push(20);

		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}
		cout << endl;
	}
}

test.cpp

#include"stack.h"
#include"queue.h"
#include"priority.h"
int main()
{
	My_Stack::Test1();
	My_Stack::Test2();

	My_queue::Test1();

	deque_stack::Test1();
	deque_queue::Test1();

	My_priority::Test1();

	return 0;
}

 

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

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

相关文章

深度学习中的优化算法：选择现有的还是自创？

深度学习中的优化算法：选择现有的还是自创？

深度学习中的优化算法 深度学习中的优化算法&#xff1a;选择现有的还是自创&#xff1f;现有优化算法的优势**优点包括**&#xff1a; 开发新的优化算法的考虑**开发新算法的原因**&#xff1a;**开发新算法的风险**&#xff1a; 实用建议结论 深度学习中的优化算法&#xff1…
阅读更多...
代码随想录算法训练营第十三天：树的认知（补五一）

代码随想录算法训练营第十三天：树的认知（补五一）

代码随想录算法训练营第十三天&#xff1a;树的认知&#xff08;补五一&#xff09; ‍ 二叉树的递归遍历 #算法公开课 《代码随想录》算法视频公开课 ****(opens new window)****​ &#xff1a;​每次写递归都要靠直觉&#xff1f; 这次带你学透二叉树的递归遍历&#xf…
阅读更多...
自动化运维工具-Ansible

自动化运维工具-Ansible

一、Ansible概述 Ansible是一种基于python开发的自动化运维工具&#xff0c;它只需要在服务端安装ansible&#xff0c;无需在每个客户端安装客户端程序&#xff0c;通过ssh的方式来进行客户端服务器的管理&#xff0c;基于模块来实现批量数据配置、批量设备部署以及批量命令执…
阅读更多...
全球260多个国家的年通货膨胀率数据集（1960-2021年）

全球260多个国家的年通货膨胀率数据集（1960-2021年）

01、数据简介 全球年通货膨胀率是指全球范围内&#xff0c;在一年时间内&#xff0c;物价普遍上涨的比率。这种上涨可能是由于货币过度供应、需求过热、成本上升等原因导致的。通货膨胀率是衡量一个国家或地区经济状况和物价水平的重要指标&#xff0c;通常以消费者价格指数&a…
阅读更多...
添加自定义内容致远oa门户

添加自定义内容致远oa门户

修改门户内容 甲方需要再主页添加按钮&#xff0c;其实也是可以的&#xff0c;这个配置还不好搞&#xff0c;在后端进行了配置开发
阅读更多...
pyqt 分组框控件QGroupBox

pyqt 分组框控件QGroupBox

pyqt 分组框控件QGroupBox 分组框控件QGroupBox介绍效果代码 分组框控件QGroupBox介绍 QGroupBox提供了一个框架&#xff0c;用于将其他控件&#xff08;如按钮、滑块、标签等&#xff09;组合在一起。 QGroupBox 通常包含一个标题栏和一个内容区域。标题栏显示文本标签&#…
阅读更多...
电子书制作神器，简单操作

电子书制作神器，简单操作

​随着数字化时代的到来&#xff0c;电子书籍越来越受到人们的喜爱。而一款优秀的电子翻页书制作软件&#xff0c;则能够帮助你轻松制作出专业级的电子书&#xff0c;让你的阅读体验更加丰富多彩。 今天&#xff0c;我们就来为大家推荐一款优秀的电子翻页书制作软件——FLBOOK在…
阅读更多...
拼多多商品详情API返回值全解析

拼多多商品详情API返回值全解析

关键数据指标 成长层级&#xff1a;根据店铺近30天交易额、店铺领航员&#xff0c;综合评估得出店铺所处的成长层级 店铺综合体验星级&#xff1a;以领航员综合分为数据基础&#xff0c;同时结合店铺活跃度、行业特色服务(特色服务要求根据行业特色调整)&#xff0c;形成的店铺…
阅读更多...
Linux学习笔记（3）---- Debian测试网速指令及查看是否千兆网卡

Linux学习笔记（3）---- Debian测试网速指令及查看是否千兆网卡

测试网速指令 在Debian系统中&#xff0c;测网速的指令主要有以下几种方法&#xff1a; 使用speedtest-cli工具&#xff1a; speedtest-cli是一个常用的网络速度测试工具&#xff0c;可以通过命令行进行安装和运行。首先&#xff0c;需要安装speedtest-cli&#xff1a; sud…
阅读更多...
【driver4】锁，错误码，休眠唤醒，中断，虚拟内存，tasklet

【driver4】锁，错误码，休眠唤醒，中断，虚拟内存，tasklet

文章目录 1.互斥锁和自旋锁选择&#xff1a;自旋锁&#xff08;开销少&#xff09;的自旋时间和被锁住的代码执行时间成正比关系2.linux错误码&#xff1a;64位系统内核空间最后一页地址为0xfffffffffffff000~0xffffffffffffffff&#xff0c;这段地址是被保留的&#xff0c;如果…
阅读更多...
Sarcasm detection论文解析 |基于情感背景和个人表达习惯的有效讽刺检测方法

Sarcasm detection论文解析 |基于情感背景和个人表达习惯的有效讽刺检测方法

论文地址 论文地址&#xff1a;https://link.springer.com/article/10.1007/s12559-021-09832-x#/ 论文首页 笔记框架 基于情感背景和个人表达习惯的有效讽刺检测方法 &#x1f4c5;出版年份:2022 &#x1f4d6;出版期刊:Cognitive Computation &#x1f4c8;影响因子:5.4 &…
阅读更多...
报错，java: 程序包sun.misc不存在

报错，java: 程序包sun.misc不存在

错误描述 down下来一个项目&#xff0c;编译的时候报错&#xff0c;提示sun.misc包不存在&#xff0c;通过百度得知&#xff0c;原来这是jdk8中的jar包&#xff0c;在后来的版本中被移除了&#xff08;我用的jdk11&#xff0c;没有这个包&#xff09; 结局方法 1.更换jdk版本&…
阅读更多...
【电影】【指环王】【中土世界】影碟播放记录

【电影】【指环王】【中土世界】影碟播放记录

一、写在前面 笔者于5月5日&#xff08;昨天&#xff09;在新加坡淘到了一套《指环王 The Lord of the Rings》DVD光碟&#xff0c;今天却听闻噩耗&#xff0c;Rohan国王Theoden的扮演者&#xff0c;英国演员Bernard Hill去世&#xff08;享年79岁&#xff09;&#xff0c;发文…
阅读更多...
链式队列基本操作

链式队列基本操作

链式队列的基本概念 链式队列是一种常见的数据结构&#xff0c;它使用链表作为其底层数据存储结构。链式队列的特点是动态的内存分配&#xff0c;可以有效地处理队列的入队和出队操作。下面&#xff0c;我将介绍链式队列的实现方法&#xff0c;并提供相应的C语言代码示例。 链…
阅读更多...
曼奇立德10节春季插画研修课

曼奇立德10节春季插画研修课

课程介绍 课程探讨了存在主义心理学的基本原理和方法。通过学习该课程&#xff0c;您将了解到存在主义的核心概念&#xff0c;如自由意志、责任感和意义寻求。您将学会运用存在主义理论和技巧来帮助个人面对挑战、追求自我实现&#xff0c;并寻找生活的意义。这门课程将启发您的…
阅读更多...
力扣每日一题-去掉最低工资和最高工资后的工资平均值-2024.5.3

力扣每日一题-去掉最低工资和最高工资后的工资平均值-2024.5.3

力扣题目&#xff1a;去掉最低工资和最高工资后的工资平均值 开篇 题目链接: 1491.去掉最低工资和最高工资后的工资平均值 题目描述 代码思路 太简单了。先利用sort排序对数组进行从小到大排序&#xff0c;然后计算时数组最小值和最大值不要加进去即可。 代码纯享版 clas…
阅读更多...
C#图像处理实例1：opencvsharp获取轮廓凸包

C#图像处理实例1：opencvsharp获取轮廓凸包

在OpenCvSharp中&#xff0c;你可以使用Cv2.ApproxPolyDP函数来获取轮廓的凸包。这个函数使用Douglas-Peucker算法来近似轮廓。 以下是一个简单的例子&#xff0c;展示如何使用OpenCvSharp获取轮廓的凸包&#xff1a; Mat src Cv2.ImRead("保存图像\2.jpg", ImreadM…
阅读更多...
C++例题:大数运算---字符串相加(使用数字字符串来模拟竖式计算)

C++例题:大数运算---字符串相加(使用数字字符串来模拟竖式计算)

1.代码速览 class Solution2 { public:string addStrings(string num1, string num2){//end1和end1是下标int end1 num1.size() - 1;int end2 num2.size() - 1;string str;//下标(指针)从后向前走,走到头才可以结束,所以是end>0int next 0;while (end1 > 0 || end2 &…
阅读更多...
利用大语言模型（KIMI）构建智能产品的信息模型

利用大语言模型（KIMI）构建智能产品的信息模型

数字化的核心是数字化建模&#xff0c;为一个事物构建数字模型是一件非常繁杂和耗费人工的事情。利用大语言模型&#xff0c;能够轻松地生成设备的信息模型&#xff0c;我们的初步实验表明&#xff0c;只要提供足够的模板&#xff0c;就能够准确地生成设备的数字化模型。 我们尝…
阅读更多...
CyberDemo解读

CyberDemo解读

CyberDemo: Augmenting Simulated Human Demonstration for Real-World Dexterous Manipulation解读 摘要1. 简介2. Related Work2.1 Data for Learning Robot Manipulation2.2 机器人的预训练视觉表征2.3 Sim2Real Transfer 3. CyberDemo3.1 收集人体遥操作数据3.2 在模拟器中…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023