java ListNode 鏈表

鏈表是一種數據結構：由數據和指針構成，鏈表的指針指向下一個節點。

java ListNode 鏈表 就是用Java自定義實現的鏈表結構。

基本結構：

class ListNode {        //類名 ：Java類就是一種自定義的數據結構
    int val;            //數據 ：節點數據 
    ListNode next;      //對象 ：引用下一個節點對象。在Java中沒有指針的概念，Java中的引用和C語言的指針類似
}

 

 

添加構造方法方便初始化：

class ListNode {        //類名 ：Java類就是一種自定義的數據結構
    int val;            //數據 ：節點數據 
    ListNode next;      //對象 ：引用下一個節點對象。在Java中沒有指針的概念，Java中的引用和C語言的指針類似
    
    ListNode(int val){  //構造方法 ：構造方法和類名相同   
        this.val=val;     //把接收的參數賦值給當前類的val變量
    }
}

 

范型寫法：使用范型可以兼容不同的數據類型

class ListNode<E>{                //類名 ：Java類就是一種自定義的數據結構
    E val;                        //數據 ：節點數據 
    ListNode<E> next;             //對象 ：引用下一個節點對象。在Java中沒有指針的概念，Java中的引用和C語言的指針類似
    
    ListNode(E val){              //構造方法 ：構造方法和類名相同   
        this.val=val;             //把接收的參數賦值給當前類的val變量
    }
}

 

創建鏈表及遍歷鏈表：

class ListNode {        //類名 ：Java類就是一種自定義的數據結構
    int val;            //數據 ：節點數據 
    ListNode next;      //對象 ：引用下一個節點對象。在Java中沒有指針的概念，Java中的引用和C語言的指針類似
    
    ListNode(int val){  //構造方法 ：構造方法和類名相同   
        this.val=val;   //把接收的參數賦值給當前類的val變量
    }
}

class Test{
    public static void main(String[] args){
        
        ListNode nodeSta = new ListNode(0);    //創建首節點
        ListNode nextNode;                     //聲明一個變量用來在移動過程中指向當前節點
        nextNode=nodeSta;                      //指向首節點

        //創建鏈表
        for(int i=1;i<10;i++){
            ListNode node = new ListNode(i);  //生成新的節點
            nextNode.next=node;               //把心節點連起來
            nextNode=nextNode.next;           //當前節點往后移動
        } //當for循環完成之后 nextNode指向最后一個節點，
        
        nextNode=nodeSta;                     //重新賦值讓它指向首節點
        print(nextNode);                      //打印輸出
      
    }
    
    //打印輸出方法
    static void print(ListNode listNoed){
        //創建鏈表節點
        while(listNoed!=null){
            System.out.println("節點:"+listNoed.val);
            listNoed=listNoed.next;
        }
        System.out.println();
    }
   
}

 

插入節點：

 

 

 

class ListNode {        //類名 ：Java類就是一種自定義的數據結構
    int val;            //數據 ：節點數據 
    ListNode next;      //對象 ：引用下一個節點對象。在Java中沒有指針的概念，Java中的引用和C語言的指針類似
    
    ListNode(int val){  //構造方法 ：構造方法和類名相同   
        this.val=val;   //把接收的參數賦值給當前類的val變量
    }
}

class Test{
    public static void main(String[] args){
        
        ListNode nodeSta = new ListNode(0);          //創建首節點
        ListNode nextNode;                           //聲明一個變量用來在移動過程中指向當前節點
        nextNode=nodeSta;                            //指向首節點
        
        //創建鏈表
        for(int i=1;i<10;i++){
            ListNode node = new ListNode(i);         //生成新的節點
            nextNode.next=node;                      //把心節點連起來
            nextNode=nextNode.next;                  //當前節點往后移動
        } //當for循環完成之后 nextNode指向最后一個節點，
        
        nextNode=nodeSta;                            //重新賦值讓它指向首節點
        print(nextNode);                             //打印輸出
     
        //插入節點
        while(nextNode!=null){
            if(nextNode.val==5){
                ListNode newnode = new ListNode(99);  //生成新的節點
                ListNode node=nextNode.next;          //先保存下一個節點
                nextNode.next=newnode;                //插入新節點
                newnode.next=node;                    //新節點的下一個節點指向 之前保存的節點
            }
            nextNode=nextNode.next;
        }//循環完成之后 nextNode指向最后一個節點
         nextNode=nodeSta;                            //重新賦值讓它指向首節點
         print(nextNode);                             //打印輸出
      
    }
    
