Java数据结构--链表

package ds.linerlist;
/**
 * 结点类，包含结点的数据和指向下一个节点的引用
 * @author Bao Yiming
 * @param <E>
 */
class Node<E> {
    private E e;
    private Node<E> next = null;
    Node() {
    }
    Node(E e) {
        this.e = e;
    }
    public void setNext(Node<E> next) {
        this.next = next;
    }
    public Node<E> getNext() {
        return next;
    }
    public E getValue() {
        return e;
    }
    public void setValue(E e) {
        this.e = e;
    }
    @Override
    public String toString() {
        return "" + e;
    }
}
/**
 * 单链表的实现
 * @author Bao Yiming
 * @param <E>
 */
public class LinkedList<E> {
    private Node<E> head = null; // 每个链表都存有一个空值的头结点。
    private Node<E> tail = null; // 链表的最后一个结点，尾结点。
    private int size = 0; // 当前链表中的节点数目。
    /**
     * 建立一个空链表（建立其头结点）。
     */
    LinkedList() {
        head = new Node<E>();
        tail = head;
    }
    /**
     * 在链表的尾部插入数据
     * @param e 待插入的数据
     * @return
     */
    public boolean add(E e) {
        Node<E> node = new Node<E>(e); // 将要插入的值封装成一个节点。
        tail.setNext(node); // 将待插入结点放到尾结点的下一个结点。
        tail = tail.getNext(); // 将新增加的结点设为尾节点。
        ++size; // 链表大小增1。
        return true;
    }
    /**
     * 
     * @param index 待插入的位置
     * @param e 待插入的元素
     * @return
     */
    public boolean insert(int index, E e) {
        validateIndex(index);
        Node<E> newNode = new Node<E>(e); // 将要插入的值封装成一个节点。
        Node preNode = getNode(index - 1);
        newNode.setNext(preNode.getNext());
        preNode.setNext(newNode);
        return true;
    }
    /**
     * 获取指定位置的结点
     * @param index 欲获取结点的下标
     */
    private Node<E> getNode(int index) {
        validateIndex(index);
        Node<E> node = head;
        for (int p = 0; p <= index; ++p) {
            node = node.getNext();
        }
        return node;
    }
    /**
     * 获取指定位置的结点的值
     * @param index 欲获取值的结点的下标
     * @return
     */
    public E get(int index) {
        validateIndex(index);
        Node<E> node = getNode(index);
        return node.getValue();
    }
    /**
     * 验证下标值是否合法，非法时抛出异常。
     * @param index 待验证的下标值
     */
    private void validateIndex(int index) {
        if (index < 0 || index > size) {
            throw new RuntimeException("无效的下标：" + index);
        }
    }
    /**
     * 删除指定位置的结点
     * @param index 待删除结点的下标
     * @return
     */
    public boolean delete(int index) {
        Node<E> curNode = null;
        if (0 == index) {
            curNode = head.getNext();
            Node<E> nextNode = curNode.getNext();
            head.setNext(nextNode);
        } else {
            validateIndex(index);
            curNode = getNode(index); // 获取待删除节点。
            Node<E> preNode = getNode(index - 1); // 获取待删除节点的前一个结点。
            // 将待删除节点的前一个结点的下一个结点指向待删除节点的下一个结点。
            preNode.setNext(curNode.getNext());
        }
        curNode.setNext(null); // 将待删除节点的下一结点置空。
        return true;
    }
    /**
     * 设置指定位置结点的值。
     * @param index 待设置值的结点的下标
     * @param e
     */
    public void set(int index, E e) {
        validateIndex(index);
        Node<E> node = getNode(index);
        node.setValue(e);
    }
    /**
     * 获取链表的大小。
     * @return
     */
    public int size() {
        return size;
    }
    @Override
    public String toString() {
        String str = "";
        Node<E> node = head;
        while (node != tail) {
            str += (" " + node.getNext().getValue());
            node = node.getNext();
        }
        return str;
    }
}

