数据结构之链表、栈和队列 java代码实现

定义抽象节点类Node：

package cn.wzbrilliant.datastructure;

/**
 * 节点
 * @author ice
 *
 */
public abstract class Node {
    private Node next;

    public Node(){
        next=null;
    }

    public void setNext(Node nextNode){
        next=nextNode;
    }

    public Node getNext(){
        return next;
    }
}

链表类，实现了插入首尾节点、指定位置节点，删除节点、指定位置节点，链表的逆序以及判空操作：

package cn.wzbrilliant.datastructure;

/**
 * 链表
 * @author ice
 *
 */
public class Link {

    protected Node head;
    protected Node tail;
    protected int size;

    public Link() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }

    public void addAtFirst(Node node){
        node.setNext(head);
        head=node;
        if(size==0)
            tail=node;
        size++;
    }

    public void addAtLast(Node node){
        if(size==0){
            head=tail=node;
        }else{
            tail.setNext(node);
            tail=node;
        }
        node.setNext(null);
        size++;
    }

    public void removeFirst(){
        if(size==0)
            throw new RuntimeException("link size is 0...");
        head=head.getNext();
        if(size==1){
            tail.setNext(null);
        }
        size--;
    }

    public void removeLast(){
        if(size==0)
            throw new RuntimeException("link size is 0...");

        if(size==1){
            head=tail=null;
            size--;
            return ;
        }

        Node node=head;
        while(node.getNext()!=tail){
            node=node.getNext();
        }
        node.setNext(null);
        tail=node;
        size--;
    }

    /**
     * 队列逆序
     */
    public void reverse() {
        Node preNode, node, tempNode;
        if (size == 0)
            return;
        preNode = head;
        node = preNode.getNext();
        preNode.setNext(null);
        tail = preNode;
        while (node != null) {
            tempNode = node.getNext();
            node.setNext(preNode);
            preNode = node;
            node = tempNode;
        }
        head = preNode;
    }

    /**
     * 在第index个节点后插入newNode
     * 
     * @param newNode
     * @param index
     */
    public void insert(Node newNode, int index) {
        if (index < 0 || index > size)
            throw new RuntimeException("索引错误");

        if (index == 0) {
            newNode.setNext(head);
            head = newNode;
            size++;
            return;
        }

        if (index == size) {
            newNode.setNext(null);
            tail.setNext(newNode);
            tail = newNode;
            size++;
            return;
        }

        Node node = head;
        for (int i = 1; node != null; i++, node = node.getNext()) {
            if (i == index) {
                newNode.setNext(node.getNext());
                node.setNext(newNode);
                size++;
                return;
            }
        }

    }

    /**
     * 移除Node节点    Node节点需重写equals()方法
     * 
     * @param node
     */
    public void remove(Node node) {
        if (node == null || size == 0)
            throw new RuntimeException("remove error...");
        for (Node temp = head; temp != null; temp = temp.getNext()) {
            if (temp == head) {
                if (temp.equals(node)) {
                    head = head.getNext();
                    size--;
                    continue;
                }
            }
            if (temp.getNext().equals(node)) {
                temp.setNext(temp.getNext().getNext());
                size--;
            }

        }
    }

    public Node getFirst() {
        if (size == 0)
            return null;
        return head;
    }

    public Node getLast() {
        if (size == 0)
            return null;
        return tail;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        if (size == 0)
            return true;
        return false;
    }
}

栈类，实现了入栈、出战、获取栈顶元素以及判空的操作：

package cn.wzbrilliant.datastructure;

/**
 * 栈
 * @author ice
 *
 */
public class Stack {
    private int size;
    private Node top;

    public Stack() {
        size = 0;
        top = null;
    }

    public void push(Node node) {
        node.setNext(top);
        top = node;
        size++;
    }

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

    public Node top() {
        return top;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        if (size == 0)
            return true;
        return false;
    }
}

队列类，实现了入队、出队、判空的操作：

package cn.wzbrilliant.datastructure;

/**
 * 队列
 * @author ice
 *
 */
public class Queue {

    private Node head;
    private Node tail;
    private int size;

    public Queue() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }

    public void enQueue(Node node) {
        tail.setNext(node);
        tail = node;
        size++;
    }

    public Node deQueue() {
        if (size == 0)
            return null;
        Node node = head;
        head = head.getNext();
        size--;
        return node;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        if (size == 0)
            return true;
        return false;
    }

}