單向鏈表不同位置的新增，刪除節點操作

1.什麼是鏈表？

一種線性的數據存儲方式的數據結構，由若干個節點組成，物理上，非連續，非順序的存儲方式
物理存儲方式：隨機存儲
數據訪問方式：順序訪問

2.鏈表分類：單向鏈表，雙向鏈表

單向鏈表：每個節點包含兩部分：一部分存數據，一部分存指向下一個節點的地址值
雙向鏈表：每個節點在單鏈表基礎上，還存儲了上一個節點的地址值

3.對比鏈表和數組的內存分配方式：

4.編碼實現單向鏈表的基本增刪改查操作

public class MyLinkedList {

    //鏈表頭節點
    private Node head;

    //鏈表實際長度
    private int size;

    private Node endNode;

    /**
     * 在鏈表指定位置插入數據
     *
     * @param index 指定插入位置
     * @param data  插入的值
     */
    //分別在一個空鏈表/鏈表頭部/鏈表尾部/鏈表中間插入一個節點
    private void insertNode(int index, int data) throws Exception {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("超出鏈表節點範圍");
        }

        Node node = new Node(data);
        //空鏈表
        if (size == 0) {
            head = node;
            endNode = node;
        } else if (index == 0) {
            //插入頭節點
            head = node;
            node.next = head;
        } else if (index == size) {
            //插入尾部
            endNode.next = node;
            endNode = node;
        } else {
            //中間插入
            Node prevNode = get(index - 1);
            node.next = prevNode.next;
            prevNode.next = node;
        }
        size++;
    }

    /**
     * 刪除指定爲位置節點
     * @param index
     */
    public void deleteNode(int index) throws Exception {
        if(index<0 || index>size){
            throw new NullPointerException("超出當前鏈表範圍");
        }
        Node temp = null;
        //刪除頭部節點
        if(index == 0){
            temp = head;
            head  = head.next;
        }else if(index == size-1){
            //刪除尾節點
            endNode  = null;
            Node prevNode = get(index-1);
            prevNode.next = null;
            endNode = prevNode;
        }else {
            //刪除中間指定位置節點
            Node prevNode = get(index-1);
            Node nextNode = prevNode.next.next;
            prevNode.next = null;
            prevNode.next = nextNode;

        }
        size--;
    }
    

    /**
     * 獲取指定位置節點
     *
     * @param index 指定位置
     * @return 鏈表指定位置節點
     */
    public Node get(int index) throws Exception {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("超出鏈表範圍");
        }
        Node temp = head;

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


    /**
     * 遍歷整個鏈表輸出節點的值
     */
    private void output() {
        Node temp = head;
        while (null != temp) {
            System.out.print(temp.datas + ",");
            temp = temp.next;
        }


    }


    public static void main(String[] args) throws Exception {
//        //尾部插入節點
        MyLinkedList endNodeLinkedList = new MyLinkedList();
        endNodeLinkedList.insertNode(0, 5);
        endNodeLinkedList.insertNode(1, 6);
        endNodeLinkedList.insertNode(2, 2);
        endNodeLinkedList.insertNode(3, 9);
        endNodeLinkedList.output();
        endNodeLinkedList.get(0);
        System.out.println("值是："+endNodeLinkedList.get(0).datas);

        //空鏈表插入節點
        MyLinkedList emptyLinkedList = new MyLinkedList();
        emptyLinkedList.insertNode(0, 1);
        emptyLinkedList.output();

        //已知鏈表中間插入一個節點
        MyLinkedList midLinkedList = new MyLinkedList();
        midLinkedList.insertNode(0, 3);
        midLinkedList.insertNode(1, 4);
        midLinkedList.insertNode(2, 5);
        midLinkedList.insertNode(3, 6);
        midLinkedList.insertNode(2, 9);
        midLinkedList.output();

        //刪除指定位置節點

        MyLinkedList delteLinkedList  = new MyLinkedList();
        delteLinkedList.insertNode(0,1);
        delteLinkedList.insertNode(1,5);
        delteLinkedList.insertNode(2,6);
        delteLinkedList.insertNode(3,7);
        delteLinkedList.insertNode(4,8);
        delteLinkedList.insertNode(5,9);
        delteLinkedList.insertNode(6,10);

        //刪除頭節點
        delteLinkedList.deleteNode(0);
        delteLinkedList.output();
        //刪除尾部節點
        delteLinkedList.deleteNode(delteLinkedList.size-1);
        delteLinkedList.output();
//        //刪除中間指定位置節點
        delteLinkedList.deleteNode(3);
        delteLinkedList.output();
    }

參考書籍：《漫畫算法》