package ds.linerlist;
/**
 * 栈的实现
 * @param <E> 
 * @author <a href="mailto:bao.yiming@live.cn" mce_href="mailto:bao.yiming@live.cn">Bao Yiming</a>
 */
public class Stack<E> {
    private Object[] data = null;
    private int capacity; // capacity： 栈的容量
    private int top; // top： 栈顶指针

    Stack() {
        this(10);
    }
    /**
     * 初始化栈，声明保存数据的数组大小。
     * @param initialSize  栈的初始化大小
     */
    Stack(int initialSize) {
        if (initialSize >= 0) {
            this.capacity = initialSize;
            data = new Object[initialSize];
            top = 0;
        } else {
            throw new RuntimeException("初始化大小不能小于0：" + initialSize);
        }
    }
    /**
     * 判断栈是否为空
     * @return
     */
    boolean empty() {
        return top == 0 ? true : false;
    }
    /**
     * 获取栈顶元素的内容，但是不弹出
     * @return
     */
    E peek() {
        return (E) data[top - 1];
    }
    /**
     * 弹出栈顶元素
     * @return
     */
    E pop() {
        E e = (E) data[top - 1];
        --top;
        return e;
    }
    /**
     * 在栈顶插入元素
     * @param e 待插入的元素
     * @return
     */
    boolean push(E e) {
        ensureCapacity();
        data[top] = e;
        ++top;
        return true;
    }
    /**
     * 检查存储数据的数组容量，如果数组已经满，则扩充容量；否则不操作。
     */
    private void ensureCapacity() {
        int index;
        if (top == capacity) {
            capacity *= 2;
            Object[] newData = new Object[capacity];
            for (index = 0; index < top; ++index) {
                newData[index] = data[index];
            }
            data = newData;
        }
    }
    @Override
    public String toString() {
        String str = "";
        for (int index = 0; index <= top - 1; ++index) {
            str += (data[index] + " ");
        }
        return str;
    }
}

package ds.linerlist;
/**
 * 队列的实现
 * @param <E> 
 * @author <a href="mailto:bao.yiming@live.cn" mce_href="mailto:bao.yiming@live.cn">Bao Yiming</a>
 */
public class Queue<E> {
    Object[] data = null;
    private int capacity; // capacity： 队的容量
    private int tail; // tail： 队尾指针
    /**
     * 初始化为声明大小，则设置为10。
     */
    Queue() {
        this(10);
    }
    /**
     * 初始化队列，声明保存数据的数组大小。
     * @param initialSize 队列的初始化大小
     */
    Queue(int initialSize) {
        if (initialSize >= 0) {
            this.capacity = initialSize;
            data = new Object[initialSize];
            tail = 0;
        } else {
            throw new RuntimeException("初始化大小不能小于0：" + initialSize);
        }
    }
    /**
     * 判断队列是否为空
     * @return
     */
    public boolean empty() {
        return tail == 0 ? true : false;
    }
    /**
     * 在队尾插入元素
     * @param e 待插入的元素
     * @return
     */
    public boolean add(E e) {
        ensureCapacity();
        data[tail] = e;
        ++tail;
        return true;
    }
    /**
     * 获取队首的元素内容，但不将该元素出队。
     * @return
     */
    public E peek() {
        return (E) data[0];
    }
    /**
     * 将队首元素出队。
     * @return
     */
    public E poll() {
        E e = (E) data[0];
        for (int index = 1; index < tail; ++index) {
            data[index - 1] = data[index];
        }
        data[tail - 1] = null;
        --tail;
        return e;
    }
    /**
     * 检查存储数据的数组容量，如果数组已经满，则扩充容量；否则不操作。
     */
    private void ensureCapacity() {
        int index;
        if (tail == capacity) {
            capacity *= 2;
            Object[] newData = new Object[capacity];
            for (index = 0; index < tail; ++index) {
                newData[index] = data[index];
            }
            data = newData;
        }
    }
    @Override
    public String toString() {
        String str = "";
        for (int index = 0; index < tail; ++index) {
            if (data[index] != null) {
                str += (data[index] + " ");
            }
        }
        return str;
    }
}