棧,佇列,優先順序佇列簡單介面使用

棧,佇列,優先順序佇列簡單介面使用

對於棧要實現成的介面:

棧滿足先入後出的性質

1.stack() 構造棧
2.push() 入棧操作
3.pop() 出棧操作
4.empty() 判空操作
5.size() 判定棧中有效元素的大小
6.top() 獲取棧頂元素

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

void test1() {
	stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	st.push(4);
	st.push(5);
	cout << "棧中有效元素的大小: " << st.size() << endl;
	while (!st.empty()) {
		cout << st.top() << " ";
		st.pop();
	}
	cout << endl;
}

int main () {
	test1();
    system("color A");
    system ("pause");
    return 0;
}

執行結果:

最小棧

解題思路:

1.藉助兩個棧來完成 st 和 Minst
2. 入棧步驟: st始終都是要入棧,Minst要有條件,1>Minst.empty() || x<= Minst.top()
3. 出棧步驟: st始終都要出棧操作, Minst出棧有條件 要有條件1> st.top() == Minst.top()
4. 最後獲得各自的頂部元素

class MinStack { 
	private:
		stack<int> st; //構建一個普通棧
		stack<int> Minst; 構建一個最小普通棧
	public:
		/** initialize your data structure here. */
		MinStack() {
		}
	
		void push(int x) {
			//入棧操作
			//最小棧中一定存放的是最小的元素
			if (Minst.empty() || x <= Minst.top())
				Minst.push(x);
	
			st.push(x);//普通棧裡面直接存放元素
		}
	
		void pop() {
			if (st.top() == Minst.top())
				Minst.pop();
	
			st.pop();
		}
	
		int top() {
			return st.top();
		}
	
		int getMin() {
			return Minst.top();
		}
	};

棧的壓入,彈出順序

彈出元素滿足條件: 出棧必須滿足不是空,同時棧頂的元素是不是等於出棧序列的元素

入棧(只要元素沒有放完就一直進行入棧操作)

class Solution {
public:
	bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
		//vector<int>& pushed和vector<int>& popped表示入棧序列和出棧序列
		int pushidx = 0;
		int popidx = 0;
		stack<int> st;
		while (pushidx < pushed.size()) {
			st.push(pushed[pushidx++]);//入棧(只要元素沒有放完就一直進行入棧操作) 
			//出棧必須滿足不是空,同時棧頂的元素是不是等於出棧序列的元素
			while (!st.empty() && st.top() == popped[popidx]) {
				st.pop();
				popidx++;
			}
		}
		return st.empty();
	}
};

對於佇列要實現成的介面:

佇列滿足先入先出的性質

1.queue() 構造空的佇列
2.push() 入隊操作
3.pop() 出隊操作
4.front() 隊頭
5.back() 隊尾
6.size() 有效元素
7.empty()判空

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

void test2() {
	queue<int> q;
	q.push(1);
	q.push(2);
	q.push(3);
	q.push(4);
	q.push(5);
	cout << "佇列長度" << q.size() << endl;
	while (!q.empty()) {
		cout << q.front() << " ";
		q.pop();
	}
	cout << endl;

}
int main () {
	test2();
    system("color A");
    system ("pause");
    return 0;
}

執行結果:

優先順序佇列簡單介面使用

priority_queue: 底層的實現是通過堆來完成的.

1. priority_queue() 構造一個空的優先順序佇列
   2.empty() 檢查優先順序佇列是否為空
   3.top() 返回佇列中的最(小)大元素,即堆頂元素
   4.push() 在優先順序佇列中插入元素
   5.刪除優先順序佇列中最大(小)元素,即堆頂元素

1.prioroty_queue簡單介面使用

本身預設優先順序佇列是建大堆

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

void test1() {
	priority_queue<int> pq;
	pq.push(10);
	pq.push(1);
	pq.push(15);
	pq.push(20);
	pq.push(2);
	pq.push(4);
	pq.push(19);
	while (!pq.empty()) {
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;

}

int main () {
	test1();
    system("color A");
    system ("pause");
    return 0;
}

預設建的是大堆
執行結果

本身預設優先順序佇列是建大堆,但是可以通過括號運算子過載的方式進行大小堆的任意切換重建.

2.如何實現括號運算子過載實現大小堆的任意重建.

借用仿函式類别範本:

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

class S{
public:
	S(int a = 0,int b = 0,int c = 0) 
		:_a(a)
		, _b(b)
		, _c(c)
	{}
	bool operator<(const S& c) const{
		return _a < c._a;
		}
	bool operator>(const S& c) const{
		return _a > c._a;
	}

	int _a;
	int _b;
	int _c;

};

template<class T>
struct Less {

	bool operator()(const T& c1, const T& c2) {
		return c1 < c2; //這塊會呼叫過載函式
	}
};

template<class T>

struct Greater{
	bool operator()(const T& c1, const T& c2) {
		return c1 > c2;
	}
};

ostream& operator<<(ostream& cout, const S& c) {
	cout << c._a << "-" << c._b << "-" << c._c << endl;
	return cout;
}
void test1() {
	priority_queue<S, vector<S>, Greater<S>> pq;  //建小堆
	//priority_queue<S, vector<S>, Greater<S>> pq;  //建小堆
	pq.push(S(1, 1, 1));
	pq.push(S(2, 1, 1));
	pq.push(S(3, 1, 1));
	while (!pq.empty()) {
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;
}
int main () {
	test1();
    system("color A");
    system ("pause");
    return 0;
}

執行結果: