C++之栈与队列

不是我衰

已于 2024-04-04 17:47:28 修改

阅读量880

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-10-11 17:26:23 首次发布

本文链接：https://blog.csdn.net/ZZY5707/article/details/133157302

版权

C++ 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

stack的介绍和使用

stack的介绍

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。

3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：
empty：判空操作
back：获取尾部元素操作
push_back：尾部插入元素操作
pop_back：尾部删除元素操作

4. 标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。

从它的成员函数来看,除了emplace其他都是比较熟悉的,另外可以注意到 stack没有迭代器.

string、vector、list都是容器,而stack和queue 是容器适配器,发现stack和queue都没有迭代器，因为stack要保证后进先出(LIFO)，queue要保证先进先出（FIFO）所以其实它们不需要迭代器。

stack使用

函数说明	接口说明
stack()	构造空的栈
empty()	检测stack是否为空
size()	返回stack中元素的个数
top()	返回栈顶元素的引用
push()	将元素val压入stack中
pop()	将stack中尾部的元素弹出

stack的使用比较简单,重要在于它在一些场景下的应用.

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

int main()
{
	stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);
	st.push(5);
	st.push(6);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
	return 0;
}

stack的模拟实现

stack就是我们数据结构学的栈，是一种操作受限制的线性表，所以它可以用链表实现，也可以用顺序表（数组）实现，不过当时C语言只实现了数组栈，因为相对而言数组的结构实现更优一些。因为数组在尾上插入删除数据的代价比较小。那传统的写法就是用一个数组或链表去写.若按C++STL库里的方式来写，就可以用适配器（配接器）模式来实现。

适配器模式的了解

什么是适配器

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

无论是电脑、手机还是其它电器，充电时都无法直接使用 220V 的交流电，为了方便用户使用，各个电器厂商都会提供一个适用于自己产品的电源线，它可以将 220V 的交流电转换成适合电器使用的低压直流电。从用户的角度看，电源线扮演的角色就是将原本不适用的交流电变得适用，因此其又被称为电源适配器。

stack是一种容器适配器，所以它也是一样的，是用来进行转换的，对已有的容器进行转换。
简单的理解容器适配器，其就是将不适用的序列式容器（包括 vector、deque 和 list）变得适用。即通过封装某个序列式容器，并重新组合该容器中包含的成员函数，使其满足某些特定场景的需要。

STL标准库中stack和queue的底层结构

虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和queue只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque:

普通的模拟实现

从栈的接口中可以看出,栈实际是一种特殊的vector,因此使用vector完全可以模拟实现stack, 当然,用链表也可以.

#include<vector>
//#include<list>
namespace test
{
	template<class T>
	class stack
	{
	public:
		stack() {}
		void push(const T& x) { _c.push_back(x); }
		void pop() { _c.pop_back(); }
		T& top() { return _c.back(); }
		const T& top()const { return _c.back(); }
		size_t size()const { return _c.size(); }
		bool empty()const { return _c.empty(); }
	private:
		std::vector<T> _c;
        //std::list<T> _c;
	};
}

STL式的模拟实现

增加一个模板参数，这个参数就是被作为封装对象的基础容器,这里的Container我们最好给一个缺省值，我们说了库里面给的缺省参数是deque

namespace test
{
	template <class T, class Container  = deque<T>>
	class stack
	{
	public:	
		stack() {};
		void push(const T& x) { _con.push_back(x); }
		void pop() { _con.pop_back(); }
		T& top() { return _con.back(); }
		const T& top() const { return _con.back(); }
		size_t size() { return _con.size; }
		bool empty() { return _con.empty(); }
	private:
		Container _con;
	};
}

指定容器，只要它能支持这些操作：就可以作为这里的基础容器。

测试:

queue的介绍及使用

queue的介绍

queue的文档介绍

1. 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。

