栈和队列的java链表实现

1 前言

栈和队列是我们在开发中常用的两种数据接口，java中也有相关的定义的实体类java.util.Stack，java.util.Queue。不过这里不想介绍java官方的定义。想自己用链表来实现这两个数据结构。

2 栈的链表实现

栈是一种先进后出的数据结构，这个一般对外的接口有：入栈，出栈，判断是否为null，栈大小等接口。实现的代码如下：

/**
 * @author Created by qiyei2015 on 2018/3/3.
 * @version: 1.0
 * @email: 1273482124@qq.com
 * @description: 栈，链表实现
 */
public class Stack<T> implements Iterable<T>{

    public static final String TAG = "Stack";

    private int mSize;

    private Node<T> mTop;

    public Stack() {
        mTop = null;
    }

    @Override
    public Iterator<T> iterator() {
        return new StackIterator();
    }

    /**
     * 入栈
     * @param item
     */
    public void push(T item){
        //临时保存mTop
        Node<T> temp = mTop;
        //构造结点 在链表头插入
        Node<T> node = new Node<>();
        node.data = item;
        node.next = temp;
        //更新表头
        mTop = node;

        mSize++;
    }

    /**
     * 出栈
     * @return
     */
    public T pop(){
        //取值
        T t = mTop.data;
        //更新表头
        mTop = mTop.next;
        mSize--;
        return t;
    }

    /**
     * 栈大小
     * @return
     */
    public int size(){
        return mSize;
    }

    /**
     * 判断是否为空
     * @return
     */
    public boolean isEmpty(){
        return mTop == null;
    }

    /**
     * 链表节点
     * @param <T>
     */
    private class Node<T>{
        T data;
        Node next;
    }

    /**
     * 迭代器
     * @param
     */
    private class StackIterator implements Iterator<T>{

        @Override
        public boolean hasNext() {
            return mTop != null;
        }

        @Override
        public T next() {
            T t = mTop.data;
            //指向下一个结点
            mTop = mTop.next;
            return t;
        }

        @Override
        public void remove() {
            pop();
        }
    }

}

测试栈的代码如下：

        String express = "( ( ( 2 * 5 ) + ( 4 / 3 ) ) - ( 1 + 3 ) )";
        String[] array = express.split(" ");

        for (String s : array){
            stringStack1.push(s);
        }

        LogUtil.println(Stack.TAG,"stack foreach");
        for (String s : stringStack1){
            LogUtil.print(s + " ");
        }

输出结果：

Stack stack foreach
) ) 3 + 1 ( - ) ) 3 / 4 ( + ) 5 * 2 ( ( ( 

3 队列的链表实现

队列是一种后进后出的数据结构，实现如下：

/**
 * @author Created by qiyei2015 on 2018/3/3.
 * @version: 1.0
 * @email: 1273482124@qq.com
 * @description: 队列的链表实现
 */
public class Queue<T> implements Iterable<T> {

    public static final String TAG = "Queue";

    /**
     * 头结点
     */
    private Node<T> mFirst;
    /**
     * 末结点
     */
    private Node<T> mLast;

    private int mSize;

    /**
     * 入队
     * @param item
     */
    public void enqueue(T item){
        Node temp = mLast;
        mLast = new Node();
        mLast.data = item;
        mLast.next = null;

        //如果为null
        if (isEmpty()){
            mFirst = mLast;
        }else {
            temp.next = mLast;
        }
        mSize++;
    }

    /**
     * 出队
     * @return
     */
    public T dequeue(){
        T t = mFirst.data;
        mFirst = mFirst.next;
        mSize--;
        //为null需要将last置为null
        if (isEmpty()){
            mLast = null;
        }
        return t;
    }


    /**
     * 大小
     * @return
     */
    public int size(){
        return mSize;
    }

    /**
     * 判断是否为空
     * @return
     */
    public boolean isEmpty(){
        return mFirst == null;
    }

    @Override
    public Iterator<T> iterator() {
        return new QueueIterator();
    }

    /**
     * 内部类
     * @param <T>
     */
    private class Node<T>{
        T data;
        Node next;
    }

    /**
     * 迭代器
     * @param
     */
    private class QueueIterator implements Iterator<T>{

        @Override
        public boolean hasNext() {
            return mFirst != null;
        }

        @Override
        public T next() {
            T t = mFirst.data;
            //指向下一个结点
            mFirst = mFirst.next;
            return t;
        }

        @Override
        public void remove() {
            dequeue();
        }
    }

}

测试代码如下：

        String express = "( ( ( 2 * 5 ) + ( 4 / 3 ) ) - ( 1 + 3 ) )";
        String[] array = express.split(" ");

        Queue<String> stringQueue1 = new Queue<>();

        for (String s : array){
            stringQueue1.enqueue(s);
        }
        LogUtil.println(Queue.TAG,"queue foreach");
        for (String s : stringQueue1){
            LogUtil.print(s + " ");
        }

结果输出如下：

Queue queue foreach
( ( ( 2 * 5 ) + ( 4 / 3 ) ) - ( 1 + 3 ) ) 

源码参考
https://github.com/qiyei2015/Algorithms