再次學習資料額結構，看到前面的單鏈表，感覺裡面的思路很不錯,自己動手寫程式碼嘗試一下，果然一動手就發現自己並沒有完全理解。這裡主要記錄我花了很長時間才理解的地方，不去考慮增刪改查，我覺得這些功能在很多地方都實現過，不是重點，也有很多資料可查。

單鏈表的原理網上很多，這裡也不解釋，先上程式碼。

這是一個節點類，用於記錄節點內容和物件引用（地址），其中不包含一些基本功能，只寫了必要的函式。

public class Node {
    Object data;//節點包含的具體內容
    Node next;//節點的引用，用於指向下一個節點

    Node (Node i){//建構函式1，用於初始化頭結點
 

        next=i;
    }

    Node (Object i,Node j){//建構函式2，用於其他節點。
        data=i;
        next=j;
    }

    public void setnext(Node nextval){//這個函式作用是把其他節點的引用指向這個節點。
        next=nextval;
    }
    public Object getelement(){//獲取節點的內容
        return data;
    }
}

這是我第一次做的測試函式

public class main_Node {

    public
 
 static void main(String[] args) {
        Node head;//頭結點
        Node current;//表示當前節點

        current=head=new Node(null);//初始化為空

        current.setnext(new Node(1,head.next));//新增一個節點
        current.setnext(new Node(2,current.next));//新增兩個節點
        current.setnext(new Node(3,current.next));//新增三個節點

        current=head.next;//讓current表示head的下一個節點，也就是第一個節點。
 


        int a=(int)current.getelement();//獲取該節點的內容
        System.out.println(a);//列印
    }

}

結果為3，這裡就有問題了，我命名讓他指向第一個節點，應該是1才對呀，怎麼會變成第三個呢？debug的結果是這樣的：：

可以看出來，這裡的head直接指向的是3，剛好反過來了，所以剛才得出的值是3。

看似很簡單的問題，我還是花了很長時間才發現問題。其實原因是這樣新增節點時，current所指向的節點並沒有變，還是在頭結點位置，新增節點並不能使current表示的節點後移，所以解決辦法是在每次添加了新的節點後把current往後移一下，讓它指向新新增的節點，這樣才能在新新增的節點後面再新增節點。程式碼如下：

public class main_test1 {

    public static void main(String[] args) {
        test1 head;
        test1 current;
        current=head=new test1(null);//這裡也表示current指向頭結點
        current.setnext(new test1(1,head.next));
        current=current.next;//使current指向下一個節點
        current.setnext(new test1(2,current.next));
        current=current.next;
        current.setnext(new test1(3,current.next));
        current=current.next;

        current=head.next;

        int a=(int)current.getelement();
        System.out.println(a);
    }

}

結果為1。這次正確了，再看debug圖：

看，這下順序就對了。
這裡主要的問題是，沒有想到新增新節點後想在其後面繼續新增，是要先移動當前current所指向的節點的位置的。感覺以後這個思路會給我幫助，記錄下來方便以後複習。

對這篇部落格的一些地方做一些補充，記錄自己思考的結果：
第八點：連結串列有環，如何判斷相交：
我自己想了另一種方法，應該比部落格中的效率高一點，其實也是借鑑了上面的思想，設定三個節點，其中一快一慢（和前面的一個意思，快的前進兩格）指向head1,另一個快指向head2。這裡思路是：如果兩個有環連結串列相交（這裡不考慮兩個無環連結串列相交的情況），那麼當前面設定的三個節點都進入環中的時候，就可以利用head2_fast去追趕head1_low,這裡最關鍵的地方是考慮什麼時候停止追趕，因為環內是可以無限迴圈的。仔細琢磨第5點的原理就能找到關鍵點了，看程式碼理解吧：

    public boolean isIntersect(Node head1,Node head2){
        //設定三個節點
        Node head1_low=head1;
        Node head1_fast=head1;
        Node head2_fast=head2;

        while(head1_fast!=null && head1_fast.next!=null && head2_fast!=null && head2_fast.next!=null){//如果有無環連結串列直接判斷不相交
            head1_low=head1_low.next;
            head1_fast=head1_fast.next.next;
            head2_fast=head2_fast.next.next;
            if(head1_low==head2_fast)//過程中如果運氣好，可以直接得到相交
                return true;
            else if(head1_low==head1_fast){//核心，也就是找到慢指標和快指標相交的點後就進行head2_fast追趕head1_low
                do{//這裡有個問題，如果head2除了環之外的部分特別長，那麼這裡是不成立的，就需要設立第四個節點，後面給出
                    head1_low=head1_low.next;
                    head2_fast=head2_fast.next.next;
                    if(head1_low==head2_fast)
                        return true;
                }while(head1_low.next!=head1_fast);//如果相交，head1_low跑一圈內必然能夠相等。
                return false;
            }

        }
        return false;
    }

給出上面的修正程式碼，其實就是要確認開始追趕時head2_fast已經進入環內，不然會出現head1_low跑完一圈head2_fast還未進環的情況，同樣通過給head2_fast也找個相交點來判斷是否進環：

        public boolean isIntersect(Node head1,Node head2){
            Node head1_low=head1;
            Node head1_fast=head1;
            Node head2_low=head2;
            Node head2_fast=head2;

            while(head1_fast!=null && head1_fast.next!=null && head2_fast!=null && head2_fast.next!=null){
                head1_low=head1_low.next;
                head1_fast=head1_fast.next.next;
                head2_low=head1_low.next;
                head2_fast=head2_fast.next.next;
                if(head1_low==head2_fast)
                    return true;
                else if(head1_low==head1_fast){
                    while(head2_low!=head2_fast){
                        head2_low=head1_low.next;
                        head2_fast=head2_fast.next.next;
                        if(head2_fast!=null && head2_fast.next!=null)
                            return false;
                    }
                    do{
                        head1_low=head1_low.next;
                        head2_fast=head2_fast.next.next;
                        if(head1_low==head2_fast)
                            return true;
                    }while(head1_low.next!=head1_fast);
                    return false;
                }
                else if(head2_low==head2_fast){
                    while(head1_low!=head1_fast){
                        head1_low=head1_low.next;
                        head1_fast=head1_fast.next.next;
                        if(head1_fast!=null && head1_fast.next!=null)
                            return false;
                    }
                    do{
                        head1_low=head1_low.next;
                        head2_fast=head2_fast.next.next;
                        if(head1_low==head2_fast)
                            return true;
                    }while(head1_low.next!=head1_fast);
                    return false;
                }

            }
            return false;
        }

其實變化不大，看一看就明白，不過這樣一來和原方法比較優勢就不明顯了。總之提供一種思路吧（以上方法沒有經過檢驗，可能有瑕疵）。

第九點：兩連結串列相交的第一個公共節點：
博主沒有寫這種方法，也許是他覺得沒必要，因為所有東西部落格上都提到了，有心人應該是自己能推理出來的：
把一個連結串列接到另一個連結串列的尾部，形成環，再用判斷環的入口，就ok了。是不是所有東西部落格裡都有寫到？