2. 队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:
empty：检测队列是否为空
size：返回队列中有效元素的个数
front：返回队头元素的引用
back：返回队尾元素的引用
push_back：在队列尾部入队列
pop_front：在队列头部出队列

4. 标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

queue的使用

函数声明	接口说明
queue()	构造空的队列
empty()	检测队列是否为空，是返回true，否则返回false
size()	返回队列中有效元素的个数
front()	返回队头元素的引用
back()	返回队尾元素的引用
push()	在队尾将元素val入队列
pop()	将队头元素出队列

queue的模拟实现

普通的模拟实现:

因为queue的接口中存在头删和尾插，因此使用vector来封装效率太低，而且vector没有push_front函数,但是也可以用erase达到类似效果,但还是效率太低,故可以借助list来模拟实现queue，具体如下：

#include <list>
namespace test
{
	template<class T>
	class queue
	{
	public:
		queue() {}
		void push(const T& x) { _c.push_back(x); }
		void pop() { _c.pop_front(); }
		T& back() { return _c.back(); }
		const T& back()const { return _c.back(); }
		T& front() { return _c.front(); }
		const T& front()const { return _c.front(); }
		size_t size()const { return _c.size(); }
		bool empty()const { return _c.empty(); }
	private:
		std::list<T> _c;
	};
}

STL式的模拟实现:

namespace test
{
	template <class T, class Container  = deque<T>>
	class queue
	{
	public:	
		queue() {};
		void push(const T& x) { _con.push_back(x); }
		void pop() { _con.pop_front(); }
		T& back() { return _con.back(); }
		const T& back() const { return _con.back(); }
        T& front() { return _con.front(); }
		const T& front() const { return _con.front(); }
		size_t size() { return _con.size; }
		bool empty() { return _con.empty(); }
	private:
		Container _con;
	};
}

STL标准库中stack和queue的底层结构

虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和queue的底层只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque。

简单了解一下deque:

deque的简单介绍

deque的原理介绍

deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。从它的功能上来看,它相当于是一种vector和list的结合体

vector:

优点:极高效率下标的随机访问

缺点:扩容,中间的插入,删除效率低

list:

优点:任意位置插入删除数据,效率高.按需申请释放

缺点:不支持下标随机访问

好像vector和list有的功能它都同时具备，那这样看来，deque好像是个的设计。

deque的底层结构

deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示：

但是如果在中间插入删除就涉及效率问题了,是整体挪动数据呢?还是对单个buff数组扩容或者控制数据个数?

这两种方法都可以,看选择牺牲什么!

如果是整体挪动数据的话,中间插入的效率就很低,但是[]访问就快很多,因为保证了每一个buff数组的个数不变:

1. i-=第一个buff的数据个数
2. i/buff存储个数 = 数据在第几个buff
3. i%buff存储个数 = 数据在此buff的位置

如果是对单个buff数组扩容,中间插入的效率高了,但是每个buff数组的数据个数不同, []访问就变麻烦了:

只能用i从第一个buff开始依次减buff数据个数,然后当i小于下一个buff数据个数,才能找到实际的位置.

SGI版本的STL里面是采用的固定大小，每个小数组大小一样的方式去插入.

结论:deque的头尾部的插入删除效率不错,[]访问效率也还可以,但是中间插入删除效率不高,它每个方面都还不错,但是都不精!

#include <vector>
#include <deque>
#include <time.h>
#include<iostream>
#include <algorithm>
using namespace std;
void test_op()
{
    srand(time(0));
    const int N = 1000000;

    deque<int> dq1;
    deque<int> dq2;

    for (int i = 0; i < N; ++i)
    {
        auto e = rand() + i;
        dq1.push_back(e);
        dq2.push_back(e);
    }

    int begin1 = clock();
    sort(dq1.begin(), dq1.end());
    int end1 = clock();

    int begin2 = clock();

    // vector
    vector<int> v(dq2.begin(), dq2.end());
    sort(v.begin(), v.end());
    dq2.assign(v.begin(), v.end());
    int end2 = clock();

    printf("deque sort:%d\n", end1 - begin1);
    printf("deque copy vector sort, copy back deque:%d\n", end2 - begin2);
}
int main()
{
    test_op();
    return 0;
}

