LeetCode-劍指Offer-06-從尾到頭打印鏈表

---

題意描述：

輸入一個鏈表的頭節點，從尾到頭反過來返回每個節點的值（用數組返回）。

限制: 0 <= 鏈表長度 <= 10000

---

示例：

輸入：head = [1,3,2]
輸出：[2,3,1]

---

解題思路：
Alice: 單向鏈表怎麼反轉啊 ？
Bob: 單向鏈表可以反轉啊，我們還做過題目哩，不過反轉鏈表不如反轉數組好寫。
Alice: 反轉數組 ？ 可以用Python列表直接切片，或者我們自己交換也可以。
Bob:是的，可以遍歷兩遍鏈表，第一遍找到鏈表中一共有多少個元素，然後一個指針指向數組末尾，往前走，一個鏈表指向鏈表頭部，往後走，這樣一遍下來就可以了。
Alice: 不錯不錯。😎😎

---

代碼：

Python 方法一： 數組切片

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        ret = []
        while head != None:
            ret.append(head.val)
            head = head.next
        return ret[::-1]

Python 方法二： 遍歷兩次鏈表 + 數組逆向索引。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        cnt  = 0
        node = head
        while node != None:
            cnt += 1
            node = node.next
        ret = [0 for x in range(cnt)]
        node = head
        while node != None:
            cnt -= 1
            ret[cnt] = node.val
            node = node.next
        return ret
            
        

Python 方法三： 遍歷鏈表 + 逆序數組

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        ret = []
        while head != None:
            ret.append(head.val)
            head = head.next
        index = 0
        while index < len(ret) // 2:
            ret[index], ret[len(ret)-1-index] = ret[len(ret)-1-index], ret[index]
            index += 1
        return ret

Java 方法一： ArrayList + 逆向索引。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        
        ArrayList<Integer> tmp = new ArrayList<Integer>();
        ListNode node = head;
        while(node != null){
            tmp.add(node.val);
            node = node.next;
        }
        int[] ret = new int[tmp.size()];
        for(int i=tmp.size()-1; i>=0; --i){
            ret[tmp.size()-1-i] = tmp.get(i);
        }
        return ret;
    }
}

Java 方法二： 兩次遍歷鏈表 + 數組逆向索引。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        int cnt = 0;
        ListNode node = head;
        while(node != null){
            cnt++;
            node = node.next;
        }
        int[] ret = new int[cnt];
        node = head;
        while(node != null){
            ret[--cnt] = node.val;
            node = node.next;
        }
        return ret;
    }
}

Java 方法三： 兩次遍歷鏈表 + 反轉數組

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        int cnt = 0;
        ListNode node = head;
        while(node != null){
            cnt += 1;
            node = node.next;
        }
        int[] ret = new int[cnt];
        node = head;
        int index  = 0;
        while(node != null){
            ret[index++] = node.val;
            node = node.next;
        }
        index = 0;
        int tmp = 0;
        while(index < cnt / 2){
            tmp = ret[index];
            ret[index] = ret[cnt-1-index];
            ret[cnt-1-index] = tmp;
            index += 1;
        }
        return ret;
    }
}

---

易錯點：

• 一些測試樣例：

[]
[1]
[1,2]
[1,3,2]

• 答案：

[]
[1]
[2,1]
[2,3,1]

---

總結：

---