单向链表的java实现

定义节点

@Data
public class LinkNode {

    /**
     * 节点中的值
     */
    private int data;
    /**
     * 节点中的指针，指向下一个节点
     */
    private LinkNode next;
}

链表的常规操作及测试

/**
 * @author ljx
 * @Description: 链表的常规操作及测试
 * @date 2021/7/29 2:35 下午
 */
public class LinkNodeProcess {

    /**
     * 头节点指针
     */
    private LinkNode head;
    /**
     * 尾节点指针
     */
    private LinkNode last;
    /**
     *  链表实际长度
     */
    private int size;

    /**
     * 链表插入元素
     * @param data 插入元素
     * @param index 插入位置
     */
    public void insert(int data, int index) throws Exception{
        if(index<0||index>size){
            throw new IndexOutOfBoundsException("超出链表中长度");
        }
        // 基于当前元素创建节点
        LinkNode linkNode = new LinkNode();
        linkNode.setData(data);

        // 将当前元素插入到指定的位置
        // 如果是空链表，则将该元素作为头节点
        if(size==0){
            head = linkNode;
            last = linkNode;
         // 插入头部，则先将当前节点的下一个节点指向现在的头节点，再把现在的节点赋值给头节点
        }else if(index==0){
            linkNode.setNext(head);
            head = linkNode;
         // 插入尾部，则先将当前尾节点的下一个节点指向当前节点，再把现在的节点赋值给尾节点
        }else if(index==size){
            last.setNext(linkNode);
            last = linkNode;
         // 插入中间节点
        }else{
            // 前面节点的next指针指向该节点，该节点的next指针指向前节点原来的next指向
            final LinkNode preNode = this.get(index - 1);
            linkNode.setNext(preNode.getNext());
            preNode.setNext(linkNode);
        }
        // 链表长度加1
        size++;
    }

    /**
     * 根据索引查找链表中的节点
     * @param index 查找的位置
     * @return
     * @throws Exception
     */
    public LinkNode get(int index) throws Exception {
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("超出链表中长度");
        }
        // 默认从头节点开始，当index为0时，直接返回头节点
        LinkNode linkNode = head;
        // 从head节点开始逐一查找，直到找到index位置
        for(int i = 0;i<index;i++){
            linkNode = head.getNext();
        }
        return linkNode;
    }

    /**
     * 移除链表中指定位置的节点
     * @param index
     * @return 返回删除的节点
     * @throws Exception
     */
    public LinkNode remove(int index) throws Exception{
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("超出链表中长度");
        }
        LinkNode removedNode = null;
        // 如果是头节点，直接将头节点的下一个节点置为新的头节点
        if(index==0){
            removedNode = head;
            head = head.getNext();
         // 如果是尾节点，将尾节点的上一个节点置为新的尾节点，同时新的尾节点next指针指向null
        }else if(index==size-1){
            last = this.get(index - 1);
            removedNode = last.getNext();
            last.setNext(null);
         // 如果是中间节点，获取到当前节点的前一个节点，将前一个节点的next指针指向当前节点的next，同时当前节点的next指针指向null
        }else{
            final LinkNode prevNode = this.get(index - 1);
            removedNode = prevNode.getNext();
            prevNode.setNext(removedNode.getNext());
            removedNode.setNext(null);
        }
        size--;
        return removedNode;
    }

    /**
     * 输出链表所有节点的值
     */
    public void output(){
        LinkNode temp = head;
        while(temp!=null){
            System.out.println(temp.getData());
            temp = temp.getNext();
        }
    }
public static void main(String[] args) throws Exception {
        LinkNodeProcess myLinkedList = new LinkNodeProcess();
        myLinkedList.insert(3,0);
        myLinkedList.insert(7,1);
        myLinkedList.insert(9,2);
        myLinkedList.insert(5,3);
        myLinkedList.insert(6,1);
        myLinkedList.output();
        myLinkedList.remove(0);
        myLinkedList.output();
    }
}