栈和队列面试题(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

 

你可能感兴趣的:(Java,数据结构)