栈和队列面试题（Java语言实现）
1.括号匹配问题。
给定一个包含"{","}","[","]","(",")"的字符串，判断字符串是否有效。
思路：依次遍历字符串中的每个字符，如果是左括号，如“{","[","("，就入栈；如果是右括号，如”}“，”]“，”)"，先判断栈是否为空，如果栈为空，说明没有元素与它匹配，一定不符合，直接返回false；如果栈不为空，取栈顶元素，看该元素是否与栈顶元素匹配，如果匹配，则继续比较，不匹配，直接返回false。遍历完所有的字符之后，如果栈为空，说明所有的括号都匹配；否则说明不匹配。
class Solution {
public boolean isValid(String s) {
Stack stack=new Stack<>();
for(int i=0;i 2.用队列实现栈
用队列实现栈的操作：push(int x),pop(),top(),empty()。
思路：用链表定义队列，则入栈相当于链表的尾插操作，出栈相当于尾删操作。利用链表的getLast()--返回链表的最后一个元素；removeLast()--删除并返回最后一个元素；addLast(int v)--将指定元素添加到链表末尾。
class MyStack {
private LinkedList queue;
/** Initialize your data structure here. */
public MyStack() {
this.queue=new LinkedList<>();
}
/** Push element x onto stack. */
public void push(int x) {
this.queue.addLast(x);
}
/** Removes the element on top of the stack and returns that element. */
public int pop() {
return this.queue.removeLast();
}
/** Get the top element. */
public int top() {
return this.queue.getLast();
}
/** Returns whether the stack is empty. */
public boolean empty() {
return this.queue.size()==0?true:false;
}
}
/**
* 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.用两个栈实现一个队列
思路：设两个栈in和out，在in栈上入队列，如果要出队列，在out栈上进行操作。如果out栈为空，则依次将in栈中的数据出栈，并同时入栈到out栈中，最后再执行out.pop()实现出栈。判断队列为空，当in栈和out栈都是空时，队列为空。
主要使用了栈的pop()、push(E v)、isEmpty()。
class MyQueue {
Stack in;
Stack out;
/** Initialize your data structure here. */
public MyQueue() {
in=new Stack<>();
out=new Stack<>();
}
/** Push element x to the back of queue. */
public void push(int x) {
in.push(x);
}
/** Removes the element from in front of queue and returns that element. */
public int pop() {
if (out.isEmpty()) {
while (!in.isEmpty()) {
int v = in.pop();
out.push(v);
}
}
return out.pop();
}
/** Get the front element. 获取队头元素*/
public int peek() {
if(!out.isEmpty()){
return out.peek();
}
//栈in的栈底元素
if (out.isEmpty()) {
while (!in.isEmpty()) {
int v = in.pop();
out.push(v);
}
}
return out.peek();
}
/** Returns whether the queue is empty. */
public boolean empty() {
return in.isEmpty()&&out.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();
*/ 4.实现一个最小栈
设计一个支持push，pop,top操作，并能在常数时间内检索到最小元素的栈。
push(x)--将元素x推入栈中。 pop()--删除栈顶的元素。 top()--获取栈顶元素 getMin()--检索栈中的最小元素。
思路：设计两个栈，normal和min。normal栈和正常栈的操作相同，min栈的栈顶始终存放最小元素（便于获取最小元素的时间复杂度为O(1))。psuh(x)操作，normal直接将x压栈，min栈，如果此时栈为空，那么直接入栈；否则和min栈的栈顶元素比较，如果x小于min的栈顶元素，则将x入栈。否则再将min的栈顶元素再次入栈。pop()操作，两个栈同时执行pop()。top()，normal栈中操作；getMin()，由min栈操作。
class MinStack {
Stack normal;
Stack min;//最小栈
/** initialize your data structure here. */
public MinStack() {
normal=new Stack<>();
min=new Stack<>();
}
public void push(int x) {
normal.push(x);//直接入栈
if(min.isEmpty()){
min.push(x);
}else{
int y=x 5.设计循环队列
题目描述见https://leetcode-cn.com/problems/design-circular-queue/
class MyCircularQueue {
private int[] array;
private int size;
private int front;//队首元素的下标
private int rear;//下一个可用位置的下标
/** Initialize your data structure here. Set the size of the queue to be k. */
public MyCircularQueue(int k) {
this.array=new int[k];
this.size=0;
this.front=0;
this.rear=0;
}
/** Insert an element into the circular queue. Return true if the operation is successful. */
public boolean enQueue(int value) {
if(this.size==this.array.length){
return false;
}
this.array[this.rear]=value;
this.rear=(this.rear+1)%this.array.length;
this.size++;
return true;
}
/** Delete an element from the circular queue. Return true if the operation is successful. */
public boolean deQueue() {
if(this.size==0){
return false;
}
this.front=(this.front+1)%this.array.length;
this.size--;
return true;
}
/** Get the front item from the queue. */
public int Front() {
if(this.size==0){
return -1;
}
return this.array[this.front];
}
/** Get the last item from the queue. */
public int Rear() {
if(this.size==0){
return -1;
}
int index=(this.rear-1+this.array.length)%this.array.length;
return this.array[index];
}
/** Checks whether the circular queue is empty or not. */
public boolean isEmpty() {
return this.size==0;
}
/** Checks whether the circular queue is full or not. */
public boolean isFull() {
return this.size==this.array.length;
}
}
/**
* 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();
*/6.栈的压入、弹出序列
题目描述：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有哦数字均不相等。例如序列1，2，3，4，5是某栈的压入顺序，序列4，5，3，2，1是该压栈序列对应的一个弹出序列，但4，3，5，1，2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
import java.util.ArrayList;
import java.util.*;
/**
思路：新建一个栈，对pushA的每个元素进行入栈，每次入栈时，都要判断popA的元素是否市栈顶元素，如果是，则进行出栈；
同时，popA的下标++.最后如果栈不为空，说明不是；栈为空，则是。
*/
public class Solution {
public boolean IsPopOrder(int [] pushA,int [] popA) {
Stack stack=new Stack();
if(pushA.length!=popA.length){
return false;
}
int curIndex=0;
for(int i=0;i