本文為資料結構基礎，研究得不是很深。用Java實現單鏈表的反轉，雖然本文研究得不是很深，但是因為是資料結構，所以必須是在對Java記憶體比較清楚的情況下才能真正的搞懂吃透，如果對Java記憶體不夠清楚，那最多隻能學形而不能學其內在。

         首先我們要搞清楚連結串列是啥玩意兒？先看看定義：

         講連結串列之前我們先說說Java記憶體的分配情況：我們new物件的時候，會在java堆中為物件分配記憶體，當我們呼叫方法的時候，會將方法載入到方法區，在方法區儲存了載入類的資訊，常量，靜態變數等等。搞明白這個我們再來講連結串列。

       連結串列是一種物理儲存單元

上非連續、非順序的儲存結構，資料元素的邏輯順序是通過連結串列中的指標連結次序實現的。連結串列由一系列結點（連結串列中每一個元素稱為結點）組成，結點可以在執行時動態生成。每個結點包括兩個部分：一個是儲存資料元素的資料域，另一個是儲存下一個結點地址的指標域。 這個定義估計太過書面化，對初學者來說，不好理解，其實簡單點說就是醬紫的。我們建立了一個類Node，這個類當中有兩個變數，一個data用於儲存資料，還有一個Node型別的變數next用於儲存另一個物件在java堆中的地址。然後new了很多個Node類的物件，我們通過setNext方法將第二個物件node2的地址給node1儲存起來，同樣的將第三個物件node3的地址交給node2儲存起來。通過這種方式，我們就將很多個物件連成串了，形成了一種鏈狀。這就是連結串列了。

       這兒著重宣告：在Java中，沒有地址一說，只有hashCode。其實hashCode就是通過演算法，將每一個物件的地址算成一個code轉成一個特有的字串。當我們沒有複寫Object類的toString方法的時候，該類的物件呼叫toString方法，打印出來，或者不呼叫toString方法，直接列印該類的物件，其實就是將hashCode打印出來了。這個hashCode就相當於是記憶體了。

     好了搞懂了這些我們就可以來看看例項了：

節點Node類，其實節點就是我們的物件，每一個節點就是一個物件。

/**
 * 其實一個節點就對應我們java中的一個物件，我們在分析的時候需要注意除了
 
next要儲存一個地址外，自己也是物件自己也有地址
* Created by PICO-USER dragon on 2017/3/16.
 */
public class Node {

    //資料域儲存資料
private int data;

    //指標域用於儲存下一個節點的地址
private Node next;

    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;
    }
}

反轉連結串列的方法，當傳入的節點為null的時候，直接染回null。如果只有一個節點，頭尾都是它，直接返回該節點

public static Node reverseList(Node head) {

    if (head == null) {

        return null;
    }

    if (head.getNext() == null) {
        return head;
    }

    //previous上一個節點
Node preNode = null;
    //current節點當前節點，並讓它指向傳進來的物件所在地址（是儲存該物件的地址，不是它的next值）
Node curNode = head;
    //next節點下一個節點
Node nextNode = null;

    while (curNode != null) {

        //讓next節點指向後一個節點所在地址，並改變新地址的值（包括data，next）
nextNode = curNode.getNext();
        if (nextNode != null) {
            System.out.print("nextNode data :" + nextNode.getData() + " next :" + nextNode.getNext() + " " + nextNode + "\n");
        }

        //將current節點儲存的地址（也就是next）的值改為preNode節點所指向的地址（這樣就把指向箭頭反轉了）這兒有個誤區
//注意：是將preNode指向的地址給curNode的next，不是把preNode的next給它。
curNode.setNext(preNode);
        if (curNode != null) {
            System.out.print("curNode data :" + curNode.getData() + " next :" + curNode.getNext() + " " + curNode + "\n");
        }

        //讓previous節點指向的地址向後移動一個單位，並改變新地址的值（包括data，next）
preNode = curNode;
        if (preNode != null) {
            System.out.print("preNode data :" + preNode.getData() + " next :" + preNode.getNext() + " " + preNode + "\n");
        }

        //讓current節點的索引向後移動一個單位，並改變新地址的值包括（data，next）
curNode = nextNode;
        if (curNode != null) {
            System.out.print("curNode data :" + curNode.getData() + " next :" + curNode.getNext() + " " + curNode + "\n");
        }

        System.out.print("-----------------------\n");
    }

    return preNode;
}

