劍指offer——從尾到頭打印鏈表節點的值

輸入一個鏈表，從尾到頭打印鏈表每個節點的值。

輸入描述：輸入為鏈表的表頭

輸出描述：輸出為需要打印的“新鏈表”的表頭

---

 

一、問題分析

---

 

　　初拿到這個題目時，這應該是考察單向鏈表這一數據結構。單向鏈表的遍歷總是從頭指針逐項遍歷各個節點，現在要求從尾到頭打印節點的值，我們可以在遍歷時把各節點壓入棧內，最后出棧打印各個節點值，即可達到要求。

　　實現之前，我們先來看看如何創建一個鏈表。

　　1，鏈表節點的數據結構定義

1 struct ListNode {
2     int val; 3 struct ListNode *next; 4 ListNode(int x) : 5  val(x), next(NULL) { 6  } 7 };

　　在鏈表的定義中，包含自己的整形成員（當然也可以定義為其它數據類型，如double），以及下一個節點的位置信息（next）。這里我們還定義了節點的構造函數（ListNode），方便節點的初始化。

　　2，鏈表的創建

　　這里我們考慮單向鏈表。如果通過用戶輸入來創建鏈表，我們可以進行如下操作：

　　1)創建頭節點head，指向NULL。因為此時沒有任何節點

　　2）為加入的節點分配空間，賦初值（如1中考慮的int類型）並指向NULL。判斷head==NULL?head指向該節點：“上一節點”指向該節點

　　3）更新新加入的節點為“上一節點”

　　4）判斷節點是否添加結束，若否，重復2,3,4步驟繼續添加節點。

---

 

二、問題的解決思路

---

 

　　1，利用stack反轉輸出鏈表節點值

#include <iostream>
#include <vector>
#include <stack>
using namespace std;

//鏈表節點定義
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
        }
};

//鏈表從尾到頭輸出節點值方法實現
class Solution {
    public:
        //方法1，通過stack 這個container來實現反轉鏈表
        vector<int> printListFromTailToHead(struct ListNode* head) {
            vector<int> result;
            if(head == NULL)
                return result;
            stack<ListNode*> reverse;
            ListNode* node = head;
            while(node != NULL) {
                reverse.push(node);
                node = node->next;
            }
            while(!reverse.empty()) {
                node = reverse.top();
                result.push_back(node->val);
                reverse.pop();
            }
            return result;
        }
        //方法2，原地反轉鏈表，不介入其它container
        //不斷的使“下一個節點”指向“前一個”節點
        vector<int> printListFromTailToHead2(struct ListNode* head) { 
            vector<int> vec; 
            ListNode *buf = head; 
            ListNode *pre = buf; 
            if(head == NULL) 
                return vec; 
            while(head->next != NULL){ 
                buf = head->next; 
                head->next = buf->next; 
                buf->next = pre; 
                pre = buf; 
            } 
            while(buf){ 
                vec.push_back(buf->val); 
                buf = buf->next; 
            } 
            return vec; 
        }
};

struct ListNode* CreateListNode(struct ListNode* head) {
    struct ListNode *p1, *p2;
    int i = 1;
    p1 = p2 = (struct ListNode*)malloc(sizeof(ListNode));
    cout << "Please input the 1st node, it's address is p1_addr = " << p1 << endl;
    cout << "And input -1 to quit.";
    cin >> (p1->val);
    p1->next = NULL;

    while (p1->val != -1) {
        if (NULL == head) {
            head = p1;
        }
        else
            p2->next = p1;
        p2 = p1;
        p1 = (struct ListNode*)malloc(sizeof(ListNode));
        ++i;
        cout << "Please input the " << i << " node," << "it's address is p" << i << "_addr = " << p1 <<endl;
        cin >> (p1->val);
    }
    free(p1);
    p2->next = NULL;
    p1 = NULL;
    cout << "End of creating ListNode." << endl;
    return head;
}

int main () {
    std::vector<int> v;
    struct ListNode* head = NULL;
    head = CreateListNode(head);

    Solution s;
    v = s.printListFromTailToHead2(head);
    for (int var : v) {
        cout << var << ' ';
    }

    //測試節點的初始化，與本題無關
    struct ListNode myListNode(100);
    cout << myListNode.val << endl;

}

　　上述程序在gcc version 6.1.0下編譯通過。

　　在上面的程序中，實現反轉的方法有兩個：

　　1）利用stack先入后出的特性實現鏈表的反轉

　　2）不借用其它container，不斷的使“后一個”節點指向“前一個節點”來原地反轉鏈表。下面來談談原地反轉鏈表

　　2，原地反轉鏈表

　　我們看函數printListFromTailToHead2()。首先，我們先定義兩個指針(buf, pre)，並與head共同指向鏈表的頭節點。然后，通過head->next遍歷原始鏈表，並同時更新buf指向已經遍歷到的節點(buf = head->next)，而這期間head始終指向頭節點。然后，更新head—>next指向buf的下一個節點(head->next = buf->next)。接着，通過buf->next = pre, 使buf指向前一個節點，緊接着更新pre，使其指向當前節點，以便下一輪更新。

　　當head->next遍歷完鏈表后，buf指向了原始鏈表最后一個節點，head->next的值變為了NULL。現在從buf開始遍歷，即可反向遍歷鏈表。