栈和队列的实现

       本文用链表的方法实现了Stack和Queue，又分别用两个刚刚实现的Stack实现了Queue，用两个Queue实现了Stack；栈和队列的实现有很多，本文只是提供了一种思路，如果大家有更简洁、高效的思路，欢迎留言。

结点

package com.vapy.diy.stackAndQueue;
/**
 * 
 * @author vapy
 *
 */
public class Node {
    private int date;
    //use for stack
    Node pre;
    //use for queue
    Node next;

    public int getDate() {
        return date;
    }

    public Node(int date) {
        this.date = date;
    }
}

栈的实现（先进后出FILO）

package com.vapy.diy.stackAndQueue;
/**
 * 
 * @author vapy
 *
 */
public class Stack<T extends Node> {
    private Node head;
    private Node current;
    private int size = 0;

    public void push(Node node) {
        if(null == head){
            head = node;
            current = head;
        } else {
            node.pre = current;
            current = node;
        }
        size ++;
    }

    public Node pop(){
        if(null == head){
            return null;
        }
        Node node = current;
        current = current.pre;
        size --;
        return node;
    }

    public int size(){
        return size;
    }
}

队列的实现（先进先出FIFO）

package com.vapy.diy.stackAndQueue;
/**
 * 
 * @author vapy
 *
 */
public class Queue<T extends Node> {
    private Node head;
    private Node current;
    private int size = 0;

    public void push(Node node) {
        if (null == head) {
            head = node;
            current = head;
        }
        else {
            current.next = node;
            current = current.next;
        }
        size ++;
    }

    public Node pop() {
        if (null == head) {
            return null;
        }
        Node node = head;
        head = head.next;
        size --;
        return node;
    }

    public int size(){
        return size;
    }
}

两个队列实现一个栈

思路：把数据存入queue1中（举例：queue1中有1、2、3，queue2为空），每次pop时，把queue1中的数据弹出到queue2中，只留下一个（queue1中留下3，queue2中有1、2），把这一个返回，返回前，将queue1指向queue2指向的对象，将queue2指向一个空的队列（queue1中有1、2，queue2为空），即可实现FILO

package com.vapy.diy.stackAndQueue;
/**
 * 
 * @author vapy
 * 
 * 通过两个Queue实现Stack
 * 
 */
public class StackByQueue<T extends Node> {
    private Queue<Node> queue1 = new Queue<Node>();
    private Queue<Node> queue2 = new Queue<Node>();

    public void push(Node node) {
        queue1.push(node);
    }

    public Node pop() {
        if (0 == queue1.size()) {
            return null;
        }
        while (queue1.size() > 1) {
            queue2.push(queue1.pop());
        }
        Node node = queue1.pop();
        //此处也可把queue2中的元素全移到queue1
        queue1 = queue2;
        queue2 = new Queue<Node>();
        return node;
    }
}

两个栈实现一个队列

思路：把数据存入stack1中（举例：stack1中有1、2、3，stack2为空），每次pop时，把数据弹出到stack2中，只留下一个数据（stack1中有1，stack2中有3、2），把这个数据返回，返回前，将stack2中的数据全部弹出到stack1中（stack1中有2、3，stack2为空），即可实现FIFO

package com.vapy.diy.stackAndQueue;
/**
 * 
 * @author vapy
 * 
 * 通过两个stack实现queue
 *
 */
public class QueueByStack<T extends Node> {
    private Stack<Node> stack1 = new Stack<Node>();
    private Stack<Node> stack2 = new Stack<Node>();

    public void push(Node node){
        stack1.push(node);
    }

    public Node pop(){
        if(0 == stack1.size()){
            return null;
        }
        while(stack1.size() > 1){
            stack2.push(stack1.pop());
        }
        Node node = stack1.pop();
        while(stack2.size() > 0){
            stack1.push(stack2.pop());
        }
        return node;
    }
}