剑指Offer 链表题目集合

已于 2023-12-22 10:06:43 修改
阅读量549 收藏 9
点赞数 8
分类专栏： 剑指offer系列 leetcode 文章标签： 链表 数据结构 C++ python
于 2023-12-06 17:56:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JulyLi2019/article/details/134837270
版权

目录

从尾到头打印链表

刷题链接：

https://www.nowcoder.com/practice/d0267f7f55b3412ba93bd35cfa8e8035
题目描述
在这里插入图片描述

思路一：
我的第一想法是可以遍历链表，将每个节点的值存入数组中，然后将数组进行反转。

在这里插入图片描述

复杂度分析

时间复杂度：O(n)。正向遍历一遍链表。
空间复杂度：O(n)。额外使用一个数组存储链表中的每个节点。

python3

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param listNode ListNode类 
# @return int整型一维数组
#
class Solution:
    def printListFromTailToHead(self , listNode: ListNode) -> List[int]:
        res = []
        while listNode:
            res.append(listNode.val)
            listNode = listNode.next
        return res[::-1]

C++

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> result;
        ListNode* current = head;
        while (current != nullptr) {
            result.push_back(current->val);
            current = current->next;
        }
        reverse(result.begin(), result.end());
        return result;
    }   
};

反转链表

刷题链接：
https://www.nowcoder.com/practice/75e878df47f24fdc9dc3e400ec6058ca

题目描述
在这里插入图片描述

思路一：
采用双指针迭代，在遍历链表时，将当前节点的next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。
在这里插入图片描述

复杂度分析

时间复杂度：O(n)，正向遍历一遍链表。
空间复杂度：O(1)，常数空间复杂度。

python3

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param head ListNode类 
# @return ListNode类
#
class Solution:
    def ReverseList(self , head: ListNode) -> ListNode:
        # write code here
        pre , cur = None ,head
        while cur:
            # 暂存后继节点 cur.next
            tmp = cur.next
            # 修改 next 引用指向
            cur.next = pre
            # pre 暂存 cur
            pre = cur
            # cur 访问下一节点
            cur = tmp
        return pre

C++

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* ReverseList(ListNode* head) {
        ListNode *cur = head,*pre=nullptr;
        while(cur != nullptr){
            // 暂存后继节点 cur.next
            ListNode *tmp = cur->next;
            // 修改 next 引用指向
            cur->next = pre;
            // pre 暂存 cur
            pre = cur;
            // cur 访问下一节点
            cur = tmp;
        }
        return pre;
    }
};

合并两个排序的链表

刷题链接：
https://www.nowcoder.com/practice/d8b6b4358f774294a89de2a6ac4d9337

题目描述
在这里插入图片描述
在这里插入图片描述

思路一：
由于两个链表是递增的，可以使用双指针遍历两个链表，通过pHead1.val与pHead2.val的大小关系确定节点添加顺序，两节点指针交替前进，直至遍历完毕。
在这里插入图片描述

复杂度分析

时间复杂度：O(m+n)，m,n 分别为两个链表的长度。
空间复杂度：O(1)，常数空间复杂度。

python3

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param pHead1 ListNode类 
# @param pHead2 ListNode类 
# @return ListNode类
#
class Solution:
    def Merge(self , pHead1: ListNode, pHead2: ListNode) -> ListNode:
        cur = head = ListNode(0)
        while pHead1 and pHead2:
            if pHead1.val <= pHead2.val:
                cur.next, pHead1 = pHead1, pHead1.next
            else:
                cur.next, pHead2 = pHead2, pHead2.next
            cur = cur.next
        cur.next = pHead1 if pHead1 else pHead2
        return head.next

C++

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead1 ListNode类 
     * @param pHead2 ListNode类 
     * @return ListNode类
     */
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        ListNode *cur = new ListNode(0);
        ListNode *head = cur;
        while(pHead1 != nullptr && pHead2 != nullptr){
            if(pHead1->val <= pHead2->val){
                cur->next = pHead1;
                pHead1 = pHead1->next;
            }
            else{
                cur->next = pHead2;
                pHead2 = pHead2->next;
            }
            cur = cur->next;
        }
        cur->next = pHead1 ? pHead1 : pHead2;
        return head->next;
    }
};