public class MainRun {

    public static void main(String[] arg0) {

        //建立連結串列的節點，建立了三個物件，那就是三個節點
Node node0 = new Node(1);
        Node node1 = new Node(2);
        Node node2 = new Node(3);
        //將這些節點，串連起來形成連結串列
node0.setNext(node1);
        node1.setNext(node2);

        //連結串列的頭結點代表了該連結串列，因為頭結點能找到第二個，第二個能找到第三個，依次找下去，全都找到了
Node head1 = node0;

        //先列印反轉之前的連結串列的值，將hashCode一起打印出來，方便去每一行程式碼都對誰做了什麼操作
while (head1 != null) {

            System.out.print("data :" + head1.getData() + " next :" + head1.getNext() + "  " + head1.toString() + "\n");
            head1 = head1.getNext();
        }

        System.out.print("---++++++-----\n");

        //注意了，我們是從頭開始反轉，所以這兒不能用head1，因為head1在上面的while迴圈中已經成為最後一個節點了
Node oldHead = node0;
        Node newHead = reverseList(oldHead);

        //列印反轉後的節點
while (newHead != null) {

            System.out.print("data :" + newHead.getData() + " next :" + newHead.getNext() + " " + newHead + "\n");
            newHead = newHead.getNext();
        }

    }

看看執行結果：

下面給出分析結果，我自己用筆畫的，網友可以根據這個分析步驟，跟著while迴圈的程式碼一句一句往下分析，每一行程式碼執行之後改動的值是什麼？多看看，多分析分析就通了。

第二種方法：遞迴呼叫實現單鏈表反轉

/**
 * 因為遞迴的思想是直接更改當前節點的next的值為前一個節點所在的地址，所以需要用到兩個引數，當前節點和前一個節點，
* 這兒給外面用就只給一個方法，我們再自己封一個兩個引數的方法。
*
 * @param head
* @return
*/

public static Node reverseList2(Node head) { return reverseListRecursively(null, head);}/** * 遞迴呼叫實現的思想很簡單，就是直接改變curNode的next的值。原本是指向後面一個節點的，現在需要改為前一個節點。* 所以參與演算法的人只有當前節點和當前的前一個節點，而下一個節點的作用只是用於讓需要更換next的物件往後面移動* * @param preNode* @param curNode* @return*/public static Node reverseListRecursively(Node preNode, Node curNode) { if (curNode == null) { return null; } if (curNode.getNext() == null) { curNode.setNext(preNode); return curNode; } //將curNode中儲存的地址改成前一個節點所在的地址curNode.setNext(preNode); //如果當前節點有下一個節點就將該節點拿出來Node nextNode = curNode.getNext(); //遞迴呼叫本方法，相當於讓preNode和curNode指向的地址都向後移動一個單位，直到所有的節點都將自己儲存的地址改為前一個為止Node newNode = reverseListRecursively(curNode, nextNode); return newNode;}

public static void main(String[] arg0) {

    //建立連結串列的節點，建立了三個物件，那就是三個節點
Node node0 = new Node(1);
    Node node1 = new Node(2);
    Node node2 = new Node(3);
    //將這些節點，串連起來形成連結串列
node0.setNext(node1);
    node1.setNext(node2);

    //連結串列的頭結點代表了該連結串列，因為頭結點能找到第二個，第二個能找到第三個，依次找下去，全都找到了
Node head1 = node0;

    //先列印反轉之前的連結串列的值，將hashCode一起打印出來，方便去每一行程式碼都對誰做了什麼操作
while (head1 != null) {

        System.out.print("data :" + head1.getData() + " next :" + head1.getNext() + "  " + head1.toString() + "\n");
        head1 = head1.getNext();
    }

    System.out.print("---++++++-----\n");

    //注意了，我們是從頭開始反轉，所以這兒不能用head1，因為head1在上面的while迴圈中已經成為最後一個節點了
Node oldHead = node0;
    Node newHead = reverseList2(oldHead);

    //列印反轉後的節點
while (newHead != null) {

        System.out.print("data :" + newHead.getData() + " next :" + newHead.getNext() + " " + newHead + "\n");
        newHead = newHead.getNext();
    }

}