栈和队列
一、栈
1.1栈的概念
- 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈
顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。 - 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
- 出栈：栈的删除操作叫做出栈。出数据在栈顶。
1.2栈的常用函数
| 函数 | 解释 |
|---|---|
| E push(E item) | 压栈 |
| E pop(E item) | 出栈 |
| E peek(E item) | 查看栈顶元素 |
| boolean empty（） | 判断栈是否为空 |
1.3代码实现栈
public class MyStack {
// 简单起见，我们就不考虑扩容问题了
private int[] array = new int[100];
private int size = 0;
public void push(int v) {
array[size++] = v;
}
//出栈并且返回栈顶的值
public int pop() {
return array[--size];
}
//返回栈顶的值但不出栈
public int peek() {
return array[size - 1];
}
//判断数组是否为空
public boolean isEmpty() {
return size == 0;
}
//返回栈顶值
public int size() {
return size;
}
}
二、队列
2.1队列的概念
- 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出
- 入队列：进行插入操作的一端称为队尾
- 出队列：进行删除操作的一端称为队头
2.2队列的常用函数
| 函数 | 解释 |
|---|---|
| E offer(E item) | 入队 |
| E poll(E item) | 出队 |
| E peek(E item) | 查看栈顶元素 |
| boolean empty（） | 判断栈是否为空 |
2.3队列的实现
- 队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上
出数据，效率会比较低。
class Node {
int val;
Node next;
Node(int val, Node next) {
this.val = val;
this.next = next;
}
Node(int val) {
this(val, null);
}
}
public class MyQueue {
private Node head = null;
private Node tail = null;
private int size = 0; //size记录队列的长度
//入队
public void offer(int v) {
Node node = new Node(v);
if (tail == null) {
head = node;
} else {
tail.next = node;
}
tail = node;
size++;
}
//出队 并返回出队的值
public int poll() {
if (size == 0) {
throw new RuntimeException("队列为空");
}
Node oldHead = head;
head = head.next;
if (head == null) {
tail = null;
}
size--;
return oldHead.val;
}
//返回队顶元素 但不出队
public int peek() {
if (size == 0) {
throw new RuntimeException("队列为空");
}
return head.val;
}
//判断队列是否为空
public boolean isEmpty() {
return size == 0;
}
//队列的长度
public int size() {
return size;
}
}
三、栈队列相关面试题
3.1 括号匹配问题。
- 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：左括号必须用相同类型的右括号闭合、左括号必须以正确的顺序闭合。
1.解题思路
- 定义一个 i 坐标遍历字符串，若是左括号则进栈
- 若是有右括号，则出栈看是否与 i 坐标标的字符匹配
- 若匹配则 i 继续遍历 若不匹配则返回false
- 若 i 遍历完栈中还有值 则左括号个数大于有括号个数 则返回false
- 若栈为空 且 i 还没有遍历完，则返回 false
- 若 i 也遍历完了，栈也为空 则括号匹配 返回true
class Solution {
public boolean isValid(String s) {
//1.定义一个栈，来存放左括号
Stack<Character> stack=new Stack<>();
if(s==null || s.length() ==0){
return true;
}
//2.开始遍历当前字符串
for(int i=0;i<s.length();i++){
//获取当前i下标
char ch=s.charAt(i);
//判断当前字符是哪个左括号,进栈
if(ch=='(' || ch=='[' || ch =='{'){
stack.push(ch);
}else {
//进入else， 说明是右括号
//先判断栈是否为空,若为空则返回 false
if(stack.empty()){
return false;
}
//获取栈顶元素的值
char tmp=stack.peek();
if(tmp=='(' && ch==')'|| tmp=='[' && ch==']' || tmp=='{' && ch=='}'){
//当前匹配成功 出栈
stack.pop();
}else{
return false;
}
}
}
//把字符串遍历完
if(stack.empty()) {
return true;
}else{
return false;
}
}
}
3.2 用队列实现栈。
225. 用队列实现栈
请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
实现 MyStack 类：
- void push(int x) 将元素 x 压入栈顶。
- int pop() 移除并返回栈顶元素。
- int top() 返回栈顶元素。
- boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。
注意：
- 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
- 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
- 解题思路
1.初始化两个队列
2.入栈：第一次入栈，入哪个队列都可以，之后入栈入到不为空的队列
3.出栈：将不为空的队列只保留一个元素其余元素全部出队，并入队到另一个空队列，最后将保留的元素出队并返回即为出栈
class MyStack {
private Queue<Integer> qu1;
private Queue<Integer> qu2;
public MyStack() {
qu1=new LinkedList<>();
qu2=new LinkedList<>();
}
public void push(int x) {
//qu1为空则将元素入队qu1
if(!qu1.isEmpty()){
qu1.offer(x);
}else if(!qu2.isEmpty()){ qu2为空则将元素入队qu2
qu2.offer(x);
}else { //两队都为空 放入指定qu1中
qu1.offer(x);
}
}
public int pop() {
if(empty()){
return -1;
}
//找到不为空的队列
if(!qu1.isEmpty()){ //qu1不为空
int size=qu1.size();
for(int i=0;i<size-1;i++){
int x=qu1.poll(); //只保留一个元素其余元素都出队
qu2.offer(x); //出队后进入空队列
}
return qu1.poll();
}else{ //qu2不为空
int size=qu2.size();
for(int i=0;i<size-1;i++){
int x=qu2.poll(); //只保留一个元素其余元素都出队
qu1.offer(x); //出队后进入空队列
}
return qu2.poll();
}
}
public int top() {
if(empty()){
return -1;
}
//找到不为空的队列
if(!qu1.isEmpty()){
int size=qu1.size();
int x=-1;
for(int i=0;i<size;i++){ //将有元素的队列全部出队 则最后一次x的值为栈顶元素
x=qu1.poll();
qu2.offer(x);
}
return x;
}else{
int size=qu2.size();
int x=-1;
for(int i=0;i<size;i++){
x=qu2.poll();
qu1.offer(x);
}
return x;
}
}
public boolean empty() {
return qu1.isEmpty()&&qu2.isEmpty();
}
}
/**
* Your MyStack object will be instantiated and called as such:
* MyStack obj = new MyStack();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.top();
* boolean param_4 = obj.empty();
*/
3.3 用栈实现队列。
232.用栈实现队列
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
- void push(int x) 将元素 x 推到队列的末尾
- int pop() 从队列的开头移除并返回元素
- int peek() 返回队列开头的元素
- boolean empty() 如果队列为空，返回 true ；否则，返回 false
说明：
- 你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
- 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
- 解题思路
1.先初始化两个栈（s1 、s2）
2 入队：将元素入到栈s1中
3.出队：若s2不为空则出s2的栈顶元素，若s2为空，将s1中所有元素放去s2 ，出s2的栈顶元素
class MyQueue {
private Stack<Integer> s1;
private Stack<Integer> s2;
public MyQueue() {
s1=new Stack<>();
s2=new Stack<>();
}
public void push(int x) {
//将元素都入到s1
s1.push(x);
}
public int pop() {
//若队列为空返回 -1；
if(empty()){
return -1;
}
if(!s2.isEmpty()){//若s2 不为空则 出s2栈顶元素
return s2.pop();
}else { //s2为空
int size=s1.size();
for(int i=0;i<size;i++){ //将s1中所有元素放去s2中
int x=s1.pop();
s2.push(x);
}
}
return s2.pop(); //出s2栈顶元素
}
public int peek() {
if(empty()){
return -1;
}
if(!s2.isEmpty()){
return s2.peek(); //返回s2栈顶元素，但不不栈
}else {
int size=s1.size();
for(int i=0;i<size;i++){
int x=s1.pop();
s2.push(x);
}
}
return s2.peek();//返回s2栈顶元素，但不不栈
}
public boolean empty() {
return s1.isEmpty()&&s2.isEmpty(); //两个栈都为空则队列为空
}
}
/**
* Your MyQueue object will be instantiated and called as such:
* MyQueue obj = new MyQueue();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.peek();
* boolean param_4 = obj.empty();
*/
3.4 实现一个最小栈。
155. 最小栈
设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
- push(x) —— 将元素 x 推入栈中。
- pop() —— 删除栈顶的元素。
- top() —— 获取栈顶元素。
- getMin() —— 检索栈中的最小元素。
- 解题思路
class MinStack {
private Stack<Integer> stack;
private Stack<Integer> minStack;
public MinStack() {
stack=new Stack<>();
minStack=new Stack<>();
}
public void push(int val) {
//先给普通栈 放元素
stack.push(val);
if(minStack.empty()){
minStack.push(val);
}else{
// 1、获取到当前的最小栈的栈顶元素
int top =minStack.peek();
// 2、谁小就要把谁放进minStack
if(top >= val){
minStack.push(val);
}
}
}
public void pop() {
int n=stack.pop();
if(!minStack.empty()){
int top=minStack.peek();
if(top==n){
minStack.pop();
}
}
}
public int top() {
if(stack.empty()){
return -1;
}
return stack.peek();
}
public int getMin() {
if(minStack.empty()){
return -1;
}
return minStack.peek();
}
}
/**
* Your MinStack object will be instantiated and called as such:
* MinStack obj = new MinStack();
* obj.push(val);
* obj.pop();
* int param_3 = obj.top();
* int param_4 = obj.getMin();
*/
3.5 设计循环队列。
- 设计循环队列
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：
- MyCircularQueue(k): 构造器，设置队列长度为 k 。
- Front: 从队首获取元素。如果队列为空，返回 -1 。
- Rear: 获取队尾元素。如果队列为空，返回 -1 。
- enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
- deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
- isEmpty(): 检查循环队列是否为空。
- isFull(): 检查循环队列是否已满。
- 解题思路
class MyCircularQueue {
private int []elem; //数组
private int front; //头
private int rear; //当前可以存放元素的下标
public MyCircularQueue(int k) {
this.elem=new int [k+1];
}
public boolean enQueue(int value) {
if(isFull()) return false;//如果是满的不能放 返回false
this.elem[this.rear]=value; //放去元素
this.rear=(this.rear+1)%this.elem.length; //自增
return true;
}
public boolean deQueue() {//删除相当于出队
if(isEmpty()) return false;//如果是空 返回false
this.front=(this.front+1)%this.elem.length; //front自增 后面添加的元素会覆盖
return true;
}
public int Front() {//得到队头元素
if(isEmpty()) return -1; //如果为空 返回-1
return this.elem[front]; //不为空返回front下标对应的值
}
public int Rear() {//获取队尾元素
if(isEmpty()) return -1; //若为空 返回-1
//若rear==0则 队尾元素坐标为数组长度-1 ，其余情况为rear-1
int index=(this.rear==0)?this.elem.length-1:this.rear-1;
return this.elem[index];
}
public boolean isEmpty() {//若rear==front则队列为空
return this.rear==this.front;
}
public boolean isFull() {//若rear的下个坐标为front 则循环队列为满
if((this.rear+1)%this.elem.length==this.front){
return true;
}else return false;
}
}
/**
* Your MyCircularQueue object will be instantiated and called as such:
* MyCircularQueue obj = new MyCircularQueue(k);
* boolean param_1 = obj.enQueue(value);
* boolean param_2 = obj.deQueue();
* int param_3 = obj.Front();
* int param_4 = obj.Rear();
* boolean param_5 = obj.isEmpty();
* boolean param_6 = obj.isFull();
*/
2998
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
