链表基本概念

链表是由一系列节点组成的数据结构，节点可以在运行过程中动态生成。每个节点包含两部分内容：存储数据的数据域；存储下一个节点地址的指针域。

单向链表

链表节点的定义

public class Node {
    //结点存放的数据
    private Integer data;
    //存放的下一个结点的内存地址
    private Node next;

    public Node(Integer data) {
        this.data = data;
    }

    public Integer getData() {
        return data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

自定义单向链表的封装类

public class SinglyLinkedList {
    private Node head;
    private int size;

    /**
     * 添加数据到链表尾部
     * @param data
     * @return
     */
    public boolean add(Integer data){
        Node temp = new Node(data);
        if(head == null)
            head = temp;
        else{
            Node t = head;
            while(t.getNext() != null){
                t = t.getNext();
            }
            t.setNext(temp);
        }
        size++;
        return true;
    }

    /**
     * 将数据插入到指定位置
     * @param data
     * @param index
     * @return
     */
    public boolean add(Integer data,int index){
        if(index < 0 || index >= size){
            throw new RuntimeException("越界异常：index"+index+",size"+size);
        }
        Node node = new Node(data);
        if(index == 0){
            node.setNext(head);
            head = node;
        }else{
            Node temp = head;
            for (int i = 0; i < index-1; i++) {
                temp = temp.getNext();
            }
            node.setNext(temp);
            temp.setNext(node);
        }
        size++;
        return true;
    }

    /**
     * 删除最后一个值
     * @return 被删除节点的值
     */
    public Integer remove(){
        if(head == null){
            return null;
        }
        if(head.getNext() == null){
            Integer data = head.getData();
            head = null;
            size--;
            return data;
        }
        Node tlow = null;
        Node tfast = head;
        while(tfast.getNext() != null){
            tlow = tfast;
            tfast = tfast.getNext();
        }
        Integer data = tfast.getData();
        tlow.setNext(null);
        size--;
        return data;
    }

    /**
     * 删除指定位置元素
     * @param index
     * @return
     */
    public Integer remove(int index){
        if(index < 0 || index >= size){
            throw new RuntimeException("越界异常：index："+index+",size："+size);
        }
        if(index == 1){
            Integer data = head.getData();
            head = head.getNext();
            size--;
            return data;
        }
        Node tlow = null;
        Node tfast = head;
        for (int i = 0; i < index-1; i++) {
            tlow = tfast;
            tfast = tfast.getNext();
        }
        Integer data = tfast.getData();
        tlow.setNext(tfast.getNext());
        size--;
        return data;
    }

    /**
     * 获取指定位置元素
     * @param index
     * @return
     */
    public Integer get(int index){
        if(index < 0 || index >= size){
            throw new RuntimeException("越界异常：index:"+index+",size:"+size);
        }
        Node t = head;
        for (int i = 1; i < index; i++) {
            t = t.getNext();
        }
        return t.getData();
    }

    public void print(){
        Node temp = head;
        while(temp != null){
            System.out.println(temp.getData());
            temp = temp.getNext();
        }
    }

    public Node getHead() {
        return head;
    }
    
    public int getSize() {
        return size;
    }

}