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

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

谁抢了我的昵称？

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

阅读量125

点赞数

分类专栏：剑指offer

本文链接：https://blog.csdn.net/weixin_42488861/article/details/113781926

版权

剑指offer 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

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

1.用栈实现（基础解法）

遍历单链表，将每个链表元素压入栈底，最后再依次弹出push进入vector即可

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int>ans;
        if(head==NULL){
            return ans;
        }
        stack<int>s;
//压栈
        while(head){
            s.push(head->val);
            head=head->next;
        }
//弹出
        while(!s.empty()){
            ans.push_back(s.top());
            s.pop();
        }
        return ans;
    }
};

执行用时：4 ms, 在所有 C++ 提交中击败了93.62%的用户

内存消耗：8.7 MB, 在所有 C++ 提交中击败了76.08%的用户

2.递归

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
     //法一：
    vector<int>ans;
    void dfs(ListNode* head){
        if(head==nullptr){
            return;
        }
        dfs(head->next);
        ans.push_back(head->val);
    }
    vector<int> reversePrint(ListNode* head) {
        if(head==nullptr){
            return ans;
        }
        dfs(head);
        return ans;
    }
    
    /*
    法二：
    vector<int>ans;
    vector<int> reversePrint(ListNode* head) {
        if(head==nullptr){
            return ans;
        }
        reversePrint(head->next);
        ans.push_back(head->val);
        return ans;*/
    
};

法一：

执行用时：4 ms, 在所有 C++ 提交中击败了93.62%的用户

内存消耗：9 MB, 在所有 C++ 提交中击败了34.75%的用户

法二：

执行用时：36 ms, 在所有 C++ 提交中击败了9.45%的用户

内存消耗：248.4 MB, 在所有 C++ 提交中击败了5.01%的用户

虽然两个方法思路一致，但是法二每次递归返回的是整个vector，所以时间和空间复杂度都要高出不少

这题尝试多种方法感觉我有些知识都忘记了，在这里顺便记一下：

定义数组需要指定大小以便分配空间；不指定空间需要在定义时初始化，就是int n[] = {,,,}，实际上是隐性分配空间。

3.一次遍历

先记录元素个数，再压入vector，使用逆向迭代器

另外说一下vector a[10]和vector a(10)的区别：

vector<int>a[10]表示的是a是一个数组，类型是vector< int > ，数组大小是10，a[0]-a[9]中每一个都是一个vector容器且是空的

vector a(10)是一个vector，初始化长度为10，默认初始化为0

关于C++11auto的使用：https://blog.csdn.net/dodoto/article/details/48413481

https://www.itranslater.com/qa/details/2582407456634700800#google_vignette

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        ListNode* temp=head;
        int cnt=0;
        while(temp){
            ++cnt;//链表元素个数
            temp=temp->next;
        }
       vector<int>ans(cnt);
        for(auto i=ans.rbegin();i!=ans.rend();++i){
            *i=head->val;//将这个地址内的数据修改
            head=head->next;
        }
        return ans;
        
    }
};

执行用时：0 ms, 在所有 C++ 提交中击败了100.00%的用户

内存消耗：8.4 MB, 在所有 C++ 提交中击败了93.77%的用户