自定义栈的实现及使用两个栈模拟队列

一，使用单链表实现栈

①栈需要一个栈顶指针

②栈的基本操作有出栈和入栈，以及判断栈是否为空

③单链表中每个结点表示一个栈元素，每个结点有指向下一个结点的指针。因此，在栈内部需要实现一个单链表。代码如下：

public class Stack<T extends Comparable<? super T>>{
    private class Node{
        T ele;
        Node next;
        
        public Node(T ele) {
            this.ele = ele;
        }
    }
    
    Node top;//栈顶指针
    
    public void push(T ele){
        Node n = new Node(ele);
        n.next = top;
        top = n;
    }
    public T pop(){
        if(top != null)
        {
            Node tmp = top.next;
            T ele = top.ele;
            top.next = null;
            top = tmp;
            return ele;
        }
        return null;
    }
    
    public boolean isEmpty(){
        return top == null;
    }
}

二，使用两个栈实现队列

①栈是先进后出，而队列是先进先出。要实现队列，就需要实现队列的基本操作，并使基本操作满足先进先出的特点。

②这里需要两个栈，一个是enStack，当有元素入队列时，一律Push到这个栈中。另一个栈是deStack，当有元素出队列时：

先检查deStack是否为空，若不为空，则从deStack中pop元素出去，作为出队列的元素。当deStack为空时，将enStack中的元素出栈，放push进deStack中，然后再从deStack中出栈。

如果enStack 和 deStack 都为空，则出队列操作返回null，代码实现如下：

public class MyQueue<T extends Comparable<? super T>> {
    private Stack<T> enStack;
    private Stack<T> deStack;
    
    public MyQueue() {
        enStack = new Stack<T>();
        deStack = new Stack<T>();
    }
    
    public void enqueue(T ele){
        enStack.push(ele);
    }
    
    public T dequeue(){
        if(!deStack.isEmpty())
        {
            return deStack.pop();
        }
        while(!enStack.isEmpty()){
            deStack.push(enStack.pop());
        }
        return deStack.pop();
    }
    
    public boolean isEmpty(){
        return enStack.isEmpty() && deStack.isEmpty();
    }
｝

总结：不管是用栈模拟队列，还是用队列模拟栈，其本质都是如何一种数据结构的特性去实现另一种数据结构的特性。