Java程序员面试笔试宝典之栈和队列-CSDN博客

1、栈

（1）实现一个栈
用数组实现一个栈：

import java.util.Arrays;

/**
 * 使用数组实现栈
 */
public class MyStack1<E> {
    private Object [] stack;
    private int size;//数组中存储元素的个数
    public MyStack1(){
        stack=new Object[10];//初始长度为10
    }

    //判断栈是否为空
    public boolean isEmpty(){
        return size==0;
    }
    //返回栈顶元素
    public E peek(){
        if(isEmpty()){
            return null;
        }
        return (E)stack[size-1];
    }
    //出栈
    public E pop(){
        E e=peek();
        stack[size-1]=null;
        size--;
        return e;
    }
    //入栈
    public E push(E item){
        ensureCapacity(size+1);//检查容量
        stack[size++]=item;
        return item;
    }
    //判断数组是否已满，若已满，则扩充数组空间
    private void ensureCapacity(int size){
        int len=stack.length;
        if(size>len){//数组已满
            int newLen=10;//每次数组扩充的容量
            stack=Arrays.copyOf(stack, newLen);
        }
    }

}

用链表实现一个栈：

class StackNode<E>{
    StackNode<E> next=null;
    E data;
    public StackNode(E data){
        this.data=data;
    }
}

/**
 * 使用链表实现栈
 */
public class MyStack2<E> {
    StackNode<E> top=null;//栈顶节点

    public boolean isEmpty(){
        return top==null;
    }
    public E peek(){
        if(isEmpty()){
            return null;
        }
        return top.data;
    }
    public E pop(){
        if(isEmpty()){
            return null;
        }
        E data=top.data;
        top=top.next;
        return data;
    }
    public void push(E data){
        StackNode<E> node=new StackNode<E>(data);
        node.next=top;
        top=node;
    }
}

（2）设计一个具有getMin功能的栈
具体可参考《程序员代码面试指针——左程云》

/**
 * 设计一个有getMin功能的栈
 */
import java.util.Stack;
public class MyStack3{
    private Stack<Integer> stackData;
    private Stack<Integer> stackMin;
    public MyStack3(){
        this.stackData=new Stack<Integer>();
        this.stackMin=new Stack<Integer>();
    }

    public void push(int item){
        if(this.stackMin.isEmpty()){
            this.stackMin.push(item);
        }else if(item>this.stackMin.peek()){
            this.stackMin.push(this.stackMin.peek());
        }else if(item<=this.stackMin.peek()){
            this.stackMin.push(item);
        }
        this.stackData.push(item);
    }
    public int pop(){
        if(this.stackData.isEmpty()){
            throw new RuntimeException("栈为空，不能出栈");
        }
        int data=this.stackData.pop();
        this.stackMin.pop();
        return data;
    }

    public int getMin(){
        return this.stackMin.peek();
    }

}

（3）两个队列模拟一个栈

/**
 * 使用两个队列模拟栈
 * 思路：假设使用两个队列q1,q2模拟栈S，q1为入队列，q2为出队列，可认为q1提供压栈功能，q2提供弹栈功能。
 * 要压栈，入队列q1即可，而当弹栈时，出队列则需要分两种情况：
 * ①若队列q1中只有一个元素，则让q1中的元素出队列并输出即可；
 * ②若队列q1中不止一个元素，则对列q1中所有元素出队列，入队列q2，最后一个元素不入队列q2，输出该元素，
 *  然后将队列q2所有元素入队列q1。
 */
import java.util.Queue;
import java.util.LinkedList;
public class MyStack4 <E>{
    private Queue<E> q1=new LinkedList<E>();
    private Queue<E> q2=new LinkedList<E>();

    public void push(E item){
        q1.offer(item);
    }
    public E pop(){
        if(q1.isEmpty()){
            return null;
        }
        while(q1.size()>1){
            q2.offer(q1.poll());
        }
        E data=q1.poll();
        while(!q2.isEmpty()){
            q1.offer(q2.poll());
        }
        return data;
    }
    public boolean isEmpty(){
        return q1.isEmpty();
    }

}

2、队列

（1）实现一个队列
使用数组实现一个队列：

import java.util.LinkedList;
/**
 * 使用数组实现队列
 */
public class MyQueue1<E> {
    private LinkedList<E> list=new LinkedList<E>();
    private int size=0;

    public void put(E e){
        list.addLast(e);
        size++;
    }
    public E pop(){
        size--;
        return list.removeFirst();
    }
    public boolean isEmpty(){
        return size==0;
    }
    public int size(){
        return size;
    }
}

使用链表实现一个对列：

class QueueNode<E>{
    QueueNode<E> next=null;
    E data;
    public QueueNode(E data){
        this.data=data;
    }
}

/**
 * 使用链表实现队列
 */
public class MyQueue2<E> {
    private QueueNode<E> head=null;
    private QueueNode<E> tail=null;

    //判断队列是否为空
    public boolean isEmpty(){
        return head==tail;
    }
    //入队
    public void put(E data){
        QueueNode<E> node=new QueueNode<E>(data);
        if(head==null && tail==null){
            head=node;
            tail=node;
        }else{
            tail.next=node;
            tail=node;
        }
    }
    //出队
    public E pop(){
        if(isEmpty()){
            return null;
        }
        E data=head.data;
        head=head.next;
        return data;
    }
    //队长
    public int size(){
        QueueNode<E> node=head;
        int size=0;
        while(node!=null){
            size++;
        }
        return size;
    }
}

（2）两个栈模拟一个队列

/**
 * 使用两个栈模拟队列
 * 思路：假设使用栈A与B模拟队列Q，A为插入栈，B为弹出栈，以实现队列Q.
 * 再假设A和B都为空，可以认为栈A提供入队功能，栈B提供出队列功能。要入队列，入栈A即可，而出队列需要分两种情况：
 * ①若栈B不为空，直接弹出栈B的数据
 * ②若栈B为空，则依次弹出栈A的数据，放入栈B，再弹出栈B的数据
 */
import java.util.Stack;
public class MyQueue3<E> {
    private Stack<E> A=new Stack<E>();
    private Stack<E> B=new Stack<E>();

    public void push(E item){
        A.push(item);
    }
    public E pop(){
        if(B.isEmpty()){
            while(!A.isEmpty()){
                B.push(A.pop());
            }
            return B.pop();
        }else{
            return B.pop();
        }
    }
    public boolean isEmpty(){
        return A.isEmpty() && B.isEmpty();
    }
}