    static void print(ListNode listNoed){
        //創建鏈表節點
        while(listNoed!=null){
            System.out.println("節點:"+listNoed.val);
            listNoed=listNoed.next;
        }
        System.out.println();
    }
}

 

替換節點：

class ListNode {        //類名 ：Java類就是一種自定義的數據結構
    int val;            //數據 ：節點數據 
    ListNode next;      //對象 ：引用下一個節點對象。在Java中沒有指針的概念，Java中的引用和C語言的指針類似
    
    ListNode(int val){  //構造方法 ：構造方法和類名相同   
        this.val=val;   //把接收的參數賦值給當前類的val變量
    }
}

class Test{
    public static void main(String[] args){
        
        ListNode nodeSta = new ListNode(0);          //創建首節點
        ListNode nextNode;                           //聲明一個變量用來在移動過程中指向當前節點
        nextNode=nodeSta;                            //指向首節點
        
        //創建鏈表
        for(int i=1;i<10;i++){
            ListNode node = new ListNode(i);         //生成新的節點
            nextNode.next=node;                      //把心節點連起來
            nextNode=nextNode.next;                  //當前節點往后移動
        } //當for循環完成之后 nextNode指向最后一個節點，
        
        nextNode=nodeSta;                            //重新賦值讓它指向首節點
        print(nextNode);                             //打印輸出
     
        //替換節點
        while(nextNode!=null){
            if(nextNode.val==4){
                ListNode newnode = new ListNode(99);  //生成新的節點
                ListNode node=nextNode.next.next;     //先保存要替換節點的下一個節點
                nextNode.next.next=null;              //被替換節點 指向為空 ，等待java垃圾回收
                nextNode.next=newnode;                //插入新節點
                newnode.next=node;                    //新節點的下一個節點指向 之前保存的節點
            }
            nextNode=nextNode.next;
        }//循環完成之后 nextNode指向最后一個節點
         nextNode=nodeSta;                            //重新賦值讓它指向首節點
         print(nextNode);                             //打印輸出
      
    }
    
    //打印輸出方法
    static void print(ListNode listNoed){
        //創建鏈表節點
        while(listNoed!=null){
            System.out.println("節點:"+listNoed.val);
            listNoed=listNoed.next;
        }
        System.out.println();
    }
}

 

刪除節點：

 

class ListNode {        //類名 ：Java類就是一種自定義的數據結構
    int val;            //數據 ：節點數據 
    ListNode next;      //對象 ：引用下一個節點對象。在Java中沒有指針的概念，Java中的引用和C語言的指針類似
    
    ListNode(int val){  //構造方法 ：構造方法和類名相同   
        this.val=val;   //把接收的參數賦值給當前類的val變量
    }
}

class Test{
    public static void main(String[] args){
        
        ListNode nodeSta = new ListNode(0);          //創建首節點
        ListNode nextNode;                           //聲明一個變量用來在移動過程中指向當前節點
        nextNode=nodeSta;                            //指向首節點
        
        //創建鏈表
        for(int i=1;i<10;i++){
            ListNode node = new ListNode(i);         //生成新的節點
            nextNode.next=node;                      //把心節點連起來
            nextNode=nextNode.next;                  //當前節點往后移動
        } //當for循環完成之后 nextNode指向最后一個節點，
        
        nextNode=nodeSta;                            //重新賦值讓它指向首節點
        print(nextNode);                             //打印輸出
     
        //刪除節點
        while(nextNode!=null){
            if(nextNode.val==5){
                ListNode listNode=nextNode.next.next;     //保存要刪除節點的下一個節點
                nextNode.next.next=null;                  //被刪除節點 指向為空 ，等待java垃圾回收
                nextNode.next=listNode;                   //指向要刪除節點的下一個節點
            }
            nextNode=nextNode.next;
        }//循環完成之后 nextNode指向最后一個節點
         nextNode=nodeSta;                            //重新賦值讓它指向首節點
         print(nextNode);                             //打印輸出
    }
    
    //打印輸出方法
    static void print(ListNode listNoed){
        //創建鏈表節點
        while(listNoed!=null){
            System.out.println("節點:"+listNoed.val);
            listNoed=listNoed.next;
        }
        System.out.println();
    }
}

 

補充說明：

在對節點進行替換或刪除的時候，被替換或被刪節點的next引用需不需要設置為null？

答案是： 不需要，因為一個對象被回收的前提是因為沒有任何地方持有這個對象的引用（引用計數器為0）也就是說它不在被引用，那么那么它將被回收，至於它引用什么對象無關緊要，因為對於它所引用的對象來說依然是看引用計數器是否為0；