两个链表的第一个公共结点

刷题链接：
https://www.nowcoder.com/practice/6ab1d9a29e88450685099d45c9e31e46

题目描述
在这里插入图片描述

思路一：
两个链表长度不一定相等，但两个链表相加的长度是相等的，即L1+L2 = L2+L1，使用两个指针分别从两个链表头节点出发，两个指针分别走完当前链表后，再从另一个链表重新开始走，直到相遇。
在这里插入图片描述

复杂度分析

时间复杂度：O(m+n)，需遍历m + n 个节点。
空间复杂度：O(1)，常数空间复杂度。

python3

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

#
# 
# @param pHead1 ListNode类 
# @param pHead2 ListNode类 
# @return ListNode类
#
class Solution:
    def FindFirstCommonNode(self , pHead1 , pHead2 ):
        p1 = pHead1
        p2 = pHead2
        while p1 != p2:
            p1 = p1.next if p1 else pHead2
            p2 = p2.next if p2 else pHead1
        return p1

C++

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2) {
        ListNode *p1 = pHead1;
        ListNode *p2 = pHead2;

        while (p1 != p2) {
            p1 = (p1 ? p1->next : pHead2);
            p2 = (p2 ? p2->next : pHead1);
        }

        return p1;
    }
};

链表中环的入口结点

刷题链接：
https://www.nowcoder.com/practice/253d2c59ec3e4bc68da16833f79a38e4

题目描述
在这里插入图片描述

思路一：
可以通过哈希表来实现。遍历链表，如果节点在哈希表中，则说明这个节点就是环的入口节点，否则就将该节点存入哈希表。

复杂度分析

时间复杂度：O(n)，需遍历链表。
空间复杂度：O(n)，至多存整个链表的所有的结点。

python3

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, pHead):
        nodes = {}
        while pHead:
            if pHead in nodes:
                return pHead
            else:
                nodes[pHead] = 1
                pHead = pHead.next
        return None

C++

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead) {
        std::unordered_map<ListNode*, int> nodes;
        while (pHead) {
            if (nodes.find(pHead) != nodes.end()) {
                return pHead;
            } else {
                nodes[pHead] = 1;
                pHead = pHead->next;
            }
        }
        return nullptr;
    }
};

链表中倒数最后k个结点

刷题链接：
https://www.nowcoder.com/practice/886370fe658f41b498d40fb34ae76ff9

题目描述
在这里插入图片描述

思路一：
快慢针间隔k步，然后遍历链表，快慢指针同步移动，当快指针到达链表尾部的时候，慢指针正好到了倒数k个元素的位置。
在这里插入图片描述

复杂度分析

时间复杂度：O(n)，需遍历链表。
空间复杂度：O(1)，常数级指针变量，无额外辅助空间使用。

python3

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param pHead ListNode类 
# @param k int整型 
# @return ListNode类
#
class Solution:
    def FindKthToTail(self , pHead: ListNode, k: int) -> ListNode:
        p1 = p2 = pHead
        for i in range(k):
            if p2 != None:
                p2 = p2.next
            #达不到k步说明链表过短，没有倒数k
            else:
                return None
        while p2:
            p2 = p2.next
            p1 = p1.next
        return p1

C++

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        ListNode* p1 = pHead;
        ListNode* p2 = pHead;

        for (int i = 0; i < k; ++i) {
            if (p2 != nullptr) {
                p2 = p2->next;
            } else {
                return nullptr;  // 链表过短，没有倒数第 k 个节点
            }
        }

        while (p2 != nullptr) {
            p2 = p2->next;
            p1 = p1->next;
        }

        return p1;
    }
};

删除链表的节点

刷题链接：
https://www.nowcoder.com/practice/f9f78ca89ad643c99701a7142bd59f5d

题目描述
在这里插入图片描述

思路一：
双指针遍历链表，找到目标节点，则将pre.next指向cur.next。
在这里插入图片描述

复杂度分析

