【剑指Offer记录】6-从尾到头打印链表

Part1. 我的思路和代码

查看结构体定义，发现节点具有指向后继的next指针，但没有指向前驱的指针，于是没有想到通过指针从尾到头遍历链表的方法。从头到尾遍历而逆序返回，和栈的“先进后出”思想相适应，因此从头到尾遍历，将节点的值压入栈，遍历结束后栈顶的值不断出栈，即是从尾到头遍历的结果。定义2个vector类的对象，tempArr临时保存从头到尾的值，然后逆向遍历tempArr保存到ans中，最后返回ans（定义stack类的对象更符合栈的思想，但对stack的用法陌生了些（诚实））。

遍历一次链表、遍历vector类对象的时间复杂度均为O(n)，总的时间复杂度为O(n)。

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/

vector<int> printListFromTailToHead(ListNode* head)
{
    vector<int> ans;
    vector<int> tempArr;

    if(head != nullptr){
        while(head->next != nullptr){
            tempArr.push_back(head->val);
            head = head->next;
        }
        tempArr.push_back(head->val);
    }
    for(int i=tempArr.size()-1; i>=0; i--){
        ans.push_back(tempArr[i]);
    }

    return ans;
}

特别记录：注意while循环中，要更新head指针，否则会成为死循环，最终造成内存超限。头节点是否为空指针也同样需要注意判断。

Part2. 其他做法

1-递归函数

递归本质上是一个栈结构，也可用递归实现。递归思路为：将“后面部分”的值按规定顺序加入返回值数组后，再把当前节点的值追加到数组末尾。递归中，保存返回值的数组只初始化一次，递归过程中仅修改，而不能重新初始化，因此定义为static型对象。

遍历一次链表即可完成递归，时间复杂度为O(n)。

vector<int> printListFromTailToHead(ListNode* head)
{
    static vector<int> ans;

    if(head == nullptr){ // 该if分支仅会判断输入链表的头节点是否为空。在递归中，链表的每个节点仅会进入else分支
        return ans;
    }
    else{
        if(head->next != nullptr){
            ans = printListFromTailToHead(head->next);
        }
        ans.push_back(head->val);
    }

    return ans;
}

特别记录：当递归层数很深时，可能造成内存超限，需要注意链表长度的最大值。以上代码提交时，占用的内存空间明显比非递归做法大。

2-改变节点指针指向

从头到尾遍历链表的每个节点，将其next指针改为指向前驱节点。修改后，链表原来的头、尾节点，分别变成了新链表的尾、头。最后遍历新的链表即可。做法上，定义3个指针，其中left、right分别指向相邻的两个节点，left指向左边的那个，right指向右边的那个，temp临时保存右边那个节点的next指针（如果不保存，就丢失了right的后继，链表就“断”了）。先用temp指向right节点的后继，然后将right的后继改为left节点，接着left指向right节点，right指向temp节点，循环该过程处理完每个节点的next指向，其中要注意的是原链表头节点的next指针需要特殊处理一下，改为空指针，以使其作为新链表的尾部。

遍历两次链表，时间复杂度均为O(n)，总的时间复杂度也为O(n)。

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
vector<int> printListFromTailToHead(ListNode* head)
{
    vector<int> ans;

    if(head != nullptr){
        ListNode *left;
        ListNode *right;
        ListNode *temp;

        left = head;
        right = left->next;
        left->next = nullptr; // 特殊处理头节点的next指针
        while(right != nullptr){ // 改变指针指向
            temp = right->next;
            right->next = left;
            left = right;
            right = temp;
        }
        temp = left; // 遍历修改后的链表
        while(temp != nullptr){
            ans.push_back(temp->val);
            temp = temp->next;
        }
    }

    return ans;
}

特别记录：这种做法改变了原链表的结构，遇到这种情况需要与面试官沟通，确定是否可行。要特别注意对头节点的next指针做处理，容易遗漏。

Part3. 心得体会

• 时间久不练编程还是很恐怖的，刚开始提交内存超限，想着64M的空间限制不算小，百思不得其解，最后发现是while循环中，没有更新指针使其指向下一个节点，一直不断地将头节点的值追加到数组。
• 递归的本质是栈的思想，但用递归时需要注意不要内存超限。
• 链表操作对指针的使用要求较高，在一些地方还需要特别注意指针是否为空，对头、尾节点有时需要进行特殊处理。