public class Node<T>{
    Node next;
    private T item;
 
    public Node(Node next, T item) {
        this.next = next;
        this.item = item;
    }
}

public class TestNode {
    public static void main(String[] args) {
        // 生成結(jié)點(diǎn)
        Node<Integer> one = new Node<Integer>(null,12);
        Node<Integer> two = new Node<Integer>(null,16);
        Node<Integer> three = new Node<Integer>(null,11);
        Node<Integer> four = new Node<Integer>(null,10);
        //生成鏈表
        one.next = two;
        two.next = three;
        three.next =four;
    }
}

package com.ycy.Algorithm.LinkList;
 
 
import java.util.Iterator;
 
/**
 * 鏈表的head是不可以動(dòng)的
 * @param <T>
 */
public class LinkList<T> implements Iterable<T>{
 
    private Node head;//頭結(jié)點(diǎn)，鏈表的head是不可以動(dòng)的
    private int N;//結(jié)點(diǎn)個(gè)數(shù)
    public LinkList() {
        this.head = new Node(null,null);
        N = 0;
    }
    /**
     * 結(jié)點(diǎn)內(nèi)部類
     */
    private class Node{
        //存儲(chǔ)數(shù)據(jù)
        T item;
        //下一個(gè)結(jié)點(diǎn)
        Node next;
        public Node(T item,Node next) {
            this.item = item;
            this.next = next;
        }
 
    }
    /**
     * 清空鏈表
     */
    public void clear(){
        head.item=null;
        head.next=null;// 頭節(jié)點(diǎn)next為null就是空鏈表
        this.N=0;
    }
    /**
     * 判斷鏈表是否為空
     */
    public boolean isEmpty(){
        return this.N==0;
    }
    /**
     * 獲取鏈表的長度
     */
    public int length(){
        return this.N;
    }
    /**
     * 讀取鏈表第i位置的元素值并返回
     */
    public T get(int i){
        //非法性檢查
        if(i<0 || i > this.N){
            throw new RuntimeException("位置不合法");
        }
        // n也是指向頭結(jié)點(diǎn)
        Node n = head;
        for(int index=0; index<i; index++){
            n = n.next;
        }
        return n.item;
    }
    /**
     * 往鏈表中插入數(shù)據(jù)t
     */
    public void insert(T t){
        // head不可以移動(dòng)，不然就無法在找到鏈表
        // 定義一個(gè)臨時(shí)的Node也指向head的指針就可以通過移動(dòng)該指針就可以
        Node n = head;
        // 獲取尾節(jié)點(diǎn)
        while(true){
            // 當(dāng)剛好就一個(gè)節(jié)點(diǎn)時(shí)（頭節(jié)點(diǎn)）
            if(n.next == null){
                break;
            }
            n = n.next;
        }
        //當(dāng)為空表時(shí)，就可以插入
        Node node = new Node(t, null);
        n.next =node;
        this.N ++;
    }
 
    /**
     * 在第i位置上插入數(shù)據(jù)t
     */
    public void insert(T t,int i){
        // 非法性檢查
        if(i < 0 || i > this.N){
            throw  new RuntimeException("插入位置❌");
        }
        Node pre = head;
        for(int index=0;index <= i-1; index++){
            pre = pre.next;
        }
        Node current = pre.next;
        //先鏈接后面結(jié)點(diǎn)
        Node newNode = new Node(t,null);
        pre.next = newNode;
        newNode.next = current;
        this.N++;
    }
    /**
     * 移除并返回第i位置的元素值
     */
    public  T remove(int i){
        // 非法性檢查
        if(i < 0 || i >this.N){
            throw  new RuntimeException("刪除位置有誤");
        }
        Node n =head;
        for(int index=0;index <= i-1;index ++){
             n = n.next;
        }
        //要?jiǎng)h除的節(jié)點(diǎn)
        Node curr = n.next;
        n.next = curr.next;
        this.N--;//結(jié)點(diǎn)個(gè)數(shù)減一
        return curr.item;
    }
    //查找元素t在鏈表中第一次出現(xiàn)的位置
    public int indexof(T t){
        Node n = head;
        for(int i = 0; n.next != null;i++){
            n =n.next;
            if(n.item.equals(t)){
                return i;
            }
        }
        return -1;
    }
 
