实现单向链表的思想以及简易代码

package com.algorithm.tiger.linkedlist;

/**
 * 链表（由众多节点相连组成）
 *
 * @description: 单向链表
 * @author: tiger
 * @create: 2020-07-11 11:05
 */
public class MyLinkedList {

    //链表头部节点
    private Node head;

    //链表尾部节点
    private Node tail;

    //链表实际大小
    private int size;

    public Node find(int index) {
        //预判异常情况
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("超出链表节点范围！");
        }

        if (size == 0) {
            //空链表
            return null;
        } else if (index == 0) {
            //头部
            return head;

        } else if (size == index) {
            //尾部
            return tail;
        } else {
            //中部(从头部开始遍历，直到抵达index位置的Node节点)
            Node targetNode = head;
            for (int i = 0; i < index; i++) {
                targetNode = targetNode.next;
            }
            return targetNode;
        }
    }

    /**
     * 插入元素（头部插入、中间插入、尾部插入）
     *
     * @param data
     * @param index
     * @return
     */
    public Node insert(int data, int index) {

        //预判异常情况
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("超出链表节点范围！");
        }

        //插入的节点
        Node insertNode = new Node(data);

        if (size == 0) {
            //空链表
            head = insertNode;
            tail = insertNode;
        } else if (index == 0) {
            //头部插入
            //1.把新节点的next指针指向原先的头节点
            insertNode.next = head;
            //2.把新节点变为链表的头节点
            head = insertNode;

        } else if (size == index) {
            //尾部插入
            //1.将原先尾部节点的next指向新节点
            tail.next = insertNode;
            //2.将新节点指向尾部节点
            tail = insertNode;
        } else {
            //中间插入（需要依托链表的查找方法）

            Node prevNode = find(index - 1);
            Node currentNode = prevNode.next;
            prevNode.next = insertNode;
            insertNode.next = currentNode;

            //从后向前刷新
//            Node prevNode = find(index - 1);
//            //1.新节点的next指针，指向插入位置的节点(1和2不能调换顺序)
//            insertNode.next = prevNode.next;
//            //2.插入位置前置节点的next指针，指向新节点
//            prevNode.next = insertNode;

        }
        size++;
        //返回插入的新节点数据
        return insertNode;
    }

    /**
     * 删除元素，返回被删除的节点
     *
     * @param index
     * @return
     */
    public Node remove(int index) {
        //预判异常情况
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("超出链表节点范围！");
        }

        Node removeNode = null;
        if (size == 0) {
            //空链表

        } else if (index == 0) {
            //删除头部
            removeNode = head;
            head = head.next;
        } else if (size == index) {
            //删除尾部
            Node prevNode = find(index - 1);
            removeNode = prevNode.next;
            prevNode.next = null;
            tail = prevNode;
        } else {
            //中间删除（需要依托链表的查找方法）
            Node prevNode = find(index - 1);
            Node nextNode = prevNode.next.next;
            removeNode = prevNode.next;
            prevNode.next = nextNode;
        }
        size--;
        return removeNode;
    }

    public Node getHead() {
        return head;
    }

    public void setHead(Node head) {
        this.head = head;
    }

    public Node getTail() {
        return tail;
    }

    public void setTail(Node tail) {
        this.tail = tail;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    @Override
    public String toString() {
        return "MyNode{" +
                "head=" + head +
                ", tail=" + tail +
                ", size=" + size +
                '}';
    }

    /**
     * 节点内部类
     */
    private static class Node {
        //当前节点数据
        private int  data;
        //下一个节点
        private Node next;

        public Node() {
        }

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

        public int getData() {
            return data;
        }

        public void setData(int data) {
            this.data = data;
        }

        public Node getNext() {
            return next;
        }

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

        @Override
        public String toString() {
            return "Node{" +
                    "data=" + data +
                    ", next=" + next +
                    '}';
        }
    }

    /**
     * 测试
     *
     * @param args
     */
    public static void main(String[] args) {
        Node node = new Node(12);

        MyLinkedList linkedList = new MyLinkedList();
        linkedList.insert(12, 0);
        linkedList.insert(122, 0);
        linkedList.insert(343, 0);
        linkedList.insert(1243, 1);
        linkedList.insert(444444, 1);
        linkedList.insert(45678, 1);
        linkedList.insert(333333, 1);
        System.out.println(linkedList);
        System.out.println("===================");
//        System.out.println(linkedList.find(2));
//        linkedList.remove(0);
//        linkedList.remove(0);
        linkedList.remove(3);
        System.out.println(linkedList);
        System.out.println("===================");
//        LinkedList linkedList1 = new LinkedList();
    }
}