剑指 Offer 06. 从尾到头打印链表

最新推荐文章于 2023-01-29 21:31:01 发布

_YAO阿瑶

最新推荐文章于 2023-01-29 21:31:01 发布

阅读量80

点赞数

分类专栏：剑指

本文链接：https://blog.csdn.net/weixin_44694952/article/details/112308613

版权

剑指专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文介绍了三种不同的方法来从尾到头打印链表的值：1) 使用Vector并反转，2) 利用Stack的先进后出特性，3) 通过递归实现。每种方法都提供了详细的代码实现，并附有执行时间和内存消耗。这些方法展示了C++在处理链表问题时的灵活性。

摘要由CSDN通过智能技术生成

文章目录

- - 解法

剑指 Offer 06. 从尾到头打印链表
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

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

限制：

0 <= 链表长度 <= 10000

解法

1. Vector

前到后遍历链表，将val值存放在vector里面，由于要反过来打印，因此可以利用vector的reverse函数进行反转，然后在输出即可
执行用时：8 ms, 在所有 C++ 提交中击败了72.64%的用户
内存消耗：8.7 MB, 在所有 C++ 提交中击败了83.90%的用户

struct ListNode
{
    int val;
    ListNode* next;
    ListNode();
    ListNode(int x):val(x),next(nullptr){}
};
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> ans;
        if(head == nullptr)
            return ans;
        ListNode *temp(head);
        ans.push_back(temp->val);
        while(temp!= nullptr && temp->next!= nullptr)
        {
            temp = temp->next;
            ans.push_back(temp->val);
        }
        reverse(ans.begin(),ans.end());
        return ans;
    }
};
int main()
{
    ListNode Node1(1);
    ListNode Node2(3);
    ListNode Node3(2);
    Node1.next = &Node2;
    Node2.next = &Node3;
    Solution s;
    vector<int> ans;
    ans = s.reversePrint(&Node1);
    mprint(ans);
    return 0;
}

2. Stack 栈先进后出

该方法与方法1大同小异
前到后遍历链表，由于要反过来打印，与栈先进后出功能吻合，所以先将val值存放在stack里面，然后再放回vector
12 ms 8.8 MB

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> ans;
        if(head == nullptr)
            return ans;
        stack<int> ans_temp;
        ListNode *temp(head);
        ans_temp.push(temp->val);
        while(temp!= nullptr && temp->next!= nullptr)
        {
            temp = temp->next;
            ans_temp.push(temp->val);
        }
        while(!ans_temp.empty())
        {
            ans.push_back(ans_temp.top());
            ans_temp.pop();
        }

        return ans;
    }
};

3.递归

栈和递归往往关联在一起
执行用时：4 ms, 在所有 C++ 提交中击败了96.53%的用户
内存消耗：11.5 MB, 在所有 C++ 提交中击败了6.79%的用户

vector<int> reversePrint(ListNode* head) {
        vector<int> ans;
        if(head == nullptr)
            return ans;
        if(head!= nullptr)
        {
            if(head->next != nullptr)
                ans = reversePrint(head->next);
        }
        ans.push_back(head->val);
        return ans;
    }