时间复杂度：O(n)，需遍历链表。
空间复杂度：O(1)，常数级指针变量，无额外辅助空间使用。

python3

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param head ListNode类 
# @param val int整型 
# @return ListNode类
#
class Solution:
    def deleteNode(self , head: ListNode, val: int) -> ListNode:
        if(head.val == val):return head.next
        pre = head
        cur = head.next
        while cur != None and cur.val != val:
            pre =cur
            cur = cur.next
        pre.next = cur.next
        return head

C++

/**
 * struct ListNode {
 *  int val;
 *  struct ListNode *next;
 *  ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @param val int整型
     * @return ListNode类
     */
    ListNode* deleteNode(ListNode* head, int val) {
        if (head == nullptr) {
            return nullptr;
        }

        if (head->val == val) {
            return head->next;
        }

        ListNode* pre = head;
        ListNode* cur = head->next;

        while (cur != nullptr && cur->val != val) {
            pre = pre->next;
            cur = cur->next;
        }
        pre->next = cur->next;

        return head;
    }
};
AI小笔记
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
《剑指Offer》题目及java代码实现
12-10
《剑指Offer》是一本备受推崇的编程面试指南，它集结了众多知名互联网公司的面试题，旨在帮助程序员提升算法和编程能力，为求职面试做好准备。本书主要关注于Java语言的实现，通过解决书中提出的各类问题，读者可以...
剑指Offer题目Java实现代码
08-17
这个"src"目录中的Java代码很可能是针对《剑指Offer》中的各个题目进行的具体实现，涵盖了以上提到的数据结构、算法、设计模式等多个方面，对于学习和复习Java编程知识，以及准备面试来说，都是非常宝贵的资源。...
《剑指offer》题目汇总
李滚滚的博客
03-28 1362
文章目录面试题1 赋值运算符函数以上是基本的内容，但还是有代码异常安全性问题存在。 面试题1 赋值运算符函数 题目：如下为类型CMyString的声明，请为该类型添加赋值运算符函数。 class CMyString { public: CMyString(char* pData = nullptr); CMyString(const CMyString& str); ~CMyStri...
【剑指offer】链表题目集合
littlemichelle
09-09 175
从尾到头打印链表 class Solution: # 返回从尾部到头部的列表值序列，例如[1,2,3] def printListFromTailToHead(self, listNode): rs = [] if not ListNode:return rs while listNode: rs.appe...
剑指offer——链表题目集合(Python)
woshicao11的博客
08-13 824
链表的题，感觉会了链表的操作应该是没什么问题．链表的访问都是基于while. １　链表中倒数第ｋ个节点 题目描述 输入一个链表，输出该链表中倒数第k个结点。 解题思路：两种方法，第一种是先访问一便链表，知道链表长度ｎ，然后走到ｎ－ｋ的结点就是．第二个就是先让一个走ｋ步，然后２个一起走，第一个走到头，返回第二个当前所在的结点．由于时间复杂度都一样,就第一种． class Solution...
剑指offer -复杂链表的复制
weixin_42870497的博客
07-28 99
复杂链表的复制题目描述算法思路代码实现 题目描述 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）。 下图是一个含有5个结点的复杂链表。图中实线箭头表示next指针，虚线箭头表示random指针。为简单起见，指向null的指针没有画出。 示例: 输入:{1,2,3,4,5,3,5,#,2,#} 输出:{1,2,3,4,5,
《剑指Offer》--- 数据结构の链表篇
Lucky_mzc的博客
04-11 1229
✨知识回顾✨ 小伙伴还记得 head，node，val，prev 和 next，以及链表的一些基础操作嘛？如果忘记了，那就一起来回顾一下吧🌞 👉数据结构---链表 面试题6：从尾到头打印链表 题目： 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回） 示例： 输入：head = [2,5,7] 输出：[7，5，2] 链接：剑指 Offer 06 方法一：题目要求用数组返回，我们只需要创建一个链表节点数大小的数组，然后在数组中从后往前输入链表的结点打印即可。 .
3 剑指offer——链表
star_yang的博客
03-29 184
3 剑指offer——链表 1. 题目描述 输入一个链表，从尾到头打印链表每个节点的值。 2. 知识点总结 仔细阅读：Java进阶–深入理解ArrayList实现原理 ArrayList类是一个特殊的数组。它来自于System.Collections命名空间；通过添加和删除元素，就可以动态改变数组的长度。 2.1 初始化： 1）不指定初始化的容量： ArrayList ...
《剑指offer》从头到尾打印链表
gsch_12的博客
06-09 243
题目 题目描述 输入一个链表，从尾到头打印链表每个节点的值。 ps: 注意本题并不是考察LinkedList的知识。 Java 集合系列05之 LinkedList详细介绍(源码解析)和使用示例 https://www.cnblogs.com/skywang12345/p/3308807.html 解法1：递归 思路 把链表的值倒序存储在动态数组ArraryList，但链表本...
剑指offer(链表专题)
qq_36317312的博客
07-11 808
牛客101专题已经刷完，现在正在开启第二轮刷题，开始剑指offer专题
剑指Offer题集（力扣）
最新发布
qq_42958831的博客
05-07 1万+
力扣题单：https://leetcode.cn/problemset/all/?listId=lcof&page=1
剑指offer题目题解java版+c++版+Python版.zip
07-15
《剑指Offer》是一本备受推崇的编程面试指南，它汇集了众多知名互联网公司的面试题，旨在帮助求职者提升算法和编程能力。本压缩包包含了该书中的题目及其解法，分别以Java、C++和Python三种编程语言实现。下面我们将...
剑指offer前10题python代码
10-14
《剑指Offer》是面试准备中的经典书籍，主要涵盖了计算机科学与技术、数据结构和算法等方面的知识，旨在帮助求职者提升编程技能，特别是在面试时能够应对各种技术问题。本压缩包包含的是书中前10题的Python代码实现...
剑指Offer面试题Python实现
11-03
《剑指Offer面试题Python实现》是一份针对...总的来说，《剑指Offer面试题Python实现》提供了丰富的实践题目，通过学习和解决这些题目，可以全面提高Python程序员的面试准备水平，为成功入职心仪公司打下坚实基础。
python实现二叉树的创建
JulyLi2019的博客
03-22 5883
文章目录二叉树的基本概念二叉树的性质(特性)二叉树的节点表示以及二叉树的创建1.二叉树的节点表示2.二叉树的创建 二叉树的基本概念 二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree） 二叉树的性质(特性) 性质1: 在二叉树的第i层上至多有2^(i-1)个结点（i>0） 性质2: 深度为k的二叉树至多有2^k - 1个结点（k>0） 性质3: 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N
python实现队列
JulyLi2019的博客
03-16 2037
文章目录队列实现操作实现 队列实现 队列是一种先进先出的数据结构，本文用顺序表实现队列。 操作 Queue() 创建一个空的队列 enqueue(item) 往队列中添加一个item元素 dequeue() 从队列头部删除一个元素 is_empty() 判断一个队列是否为空 size() 返回队列的大小 实现 class Queue(object): """队列""" def __init__(self): self.items = [] def is_e
200. 岛屿数量（Python）
JulyLi2019的博客
11-02 1974
给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围。 示例 1： 输入：grid = [ [“1”,“1”,“1”,“1”,“0”], [“1”,“1”,“0”,“1”,“0”], [“1”,“1”,“0”,“0”,“0”], [“0”,“0”,“0”,“0”,“0”] ] 输出：1 示例 2： 输入：grid = [ [“1”,“1”,“0”,“0
560. 和为K的子数组（Python）
JulyLi2019的博客
05-15 1521
给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。 示例 1 : 输入:nums = [1,1,1], k = 2 输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。 方法一：暴力法，会超时。 class Solution: def subarraySum(self, nums: List[int], k: int) -> int: cnt, n = 0, len(nums) for i in range(n):
力扣剑指offer.pdf
10-09
在《力扣剑指Offer》这本书中，提供了几个有趣的编程题目来帮助读者提升算法技能和理解。以下是针对三个具体问题的详细解析： 1. **数组中重复的数字** 题目要求找出一个整数数组中重复出现的数字。`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AI小笔记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值