stack和queue
一.容器适配器
1.什么是适配器
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设
计经验的总结),该种模式是将一个类的接口转换成客户希望的另外一个接口。
二.模拟实现stack和queue
函数说明 | 接口说明 |
---|---|
stack() | 构造空的栈 |
empty() | 检测stack是否为空 |
size() | 返回stack中元素的个数 |
top() | 返回栈顶元素的引用 |
push() | 将元素val压入stack中 |
pop() | 将stack中尾部的元素弹出 |
namespace xzy
{
//Container适配转换成stack
template<class T, class Container = vector<T>>
//template<class T, class Container = deque<T>> STL中的模版
class stack
{
public:
stack(){} //自定义类型默认调用它的默认构造,无需写
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_back();
}
const T& top() const
{
return _con.back();
}
size_t size() const
{
return _con.size();
}
bool empty() const
{
return _con.empty();
}
private:
Container _con;
};
}
函数声明 | 接口说明 |
---|---|
queue() | 构造空的队列 |
empty() | 检测队列是否为空,是返回true,否则返回false |
size() | 返回队列中有效元素的个数 |
front() | 返回队头元素的引用 |
back() | 返回队尾元素的引用 |
push() | 在队尾将元素val入队列 |
pop() | 将队头元素出队列 |
namespace xzy
{
//Container适配转换成queue
template<class T, class Container = list<T>>
//template<class T, class Container = deque<T>> STL中的模版
class queue
{
public:
queue() {} //自定义类型默认调用它的默认构造,无需写
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_front();
}
const T& front() const
{
return _con.front();
}
const T& back() const
{
return _con.back();
}
size_t size() const
{
return _con.size();
}
bool empty() const
{
return _con.empty();
}
private:
Container _con;
};
}
注意:
- 为了维护stack后进先出和queue先进先出的性质,它们没有迭代器的概念。
- 类模版实例化时,按需实例化,使用哪些成员函数就实例化哪些,不会全部实例化,即使类内部的成员函数中调用不存在的函数,不使用该成员函数则不会实例化,编译不会报错,只有对象.成员函数调用该成员函数时,才会实例化,编译报错。
三.STL标准库中stack和queue的底层结构
虽然stack和queue中也可以存放元素,但在STL中并没有将其划分在容器的行列,而是将其称为
容器适配器,这是因为stack和queue只是对其他容器的接口进行了包装,STL中stack和queue默认
使用deque,比如:
四.deque(双端队列)的简单介绍
deque(双端队列):是一种双开口的"连续"空间的数据结构,双开口的含义是:可以在头尾两端进行插入和删除操作,且时间复杂度为O(1),与vector比较,头插效率高,不需要搬移元素;与list比较,空间利用率比较高。
deque并不是真正连续的空间,而是由一段段连续的小空间拼接而成的,实际deque类似于一个动态的二维数组,其底层结构如下图所示:
双端队列底层是一段假象的连续空间,实际是分段连续的,为了维护其“整体连续”以及随机访问的假象,落在了deque的迭代器身上,因此deque的迭代器设计就比较复杂,如下图所示:
那deque是如何借助其迭代器维护其假想连续的结构呢?
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作为其底层容器,主要是因为:
- stack和queue不需要遍历(因此stack和queue没有迭代器),只需要在固定的一端或者两端进
行操作。 - 在stack中元素增长时,deque比vector的效率高(扩容时不需要搬移大量数据);queue中的元素增长时,deque不仅效率高,而且内存使用率高。结合了deque的优点,而完美的避开了其缺陷。
六.priority_queue(优先级队列)的介绍和使用
-
优先级队列是一种容器适配器,根据严格的弱排序标准,它的第一个元素总是它所包含的元素中最大的。
-
此上下文类似于堆,在堆中可以随时插入元素,并且只能检索最大堆元素(优先队列中位于顶部的元素)
-
优先级队列被实现为容器适配器,容器适配器即将特定容器类封装作为其底层容器类,queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出,其称为优先队列的顶部。
-
底层容器可以是任何标准容器类模板,也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问。
-
标准容器类vector和deque满足这些需求,默认情况下,如果没有为特定的priority_queue类实例化指定容器类,则使用vector。
-
需要支持随机访问迭代器,以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。
优先级队列默认使用vector作为其底层存储数据的容器,在vector上又使用了堆算法将vector中元素构造成堆的结构,因此priority_queue就是堆,所有需要用到堆的位置,都可以考虑使用priority_queue。注意:默认情况下priority_queue是大堆。
函数声明 | 接口说明 |
---|---|
priority_queue() | 构造一个空的优先级队列 |
priority_queue(InputIterator first, InputIterator last) | 迭代器构造优先级队列 |
empty() | 检测优先级队列是否为空,是返回true,否则返回false |
size() | 返回有效数据的个数 |
top() | 返回优先级队列中最大(最小元素),即堆顶元素 |
push() | 在优先级队列中插入元素,尾插 |
pop() | 删除优先级队列中最大(最小)元素,即堆顶元素 |
int main()
{
//priority_queue<int> pq; //默认大堆
//priority_queue<int, vector<int>, less<int>> pq; //大堆
priority_queue<int, vector<int>, greater<int>> pq; //小堆
pq.push(1);
pq.push(3);
pq.push(9);
pq.push(7);
pq.push(5);
while (!pq.empty())
{
cout << pq.top() << " ";
pq.pop();
}
cout << endl; //输出:1 3 5 7 9
return 0;
}
七.priority_queue的模拟实现
1.前置:仿函数的介绍
上面的less是仿函数:本质是一个类,这个类重载operator(),它的对象可以像函数一样使用。
template<class T>
class Less //小于号
{
public:
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
template<class T>
class Greater //大于号
{
public:
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
int main()
{
//类实例化对象
Less<int> LessFunc;
Greater<int> GreaterFunc;
//仿函数:本质是一个类,这个类重载operator(),它的对象可以像函数一样使用
cout << LessFunc(1, 2) << endl; //有名对象
cout << Less<int>()(1, 2) << endl; //匿名对象
cout << LessFunc.operator()(1, 2) << endl; //本质
return 0;
}
排序时可以用仿函数替代函数指针,如下:
//函数指针写法
int compare(int x, int y)
{
return x > y;
}
//回调函数cmp:通过函数指针调用的函数
void BubbleSort(int* a, int n, int(*cmp)(int, int))
{
for (int i = 0; i < n - 1; i++)
{
int flag = 1;
for (int j = 0; j < n - i - 1; j++)
{
if (cmp(a[j], a[j + 1])) //通过函数指针回调compare函数,进行比较大小
{
swap(a[j], a[j + 1]);
flag = 0;
}
}
if (flag == 1)
{
break;
}
}
}
int main()
{
int a[] = { 1,9,5,4,6,8,2,3,7 };
BubbleSort(a, 9, compare);
return 0;
}
//仿函数写法:本质是一个类,这个类重载operator(),它的对象可以像函数一样使用
// < 升序
template<class T>
class Less
{
public:
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
// > 降序
template<class T>
class Greater
{
public:
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
template<class T, class Compare>
void BubbleSort(T* a, int n, Compare com)
{
for (int i = 0; i < n - 1; i++)
{
int flag = 1;
for (int j = 0; j < n - i - 1; j++)
{
//if (a[j] > a[j + 1]) 直接比较大小
if(com(a[j + 1], a[j])) //com是类的对象调用operator(), 完成比较大小
{
swap(a[j], a[j + 1]);
flag = 0;
}
}
if (flag == 1)
{
break;
}
}
}
int main()
{
//类实例化对象
Less<int> LessFunc; // < 升序
Greater<int> GreaterFunc; // > 降序
int a[] = {1,9,5,4,6,8,2,3,7};
//函数模版显示实例化传入类名,函数的参数传入类实例化的对象,也可以是匿名对象
//BubbleSort<int, Less<int>>(a1, 9, LessFunc); //有名对象
//BubbleSort<int, Less<int>>(a1, 9, Less<int>()); //匿名对象
//这里函数模版可以无需显示实例化,只需传入函数参数,编译器会自动推导函数模版的类型
BubbleSort(a, 9, LessFunc); //有名对象,升序
BubbleSort(a, 9, Less<int>()); //匿名对象,升序
BubbleSort(a, 9, GreaterFunc); //有名对象,降序
BubbleSort(a, 9, Greater<int>()); //匿名对象,降序
return 0;
}
class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
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);
}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
class DateLess
{
public:
bool operator()(Date* p1, Date* p2)
{
return *p1 < *p2;
}
};
class DateGreater
{
public:
bool operator()(Date* p1, Date* p2)
{
return *p1 > *p2;
}
};
int main()
{
//当优先级队列存储的时自定义类型时,由于内部存在比较大小,我们自己需要重载operator大于、小于号
priority_queue<Date> q1;
q1.push(Date(2024, 8, 29));
q1.push(Date(2024, 8, 30));
q1.push(Date(2024, 8, 31));
cout << q1.top() << endl;
q1.pop();
cout << q1.top() << endl;
q1.pop();
cout << q1.top() << endl;
q1.pop();
cout << endl;
//当优先级队列存储的时自定义类型的指针时,比较的是地址的大小,无意义,需要自己写仿函数
priority_queue<Date*> q2;
q2.push(new Date(2024, 8, 29));
q2.push(new Date(2024, 8, 30));
q2.push(new Date(2024, 8, 31));
cout << *q2.top() << endl;
q2.pop();
cout << *q2.top() << endl;
q2.pop();
cout << *q2.top() << endl;
q2.pop();
cout << endl;
//自己写仿函数,实现比较大小
priority_queue<Date*, vector<Date*>, DateLess> q3;
q3.push(new Date(2024, 8, 29));
q3.push(new Date(2024, 8, 30));
q3.push(new Date(2024, 8, 31));
cout << *q3.top() << endl;
q3.pop();
cout << *q3.top() << endl;
q3.pop();
cout << *q3.top() << endl;
q3.pop();
return 0;
}
2.模拟实现
namespace xzy
{
// < 升序
template<class T>
class Less
{
public:
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
// > 降序
template<class T>
class Greater
{
public:
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(){}
~priority_queue(){}
//向上调整算法:维持堆的特点
void AdjustUp(int child)
{
Compare cmp; //实例化对象
int parent = (child - 1) / 2;
while (child > 0)
{
//if (_con[child] > _con[parent]) 孩子 > 父亲,交换,建大堆
if(cmp(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
child = parent;
parent = (child - 1) / 2;
}
else
{
break;
}
}
}
//尾插
void push(const T& x)
{
//尾插
_con.push_back(x);
//向上调整堆
AdjustUp(size() - 1);
}
void AdjustDown(int parent)
{
Compare cmp; //实例化对象
//假设左孩子最大
int child = parent * 2 + 1;
while (child < size())
{
//找出真正最大的那个孩子
//if (child + 1 < size() && _con[child + 1] > _con[child])
if (child + 1 < size() && cmp(_con[child], _con[child + 1]))
{
++child;
}
//if (_con[child] > _con[parent])
if (cmp(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
//头删
void pop()
{
//交换堆顶与堆尾的数据
swap(_con[0], _con[size() - 1]);
//尾删
_con.pop_back();
//向下调整堆
AdjustDown(0);
}
const T& top() const
{
return _con.front();
}
bool empty() const
{
return _con.empty();
}
size_t size() const
{
return _con.size();
}
private:
Container _con;
};
}
int main()
{
//利用仿函数可以灵活的实现大小堆
//xzy::priority_queue<int, vector<int>, Less<int>> pq; //大堆
xzy::priority_queue<int, vector<int>, Greater<int>> pq; //小堆
pq.push(15);
pq.push(24);
pq.push(50);
pq.push(6);
pq.push(19);
pq.push(29);
pq.push(7);
while (!pq.empty())
{
cout << pq.top() << " ";
pq.pop();
}
cout << endl; //输出:6 7 15 19 24 29 50
return 0;
}
3.关于堆的算法
int main()
{
int myints[] = { 10,20,30,5,15 };
//vector的迭代器构造,也支持原生指针,原因是物理空间是连续的
vector<int> v(myints, myints + 5);
make_heap(v.begin(), v.end()); //先建堆,默认是大堆
cout << "initial max heap : " << v.front() << '\n';
//堆的头删
pop_heap(v.begin(), v.end()); //交换堆顶与堆尾的数据,再向下调整恢复成堆
v.pop_back(); //尾删
cout << "max heap after pop : " << v.front() << '\n';
//堆的尾插
v.push_back(99); //尾插
push_heap(v.begin(), v.end()); //向上调整恢复成堆
cout << "max heap after push: " << v.front() << '\n';
sort_heap(v.begin(), v.end()); //堆排序
cout << "final sorted range :";
for (unsigned i = 0; i < v.size(); i++)
{
cout << v[i] << " ";
}
cout << endl;
return 0;
}
八.栈和队列OJ题
class MinStack {
public:
//1.初始化列表是成员变量定义的地方,成员变量在初始化列表中,就用初始化列表中的值
//2.若没有初始化列表
// 对于内置类型有缺省值就用缺省值,没有的话取决于编译器,大概率是随机值
// 对于自定义类型自动调用它的默认构造,没有默认构造则编译错误
//3.同理无需写析构,编译器会自动调用它的析构
MinStack() {}
void push(int val)
{
//val入栈_st
_st.push(val);
//若_minst为空 或者 val小于等于_minst的栈顶元素:val入栈_minst
if(_minst.empty() || val <= _minst.top())
{
_minst.push(val);
}
}
void pop()
{
//若_st的栈顶元素等于_minst的栈顶元素:_minst出栈
if(_st.top() == _minst.top())
{
_minst.pop();
}
//_st出栈
_st.pop();
}
int top()
{
return _st.top();
}
int getMin()
{
return _minst.top();
}
private:
stack<int> _st;
stack<int> _minst;
};
class Solution {
public:
bool IsPopOrder(vector<int>& pushV, vector<int>& popV)
{
stack<int> st;
int popi = 0;
for(auto& e : pushV)
{
st.push(e); //入栈
//栈顶数据与出栈序列是否相等,判断是否出栈
while(!st.empty() && st.top() == popV[popi])
{
st.pop();
popi++;
}
}
return st.empty(); //返回栈是否为空
}
};
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root)
{
vector<vector<int>> vv;
queue<TreeNode*> q;
int levelSize = 0; //记录某一层数据的个数
if(root != nullptr)
{
q.push(root);
levelSize = 1;
}
while(!q.empty())
{
//当前层数据的个数,控制数据一层一层的出
vector<int> v;
while(levelSize--)
{
TreeNode* front = q.front(); //保留队头指针
v.push_back(front->val); //尾差队头指针中的数据
q.pop(); //出队
if(front->left != nullptr) //左孩子不为空,入队
{
q.push(front->left);
}
if(front->right != nullptr) //右孩子不为空,入队
{
q.push(front->right);
}
}
vv.push_back(v);
//当前层出完,下一层都进队列了,队列的size就是下一层的数据个数
levelSize = q.size();
}
return vv;
}
};