    @Override
    public Iterator iterator() {
        return new Iterator() {
            Node n =head;
            @Override
            public boolean hasNext() {
                return n.next !=null;
            }
            @Override
            public Object next() {
                //下移一個(gè)指針
                n = n.next;
                return n.item;
            }
        };
    }
}

public class test {
    public static void main(String[] args) {
        LinkList<Integer>linkList = new LinkList<>();
        linkList.insert(1);
        linkList.insert(2);
        linkList.insert(4);
        linkList.insert(3);
        linkList.insert(1,2);
        for (Integer i : linkList) {
            System.out.print(i+" ");
        }
    }
}

class MyLinkedList {
    Node head;//定義雙向鏈表的頭節(jié)點(diǎn)
    Node last;//定義雙向鏈表的尾節(jié)點(diǎn)
 
    //打印雙向鏈表
    public void disPlay() {
        Node cur = this.head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }
 
    //求雙向鏈表的長度（之后addIndex代碼會(huì)用到）
    public int size() {
        int count = 0;
        Node cur = this.head;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }
 
    //頭插法
    public void addFirst(int data) {
        Node node = new Node(data);//定義一個(gè)用作插入的節(jié)點(diǎn)
        //1.假設(shè)雙向鏈表為空
        if (this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            //2.雙向鏈表不為空的情況下
            //不懂請看上面的圖解，就很簡單了
            node.next = this.head;
            this.head.prev = node;
            this.head = node;
        }
    }
 
    //尾插法（與頭插法類似）
    public void addLast(int data) {
        //定義一個(gè)用作插入的節(jié)點(diǎn)
        Node node = new Node(data);
        //1.假設(shè)雙向鏈表為空
        if (this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            //2.雙向鏈表不為空的情況下
            //不懂請看上面的圖解，就很簡單了
            last.next = node;
            node.prev = last;
            last = node;
        }
    }
 
    //在任意位置插入
    public void addIndex(int index, int data) {//形參index為插入元素位置，data為插入的數(shù)值
        //定義一個(gè)用作插入的節(jié)點(diǎn)
        Node node = new Node(data);
        Node cur = this.head;//定義一個(gè)cur用作遍歷雙向鏈表
        //1、判斷插入位置的合法性
        if (index < 0 || index > size()) {
            System.out.println("插入位置不合法?。?！");
            return;
        }
        //2、假設(shè)插入位置為頭結(jié)點(diǎn)的情況下，即就是頭插法
        if (index == 0) {
            addFirst(data);//調(diào)用頭插法代碼
            return;
        }
        //3、假設(shè)插入位置為尾結(jié)點(diǎn)的情況下，即就是尾插法
        if (index == size()) {
            addLast(data);//調(diào)用尾插法代碼
            return;
        }
        //4、在中間任意位置的情況下
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        //不懂請看上面的圖解，就很簡單了
        //核心代碼
        node.next = cur;
        node.prev = cur.prev;
        cur.prev = node;
        node.prev.next = node;
    }
}
 
//雙向鏈表的節(jié)點(diǎn)結(jié)構(gòu)
class Node {
    int val;
    Node prev;
    Node next;
 
    Node(int val) {
        this.val = val;
    }
}

public void reverse(){
        if(N==0){
        //當(dāng)前是空鏈表，不需要反轉(zhuǎn)
            return;
        }
        reverse(head.next);
}
    /**
     * @param curr 當(dāng)前遍歷的結(jié)點(diǎn)
     * @return 反轉(zhuǎn)后當(dāng)前結(jié)點(diǎn)上一個(gè)結(jié)點(diǎn)
     */
public Node reverse(Node curr){
        //已經(jīng)到了最后一個(gè)元素
        if(curr.next==null){
        //反轉(zhuǎn)后，頭結(jié)點(diǎn)應(yīng)該指向原鏈表中的最后一個(gè)元素
          head.next=curr;
          return curr;
        }
       //當(dāng)前結(jié)點(diǎn)的上一個(gè)結(jié)點(diǎn)
       Node pre=reverse(curr.next);
       pre.next=curr;
       //當(dāng)前結(jié)點(diǎn)的下一個(gè)結(jié)點(diǎn)設(shè)為null
       curr.next=null;
       //返回當(dāng)前結(jié)點(diǎn)
       return curr;
}