实现一个简单的单向链表

什么是单向链表

单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点

单向链表的结构图

代码

因为实现比较简单所以不做过多解释，该实现未实现Iterable接口，也未做并发修改异常的检测。

public class SimpeLinkedList<T> {
    //存储首尾节点，便于计算
    private Node<T> first;
    private Node<T> last;
    int size;

    public SimpeLinkedList() {
    }

    /**
     * 使用遍历的方式查询
     *
     * @param index
     * @return
     */
    public T get(int index) {
        //检查入参index是否是合法的
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界异常");
        }

        Node<T> n = first;

        for (int i = 0; i < index; i++) {
            n = n.next;
        }

        return n.data;
    }

    /**
     * 获取第一项
     *
     * @return
     */
    public T getFirst() {
        return first.data;
    }

    /**
     * 获取最后一项
     *
     * @return
     */
    public T getLast() {
        return last.data;
    }

    /**
     * 向单向链表的末尾添加
     *
     * @param t
     */
    public void insert(T t) {
        if (last == null) {
            insertFirst(t);
        } else {
            Node<T> tNode = new Node<>(t, null);
            last.next = tNode;
            last = tNode;
            size++;
        }
    }

    /**
     * 向单链表的指定位置进行插入
     *
     * @param index
     * @param t
     */
    public T insert(int index, T t) {
        if (index < 0) {
            //向单向链表的头部添加元素
            insertFirst(t);
        }
        if (index >= size)
            insert(t);

        Node<T> n1 = first;

        //获取要插入位置的上一个元素
        for (int i = 0; i < index - 1; i++) {
            n1 = n1.next;
        }

        Node n2 = n1.next;
        Node<T> tNode = new Node<T>(t, n2);
        n1.next = tNode;
        size++;

        return t;
    }

    /**
     * 向链表的表头添加
     *
     * @param t
     */
    public void insertFirst(T t) {
        Node<T> tNode = new Node<T>(t, null);
        first = tNode;
        last = tNode;
        size++;
    }

    /**
     * 删除单向链表的最后一项
     */
    public void remove() {
        Node<T> n = first;

        for (int i = 0; i < size - 1; i++)
            n = n.next;

        n.next = null;
        last = n;
        size--;
    }

    /**
     * 删除单向链表中指定位置的项
     *
     * @param index
     */
    public void remove(int index) {
        if (index >= size)
            remove();

        if (index < -1)
            throw new RuntimeException("索引非法");

        Node<T> n1 = first;
        for (int i = 0; i < index - 1; i++) {
            n1 = n1.next;
        }

        Node<T> n2 = n1.next;
        Node<T> n3 = n2.next;
        n1.next = n3;
        size--;
    }

    /**
     * 删除单向链表的第一项
     */
    public void removeFirst() {
        first = first.next;
        size--;
    }

    /**
     * 根据内容删除链表中的节点
     *
     * @param t
     */
    public void remove(T t) {
        Node<T> lastNode = null;
        for (Node<T> n = first; n != null; n = n.next) {
            if (n.data == t) {
                //删除对应的节点
                lastNode.next = n.next;
                size--;
                return;
            }
            lastNode = n;
        }
    }

    /**
     * 修改index处的节点
     *
     * @param index
     * @param t
     * @return
     */
    public T set(int index, T t) {
        remove(index);
        return insert(index, t);
    }


    private static class Node<T> {
        T data;
        Node<T> next;

        public Node(T data, Node<T> next) {
            this.data = data;
            this.next = next;
        }
    }
}