deque直接排序比把deqe的数据拷贝到vector用vector排序再拷贝回deque的效率低!

deque的迭代器

双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：

我们看到deque的迭代器由四个指针组成.
cur指针就是当前元素的位置，first和last就是指向其对应buffer数组的起始和结束位置。
node指向其对应buffer数组的地址在中控指针数组中存储的位置,是一个二级指针,如果cur == last,node设置为node+1也就是下一个buffer数组的地址，first就是*(新node),因为node是二级指针,解引用就是一级指针了,然后last = first + buf数据个数,cur赋值为first,就可以继续访问了。

deque的优点与缺点

与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。

与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。

但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

为什么选择deque作为stack和queue的底层默认容器

stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，比如vector和list都可以.

queue是先进先出的特殊线性数据结构，只要具有push_back和pop_front操作的线性结构，都可以作为queue的底层容器，比如list.

但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

deque最突出的一个优点是头插头删、尾插尾删效率很高。而stack和queue是不是都是只在两端进行操作，所以说deque用来作为stack和queue的底层默认容器是确实很适合。

stack和queue不需要遍历(因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作，而deque头插头删、尾插尾删效率很高.
在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率高（与list相比）。
结合了deque的优点，而完美的避开了其缺陷。

优先级队列

priority_queue队列的介绍和使用

priority_queue的介绍

优先级队列也是在<queue>里的,和queue一样,priority_queue也是一个容器适配器,

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：
empty()：检测容器是否为空
size()：返回容器中有效元素个数
front()：返回容器中第一个元素的引用
push_back()：在容器尾部插入元素

5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。

6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

它的默认底层容器不是deque了，而是vector。不是只能用vector，只要支持这些操作的容器都可以，另外我们看到他对容器的迭代器是有要求的

，要求得是随机迭代器random access iterators 。

priority_queue的使用

优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。


#include <iostream>
#include <queue>
using namespace std;
int main()
{
	priority_queue<int> q;
	q.push(1);
	q.push(0);
	q.push(5);
	q.push(2);
	q.push(1);
	q.push(7);
	while (!q.empty())
	{
		cout << q.top() << " ";
		q.pop();
	}
	cout << endl;

	return 0;
}

那如果我们想使用小堆怎么做呢？

这时候就要用到一个东西叫做仿函数。

默认仿函数参数是less,是小堆.

不过呢，因为Compare 这个模板参数被设计在了第三个位置，所以我们要传第三个的话，也要传一下第二个。那我们现在优先级队列里面放的是整型，就可以传一个greater<int>，让它变成大堆

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main()
{
	priority_queue<int,vector<int>,greater<int>> q;
	q.push(1);
	q.push(0);
	q.push(5);
	q.push(2);
	q.push(1);
	q.push(7);
	while (!q.empty())
	{
		cout << q.top() << " ";
		q.pop();
	}
	cout << endl;

	return 0;
}

仿函数介绍

我们来解释一下这里用到的less<int>/greater<int>是什么？
那我们先来认识一个东西——仿函数。他也是STL的六大组件之一。

仿函数（又称函数对象）其实就是一个类,类中重载了运算符()，使得这个类的使用看上去像一个函数。上面priority_queue用到的greater包括默认给的less其实就是库里面提供的仿函数。

实现一个仿函数:

struct LESS
{
	bool operator()(int x, int y)
	{
		return x < y;
	}
};

也可以用class，区别只是它的的默认访问限定符不同。

使用一下:

struct LESS
{
	bool operator()(int x, int y)
	{
		return x < y;
	}
};

void test1()
{
	LESS less;
	cout << less(1, 2) << endl;
}

int main()
{
    test1();
    return 0;
}

1小于2为真，所以打印结果为1。

也可以写成模板,这样更通用:

template <class T>
struct LESS
{
	bool operator()(const T& x,const T& y)
	{
		return x < y;
	}
};

void test1()
{
	LESS<double> less;
	cout << less(1.1, 1.2) << endl;
}

再来看这句关键的代码:

cout << less(1, 2) << endl;

对仿函数对象重载的()运算符的调用就像是一个函数调用。C++发明出这个东西原因之一是C语言的函数指针太复杂了，而仿函数在很多场景能替代函数指针,比如C++库中的sort函数,和下面的priority_queue模拟实现中可以看到它的具体使用.

函数参数中需要传一个仿函数对象去控制,当然不是只能传仿函数，我们看到它给的是一个模板。排序默认是升序,如果要降序:
sort(array.begin(),array.end(),greater<int>())
可以看到传一个仿函数的匿名对象即可

而qsort是传入一个函数指针:

还要注意priority_queue是类模板,第三个模板参数传的是一个类名,sort是模板函数,它能直接传对象是因为函数模板可以隐式实例化,而类模板只能显示实例化.

priority_queue的模拟实现

还是按照库里面的来，把它实现成一个容器适配器的类模板,先实现一个大堆,暂时不使用仿函数:

先实现几个简单的接口:

template<class T, class Container = vector<T>>
class priority_queue
{
public:
    T& top()
    {
	    return con[0];
    }

	T& operator[](size_t i)
	{
		return con[i];
	}

	size_t size()
	{
		return con.size();
	}

	bool empty()
	{
		return con.empty();
	}
private:
	Container con;
};

核心接口

堆的push怎么实现的？

堆的逻辑结构是一个完全二叉树，其物理结构，即底层实际的存储结构是一个一维数组（我们这里使用的是vector），我们push的时候先尾插一个数据，然后对它进行向上调整，确保插入新数据之后它还是一个堆。(堆具体分析见数据结构之二叉树章节)

void adjust_up(int child)
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (con[child] > con[parent])
		{
			swap(con[child], con[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void push(const T& x)
{
	con.push_back(x);
	adjust_up(con.size() - 1);
}

注意向上调整循环的结束条件:
1.当调整到所有结点都满足大堆或小堆的关系,可能调整了多次,最优情况是一次都没调整

2.最坏一直调整当插入的新数据一直交换到成为根结点时就结束了,即child == 0时就中断了,注意不能用parent < 0来判断,因为这里的整除parent最小是0会死循环。代码中就是while(child>0)而不是while(parent >=0).

pop

将堆顶的数据跟最后一个数据进行交换，然后删除数组最后一个数据，再进行向下调整。

void adjust_down(int parent)
{
	int child = parent * 2 + 1;
	while (child < con.size())
	{
		if (child + 1 < con.size() && con[child + 1] > con[child])
		{
			child = child + 1;
		}
		if (con[child] > con[parent])
		{
			swap(con[child], con[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

void pop()
{
	swap(con[0], con[con.size() - 1]);
	con.pop_back();
	adjust_down(0);
}

仿函数less和greater模拟实现及使用

然后呢我们把第三个模板参数加上，把仿函数实现一下：

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

我们刚才实现的是大堆，那我们想要小堆怎么办？
把向上/向下调整里面的比较的符号改一下就可以了.

所以我们要增加一个模板参数，然后通过两个仿函数去控制比较大于还是比较小于，以此控制大堆还是小堆。

void adjust_up(int child)
{
	Compare com;
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if(com(con[parent], con[child]))
		//if (con[child] > con[parent])//等同于if(con[parent] < con[child] )
		{
			swap(con[child], con[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void adjust_down(int parent)
{
	Compare com;
	int child = parent * 2 + 1;
	while (child < con.size())
	{
		if(child+1 < con.size() && com(con[child],con[child+1]))
		//if (child + 1 < con.size() && con[child + 1] > con[child])
		{
			child = child + 1;
		}

		if (com(con[parent], con[child])) 
		//if (con[child] > con[parent])//等同于if(con[parent] < con[child] )
		{
			swap(con[child], con[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

也可以直接用匿名对象:

void adjust_up(int child)
{
	//Compare com;
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if(Compare()(con[parent], con[child]))
		//if (con[child] > con[parent])//等同于if(con[parent] < con[child] )
		{
			swap(con[child], con[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void adjust_down(int parent)
{
	//Compare com;
	int child = parent * 2 + 1;
	while (child < con.size())
	{
		if(child+1 < con.size() && Compare()(con[child], con[child+1]))
		//if (child + 1 < con.size() && con[child + 1] > con[child])
		{
			child = child + 1;
		}

		if (Compare()(con[parent], con[child]))
		//if (con[child] > con[parent])//等同于if(con[parent] < con[child] )
		{
			swap(con[child], con[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

void priority_queue_test2()
{
    test::priority_queue<int,vector<int>,test::GREATER<int>> q;
    q.push(1);
    q.push(0);
    q.push(5);
    q.push(2);
    q.push(1);
    q.push(7);

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

priority_queue 存放自定义类型数据

再来研究一个问题：

现在有一个日期类,并重载了<<，>和<。

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}
	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}
	friend ostream& operator<<(ostream& _cout, const Date& d);
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

我想用priority_queue（优先级队列）去存这个自定义类型数据——日期类的变量，可以吗？

void priority_queue_test3()
{
    test::priority_queue<Date, vector<Date>, test::GREATER<Date>> q;
    q.push(Date(2023,10,10));
    q.push(Date(2023, 10, 11));
    q.push(Date(2023, 10, 12));
    while (!q.empty())
    {
        cout << q.top() << " ";
        q.pop();
    }
    cout << endl;
}

可以的,因为我们的日期类重载了>和<，因为它里面建堆的过程是不是要进行比较啊, 如果没有>和<的重载就不行了。所以如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供> 或者< 的重载

再来看，如果存放一个自定义类型数据的指针呢?

void priority_queue_test3()
{
    test::priority_queue<Date*, vector<Date*>, test::GREATER<Date*>> q;
    q.push(new Date(2023,10,10));
    q.push(new Date(2023, 10, 11));
    q.push(new Date(2023, 10, 12));
    while (!q.empty())
    {
        cout << *(q.top()) << " ";
        q.pop();
    }
    cout << endl;
}

两次运行的结果都不一样:

原因在于现在priority_queue里面存的是Date* 的指针，指针是内置类型，指针比较大小的话就是去比较对应地址的大小。但是这里我们new出来的地址，它们的大小关系可认为是随机的，所以虽然可以比，但是结果并不是我们想要的,我们想要的是去比较它们指针指向的Date类对象的大小。

指针是内置类型，我们也没法重载它的比较操作，那怎么办呢？

我们是不是可以使用仿函数来解决啊。

struct PDataless
{
    bool operator()(Date* d1, Date* d2)
    {
        return *d1 < *d2;
    }
};

struct PDatagreater
{
    bool operator()(Date* d1, Date* d2)
    {
        return *d1 > *d2;
    }
};

void priority_queue_test3()
{
    test::priority_queue<Date*, vector<Date*>, PDataless> q;
    q.push(new Date(2023,10,10));
    q.push(new Date(2023, 10, 11));
    q.push(new Date(2023, 10, 12));
    while (!q.empty())
    {
        cout << *(q.top()) << " ";
        q.pop();
    }
    cout << endl;
}

所以这里我们看到有了仿函数，即使是内置类型，这里我们也可以去控制它的比较方式。

完整代码:

#include <vector>
namespace test
{

	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:
		void adjust_up(int child)
		{
			//Compare com;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				if(Compare()(con[parent], con[child]))
				//if (con[child] > con[parent])//等同于if(con[parent] < con[child] )
				{
					swap(con[child], con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		void adjust_down(int parent)
		{
			//Compare com;
			int child = parent * 2 + 1;
			while (child < con.size())
			{
				if(child+1 < con.size() && Compare()(con[child], con[child+1]))
				//if (child + 1 < con.size() && con[child + 1] > con[child])
				{
					child = child + 1;
				}

				if (Compare()(con[parent], con[child]))
				//if (con[child] > con[parent])//等同于if(con[parent] < con[child] )
				{
					swap(con[child], con[parent]);
					parent = child;
					child = 2 * parent + 1;
				}
				else
				{
					break;
				}
			}
		}

		T& operator[](size_t i)
		{
			return con[i];
		}

		void push(const T& x)
		{
			con.push_back(x);
			adjust_up(con.size() - 1);
		}

		void pop()
		{
			swap(con[0], con[con.size() - 1]);
			con.pop_back();
			adjust_down(0);
		}

		T& top()
		{
			return con[0];
		}
		size_t size()
		{
			return con.size();
		}

		bool empty()
		{
			return con.empty();
		}
	private:
		Container con;
	};
	
}

OJ题----数组中的第K个最大元素(TopK)

215. 数组中的第K个最大元素 - 力扣（LeetCode）

思路1：排序

那这道题我们最容易想到的方法应该就是堆数组排个序，如果数组是降序的，那我们想拿到第k个最大的元素，直接获取数组第k-1个元素就行了, 但是题目要求时间复杂度为 O(n)

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        std::sort(nums.begin(),nums.end(),greater<int>());
        return nums[k-1];
    }
};

思路2：priority_queue

建一个大堆，pop k-1次，然后堆顶的数据就是第K个最大的数了。

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        priority_queue<int> q(nums.begin(),nums.end());
        while(--k)//k--是k次循环,--k就是k-1次
        {
            q.pop();
        }
        return q.top();
    }
};

时间复杂度: 初始化堆需要N*logN, k-1次pop就是(k-1*logN), 所以时间复杂度是O(N*logN + (k-1)*log(N)), 而k<<n, 所以近似于O(N*log(N))

思路3: 也是优先级队列

只拿前K个数建堆, 并维护这个堆里始终都是前K大的元素, 注意要建小堆, 然后从剩余的数中挨个与top()比较, 只要大就进堆, 然后踢掉小的那个值, 最后堆顶元素就是第k大元素.

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        priority_queue<int,vector<int>,greater<int>> q(nums.begin(),nums.begin()+k);
        for(int i = k; i<nums.size(); i++)
        {
            if(nums[i] > q.top())
            {
                q.pop();
                q.push(nums[i]);
            }
        }
        return q.top();
    }
};

时间复杂度: 因为初始化大小为 k 的小顶堆的时间复杂度是 O(k*logk), 然后遍历数组中剩余的 n−k 个元素, 最坏情况下每个元素需要执行时间复杂度为 O(logk) 的插入和弹出操作, 时间复杂度是 O(2*(n−k)*logk), 所以总时间复杂度为O(k*logk + 2*(n−k)*logk), 因为n>>k, 所以时间复杂度近似于O(n*logk), 在数据量很大的时候比第二种思路快一点, 而且空间复杂度也比第二种低.

不是我衰

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
C++之栈与队列

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。无论是电脑、手机还是其它电器，充电时都无法直接使用 220V 的交流电，为了方便用户使用，各个电器厂商都会提供一个适用于自己产品的电源线，它可以将 220V 的交流电转换成适合电器使用的低压直流电。从用户的角度看，电源线扮演的角色就是将原本不适用的交流电变得适用，因此其又被称为电源适配器。
复制链接

扫一扫