【剑指offer】题型总结 - 链表

已于 2024-01-08 11:08:09 修改
阅读量316 收藏
点赞数
文章标签： 链表 数据结构 c++
于 2023-07-10 10:10:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43736572/article/details/131527477
版权
本文介绍了三种方法解决从尾到头打印链表问题，包括借助栈、逆序vector和递归。同时，详细解析了两种链表反转策略，以及复杂链表复制的三种解决方案，涉及原地修改、哈希表和回溯等技巧，并分析了各种方法的时间和空间复杂度。
摘要由CSDN通过智能技术生成

文章目录

链表

06. 从尾到头打印链表

题意

  • 逆序输出单向链表

解法1 借助栈

逆序输出 --》 先进后出 --》 栈

/**
 * 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) {
        stack<int> st;
        vector<int> res;

        while(head!=NULL)
        {
            st.push(head->val);
            head=head->next;
        }

        while(!st.empty())
        {
            res.push_back(st.top());
            st.pop();
        }
        
        return res;

    }
};
复杂度分析

时间复杂度 O(N)：遍历链表；
空间复杂度 O(N)：临时存储变量的栈。

解法2 逆序 vector

利用 reverse 函数 逆序 数组。

/**
 * 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) {
        stack<int> st;
        vector<int> res;

        while(head!=NULL)
        {
            res.push_back(head->val);
            head=head->next;
        }

        reverse(res.begin(), res.end());
        return res;

    }
};
复杂度分析

时间复杂度 O(N)：遍历链表；
空间复杂度 O(N)：临时存储变量的 vector。

reverse：

可以原地反转 vector / string / char[] 。

解法3 递归

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
private:
    vector<int> res;
public:
    void recur(ListNode* head)
    {
        if(head == nullptr)
            return;
        recur(head->next);
        res.emplace_back(head->val);
    }
    vector<int> reverseBookList(ListNode* head) {
        recur(head);
        return res;
    }
};
复杂度分析

时间复杂度： O ( N ) O(N) O(N)，遍历链表；
空间复杂度： O ( N ) O(N) O(N)，递归栈共 n n n 层。

24. 反转链表

题意

  • 反转链表

解法1 新建反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* ans=NULL;

        while(head != NULL)
        {
            if(ans == NULL)
                ans = new ListNode(head->val);
            else
            {
                ListNode* tmp = new ListNode(head->val);    // new，本质上是对指针做初始化
                tmp->next = ans;    // 链表指针这里next存的是指针指向的空间地址？对，next本身就是一个指针，所以本质上next的这个内存空间存的是指针指向的空间地址。
                ans = tmp;
            }
            head = head->next;
        }
        return ans;
    }
};
复杂度分析

时间复杂度 O(N)：遍历链表；
空间复杂度 O(N)：新建链表。

解法2 原地修改

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* ans;
        if(head == NULL) return NULL;
        ListNode* q = head->next;
        ListNode* p = NULL;

        while(head!=NULL)
        {
            q = head->next;
            head->next = p;
            p = head;
            head = q;

        }
        return p;
    }
};
复杂度分析

时间复杂度 O(N)：遍历链表；
空间复杂度 O(1)：原地修改。

解法3 递归

假设 nk+1 到 nm 都实现了反转，也就是说，现在要反转nk -> nk+1 为 nk <- nk+1，那么只要 nk->next->next=nk; nk->next=nullptr;

而为了得到反转后的链表头 head，从递归最尾端开始，将 newHead 返回。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
       if(head==nullptr || head->next == nullptr)   return head;

       ListNode* newHead = reverseList(head->next);
       head->next->next = head;
       head->next = nullptr;

       return newHead;
    }
};
复杂度分析

时间复杂度 O(N)：对链表的每个节点实现递归；
空间复杂度 O(N)：空间复杂度主要取决于递归调用的栈空间，最多为 N 层。

35. 复杂链表的复制

题意

  • 复制一个含有 next 和 random 的链表。

解答1 利用哈希表实现

因为 random 指向的节点可能是还没复制到的节点，所以 next 和 random 需要分开复制。

  • 第一次遍历，复制 val 和 next；
  • 第二次遍历，复制 random。
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head==nullptr) return nullptr;

        Node* newHead = new Node(head->val);
        Node* cur = newHead, *old = head;
        unordered_map<Node*, Node*> mp;

        while(old!=nullptr)
        {
            Node* nxt = nullptr;
            if(old->next!=nullptr)
                nxt = new Node(old->next->val);
            cur->next = nxt;
            mp[old] = cur;

            cur = cur->next;
            old = old->next;
        }

        mp[nullptr] = nullptr; 

        cur = newHead;
        while(head!=nullptr)
        {
            cur->random = mp[head->random];
            head = head->next;
            cur = cur->next;
        }
        return newHead;
    }
};
复杂度分析

时间复杂度 O(N)：两次遍历；
空间复杂度 O(N)：复制的链表和 map。

解答2 节点拆分

在每个节点 n 后复制一个节点 n’，然后将链表拆分成原链表和复制后的链表。

但是同样的，next 和 random 需要分两次遍历复制，再加上拆分，一共遍历 三 轮。

ps. 注意 nullptr 的处理。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        if (head == nullptr) {
            return nullptr;
        }
        for(Node* node=head; node!=nullptr; node=node->next->next)
        {
            Node* nodeNew = new Node(node->val);
            nodeNew->next = node->next;
            node->next = nodeNew;
        }
        for(Node* node=head; node!=nullptr; node=node->next->next)
        {
            Node* nodeNew = node->next;
            nodeNew->random = node->random == nullptr ? nullptr : node->random->next;
        }
        Node* headNew = head->next;
        for(Node* node=head; node!=nullptr; node=node->next)
        {
            Node* nodeNew = node->next;
            node->next = node->next->next;
            nodeNew->next = nodeNew->next == nullptr ? nullptr : nodeNew->next->next;
        }
        return headNew;
    }
};
复杂度分析

时间复杂度 O(N)：三次遍历；
空间复杂度 O(N)：复制的链表。

解法3 回溯

实际上这样的回溯本质上还是先实现了 next 的复制，然后回溯到了 newHead 进行 random 的复制。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    unordered_map<Node*, Node*> mp;

    Node* copyRandomList(Node* head) {
        if (head == nullptr) {
            return nullptr;
        }
        
        if(!mp.count(head))
        {
            Node* headNew = new Node(head->val);
            mp[head] = headNew;
            headNew->next = copyRandomList(head->next);
            headNew->random = copyRandomList(head->random);
        }
        
        return mp[head];
        
    }
};
复杂度分析

时间复杂度 O(N)：每个节点都要调用两次复制函数 copyRandomList；
空间复杂度 O(N)：复制的链表和哈希表。

总结

A. reverse：

可以原地反转 vector / string / char[] 。

B. 指针与 new

p->next 应当被视为一个指针。

-> 是指针用来访问结构体内成员的，所以实际上 p->next 表示的是指针 p 指向的结构体中的 next 成员，而 next 成员正是一个指针，因此，p->next 应当被视为一个指针。

指针与 new

C. map 的基本使用

map的基本使用

wtttcl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《剑指Offer》题目及代码（修订版2）.pdf
06-16
《剑指Offer》是著名的一本针对IT求职者尤其是程序员的面试题集，其中包含了大量高质量的面试题目及解题思路，涵盖了众多编程知识点和算法技巧，是业界公认的程序员求职宝典。这本书主要面向的是即将参加软件企业...
CodingInterviews:剑指offer2
03-08
《CodingInterviews:剑指offer2》是一本专注于C++编程语言的面试准备指南，它旨在帮助求职者熟练掌握在IT行业中，特别是软件开发领域所必需的编程技能和算法知识。书中涵盖了各种常见面试题型，包括但不限于数据结构...
剑指Offer-15-链表反转
大权子的博客
09-04 85
**题目：**输入一个链表，反转链表后，输出新链表的表头。 这是一道数据结构的题型，我觉得后插法是非常方便的（其他方法我不会！手动狗头！！） 上代码！！ class Solution15 { public static ListNode ReverseList(ListNode head) { if(head==null) { return null; } ...
剑指offer-题型总结
ZHE
08-15 809
文章目录数据结构类题目LinkedListTreeStack & QueueHeapHash Table图具体算法类题目搜索算法全排列动态规划回溯排序位运算其他算法 数据结构类题目 LinkedList 003-从尾到头打印链表 014-链表中倒数第k个结点 015-反转链表 016-合并两个或k个有序链表 025-复杂链表的复制 036-两个链表的第一个公共结点 ...
【剑指 Offer】链表-反转链表（经典题型）
码农研究僧的博客
06-24 168
题目： 定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 限制： 0 <= 节点个数 <= 5000 注意：本题与主站 206 题相同：https://leetcode-cn.com/problems/reverse-linked-list/ 思路一： 将其转换为链表 再将链表倒置过来 但返回类型与条
【剑指Offer】链表-删除链表的节点（经典题型）
码农研究僧的博客
06-24 171
题目： 给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。 返回删除后的链表的头节点。 注意：此题对比原题有改动 示例 1: 输入: head = [4,5,1,9], val = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 示例 2: 输入: head = [4,5,1,9], val = 1 输出: [4,5,9] 解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的
剑指offer第十天-----链表题总结
weixin_60343465的博客
01-11 198
总结一下所有做过的题型， 第一个从尾到头打印链表： 使用递归的时候，可以分两种 list=printListFromTailToHead(listNode.next); printListFromTailToHead(listNode.next); 就是说写递归的时候可以通过递归使用返回值，也可以使用递归放弃那个返回值，只执行函数里的操作。 写递归很容易发生空间复杂度太大不能通过的问题。 第二个反转链表 记住方法就行，先递归 然后head.next.ne...
数据结构-链表题型-剑指offer25
weixin_46254542的博客
07-11 76
剑指 Offer 25. 合并两个排序的链表 输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 思路： 声明一个新链表的head，依次去遍历这两个链表，看谁的值小就取谁，当某个链表为null时，取剩下那个链表即可 1、如果其中一个链表为null，直接返回另一个链表即可 2、p1、p2节点，用于遍历链表。声明虚拟头节点，用于生产新的链表 这里为什么用虚拟头节点，而不能用头节点，val是int，它的默认值是0，如果你把头节点的val赋值为0，那合并后的链表就多了一个节点 同理，val
剑指offer--所有链表题型题解及代码，Java语言
erciyuan_的博客
04-14 148
1、树的子结构 题目描述： 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） 思路： 递归判断，其中一个函数hasSubTree判读一个树是不是另一个树的子树，函数isSubTree判断两棵树是不是相等，根节点相等则判断左右子树是否相等。 代码： /** public class TreeNode { int val = 0; Tree...
LeetCode刷题总结 - 剑指offer系列 - 持续更新
qq_45464560的博客
12-24 3506
LeetCode刷题总结
刷穿剑指offer-Day12-链表II 链表的环与交点
清风Python
09-06 215
昨日回顾 昨天我们初步介绍了链表的相关知识，并且通过列举数组和链表的差异，进行了比较学习。之后介绍了链表涉及的相关题型，并举例了第一种链表的第一种删除类题目。那么今天我们就来看看链表的第二类题目：链表的环与交点 环形链表 链表的环是一类在链表中很爱考察的热门题目，今天针对这类题目，带着大家一起学习下。 对于一般的链表，会存在一个头节点，然后根据链表指针一直遍历到链表的结尾即null。但有一种环形链...
leetcode题库-leetcode:leetcode、剑指offer刷题集
06-29
总结来说，LeetCode题库和《剑指Offer》结合使用，是提升编程技能、准备面试的理想资源。通过系统地刷题和参与开源社区，不仅可以深入理解算法和数据结构，还能锻炼解决问题的能力，为职业生涯添砖加瓦。在实际练习...
leetcode围棋-leetcode:Leetcode&剑指offer部分题解
07-01
最后一章主要是《剑指offer》上的题目，其中有一部分题目是与之前章节重合的。 目前只有Java语言的实现，后续考虑会加入Javascript以及Go语言的实现。但是鉴于个人有限的精力和时间，也可能不会实施...... 如果有...
Coding_Interviews:主要刷剑指Offer、TopCode、Leetcode
04-17
通过解决剑指Offer中的问题，你可以提升对二叉树、链表、排序、搜索等经典算法的理解。 2. **TopCode**：这是一个在线编程竞赛和面试题平台，它提供了大量的编程挑战，涵盖了各种难度级别的题目。参与TopCode的训练...
数据结构之并查集
我要学编程的博客
08-21 1208
并查集相关概念、模拟实现并查集、并查集的应用：省份的数量、等式方程的可满足行
【Redis】Redis 底层的数据结构（结合源码）
秋玄的博客
08-22 849
Redis 底层数据结构详解
算法的学习笔记—二叉搜索树的后序遍历序列(牛客JZ33)
最新发布
业精于勤，荒于嬉
08-22 802
通过递归地判断数组的子序列是否满足二叉搜索树的性质，我们可以有效地判断一个数组是否是某二叉搜索树的后序遍历序列。这个方法在逻辑上比较直观，并且能够处理复杂的情况，尽管其时间复杂度为O(n^2)，但在实际应用中仍然是一个实用的算法。希望通过这篇文章，大家能够更加深入地理解二叉搜索树及其后序遍历的相关概念，并掌握如何通过编程来解决这类问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVC。
数据结构—— 再探二叉树
hedhjd的博客
08-21 926
前面我们的完全二叉树和满二叉树是使用数组来存储，如果不是完全二叉树和满二叉树就不适合使用数组存储，更适合链式结构来存储二叉树是：1. 空树2. 非空：根结点，根结点的左子树、根结点的右子树组成的3.二叉树是递归结构二叉树是整棵树拆分为根和子树，然后拆分过的子树再作为根继续拆分，一直这样持续至最后一个没有子树的根在遍历之前先手搓一个二叉树的基础模板}BTNode;//node1的左和右指向node2和node4//node1的左指向node3。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值