剑指offer 关于链表的例题 —— 链表的环的入口结点、倒数第k个结点、两个链表的第一个公共结点、反转链表、合并两个排序的链表、删除排序链表中的重复元素

最新推荐文章于 2023-04-22 23:36:17 发布
最新推荐文章于 2023-04-22 23:36:17 发布
阅读量143 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表的环的入口结点、 倒数第k个结点、 两个链表的第一个公共结点、 反转链表、 合并两个排序的链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JMW1407/article/details/108117634
版权

链表热点题目

链表热点题目

1、链表的环的入口结点

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* EntryNodeOfLoop(ListNode* pHead)
    {
        if(pHead == NULL || pHead->next == NULL || pHead->next->next == NULL)
            return NULL;
        ListNode* SlowNode = pHead->next;
        ListNode* FastNode = pHead->next->next;
        while(SlowNode != FastNode)
        {
            if(FastNode->next == NULL || FastNode->next->next == NULL)
                return NULL;
            SlowNode = SlowNode->next;
            FastNode = FastNode->next->next;
        }
        FastNode = pHead;
        while(SlowNode != FastNode)
        {
            SlowNode = SlowNode->next;
            FastNode = FastNode->next;
        }
        return SlowNode;
    }
};

2、倒数第k个结点

输入一个链表，输出该链表中倒数第k个结点。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        if(pListHead == NULL || k < 1)
            return NULL;
        ListNode* fast = pListHead;
        while(--k)
        {
            fast = fast->next;
            if(fast == NULL)
                return NULL;
        }
        ListNode* slow = pListHead;
        while(fast->next != NULL)
        {
            fast = fast->next;
            slow = slow->next;
        }
        return slow;
    }
};

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

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        if(pHead1 == NULL || pHead2 == NULL)
            return NULL;
        int node = 0;
        ListNode* p1 = pHead1;
        while(p1->next != NULL)
        {
            node++;
            p1 = p1->next;
        }
        ListNode* p2 = pHead2;
        while(p2->next != NULL)
        {
            node--;
            p2 = p2->next;
        }
        if(p1 != p2)
            return NULL;
        p1 = node > 0 ? pHead1:pHead2;
        p2 = p1 == pHead1 ? pHead2 : pHead1;
        node = abs(node);
        while(node > 0)
        {
            node--;
            p1 = p1->next;
        }
        while(p1 != p2)
        {
            p1 = p1->next;
            p2 = p2->next;
        }
        return p1;
    }
};

4、反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
 
限制：
0 <= 节点个数 <= 5000

非递归方法:

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if(pHead == NULL)
            return NULL;
        ListNode* Pnow = pHead;
        ListNode* Ppre = NULL;
        while(Pnow->next!=NULL)
        {
            ListNode* Pnext = Pnow->next ;
            Pnow->next = Ppre;
            Ppre = Pnow;
            Pnow = Pnext;
        }
        Pnow->next = Ppre;
        return Pnow;
    }
};

递归方法:

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == NULL)
          return NULL;
        if(head->next == NULL)
           return head;
        ListNode* last = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return last;
    }
};

LeetCode92. 反转链表 II

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

示例:

输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

非递归

对于链表的问题，根据以往的经验一般都是要建一个dummy node，连上原链表的头结点，这样的话就算头结点变动了，我们还可以通过dummy->next来获得新链表的头结点。

这道题的要求是只通过一次遍历完成，就拿题目中的例子来说，变换的是2,3,4这三个点，我们需要找到第一个开始变换结点的前一个结点，只要让pre向后走m-1步即可。

为啥要减1呢，因为题目中是从1开始计数的，这里只走了1步，就是结点1，用pre指向它。万一是结点1开始变换的怎么办，这就是我们为啥要用dummy结点了，pre也可以指向dummy结点。然后就要开始交换了，由于一次只能交换两个结点，所以我们按如下的交换顺序：

1 -> 2 -> 3 -> 4 -> 5 -> NULL

1 -> 3 -> 2 -> 4 -> 5 -> NULL

1 -> 4 -> 3 -> 2 -> 5 -> NULL

我们可以看出来，总共需要n-m步即可，第一步是将结点3放到结点1的后面，第二步将结点4放到结点1的后面。

这是很有规律的操作，那么我们就说一个就行了，比如刚开始，

  • pre指向结点1，cur指向结点2，然后我们建立一个临时的结点t，指向结点3（注意我们用临时变量保存某个结点就是为了首先断开该结点和前面结点之间的联系，这可以当作一个规律记下来），
  • 然后我们断开结点2和结点3，将结点2的next连到结点4上，也就是 cur->next = t->next，再把结点3连到结点1的后面结点（即结点2）的前面，即 t->next = pre->next，
  • 最后再将原来的结点1和结点2的连接断开，将结点1连到结点3，即 pre->next = t。这样我们就完成了将结点3取出，加入结点1的后方。

第二步将结点4取出，加入结点1的后方，也是同样的操作，这里就不多说了，请大家自己尝试下吧，参考代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        ListNode* dummy=new ListNode(-1);
        ListNode* pre=dummy;
        dummy->next=head;
        
        for(int i=0;i<m-1;i++)
            pre=pre->next;
        ListNode* cur=pre->next;
        for(int i=m;i<n;i++){
            ListNode* t=cur->next;//t = 3
            cur->next=t->next;// 2->4
            t->next=pre->next;//3->2
            pre->next=t;//1->3 ===>>>> 1->3 ->2->4
        }
        return dummy->next;
    }
};

递归

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* successor = NULL;
    ListNode* reverseN(ListNode* head, int n) {
        if (n == 1) { 
            // 记录第 n + 1 个节点
            successor = head->next;
            return head;
        }
        // 以 head.next 为起点，需要反转前 n - 1 个节点
        ListNode* last = reverseN(head->next, n - 1);

        head->next->next = head;
        // 让反转之后的 head 节点和后面的节点连起来
        head->next = successor;
        return last;
    }  

    ListNode* reverseBetween(ListNode* head, int m, int n) {
        // base case
    if (m == 1) {
        return reverseN(head, n);
    }
    // 前进到反转的起点触发 base case
    head->next = reverseBetween(head->next, m - 1, n - 1);
    return head;

    }
};

5、合并两个排序的链表

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        if(pHead1 == NULL)
            return pHead2;
        if(pHead2 == NULL)
            return pHead1;
        ListNode* dummy = new ListNode(0);
        ListNode* newHead = dummy;
        while(pHead1 != NULL && pHead2 != NULL)
        {
            if(pHead1->val < pHead2->val)
            {
                newHead->next = pHead1;
                pHead1 = pHead1->next;
            }
            else
            {
                newHead->next = pHead2;
                pHead2 = pHead2->next;
            }
            newHead = newHead->next;
        }
        newHead->next = pHead1 == NULL ? pHead2:pHead1;
        ListNode* temp = dummy;
        dummy = dummy->next;
        delete temp;
        temp = NULL;
        return dummy;
    }
};

合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

 

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6


示例 2：

输入：lists = []
输出：[]


示例 3：

输入：lists = [[]]
输出：[]
 

提示：

k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4


/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
   struct cmp 
{
	bool operator()(ListNode *a, ListNode *b)
	{
		return a->val > b->val;
	}
};

ListNode* mergeKLists(vector<ListNode*>& lists)
{
		 if(lists.size() == 0)
            return NULL;
        priority_queue<ListNode*, vector<ListNode*>, cmp> pri_queue;
		for (auto elem : lists) 
		{
			if (elem) 
				pri_queue.push(elem);
		}
		ListNode* dummy = new ListNode(-1);
		ListNode* p = dummy;
		while (!pri_queue.empty()) 
		{
			ListNode* top = pri_queue.top(); pri_queue.pop();
			p->next = top; p = top;
			if (top->next) pri_queue.push(top->next);
		}
		return dummy->next;
}
};

6、删除排序链表中的重复元素

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1->1->2
输出: 1->2
示例 2:

输入: 1->1->2->3->3
输出: 1->2->3

双指针方法：
1、slowNode：牢牢锁死当前非重复元素的位置，它之前包括它自己都说非重复的元素；
2、fastNode：链表遍历节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        ListNode* slowNode = head;
        ListNode* fastNode = head->next;
        while(fastNode != NULL)
        {
            if(fastNode->val != slowNode->val)
            {
                slowNode = slowNode->next;
                slowNode->val = fastNode->val;
            }
            fastNode = fastNode->next;
        }
        slowNode->next = NULL;//链表最后的节点指向空。
        return head;
    }
};

强化版：

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
        val(x), next(NULL) {
    }
};
*/
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead)
    {
        if(pHead == NULL || pHead->next==NULL )
            return pHead;
        ListNode* dummy = new ListNode(-1);
        ListNode* pre = dummy;
        ListNode* cur = pHead;
        while(cur!= NULL &&cur->next !=  NULL)
        {
            if( cur->val == cur->next->val)
            {
                while(cur->next != NULL && cur->next->val == cur->val  )
                {
                    cur = cur->next;
                }
                pre->next = cur->next;
                cur = cur->next;
            }
            else
            {
                pre->next = cur;
                cur = cur->next;
                pre = pre->next;
            }
        }
        ListNode* temp = dummy;
        dummy = dummy->next;
        delete temp;
        temp = NULL;
        return dummy;
    }
};
JMW1407
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表反转问题 3：K 个一组反转
阿飞的博客
08-10 320
代码总体使用递归，前半部分判断剩余元素是否达到 k 个：若没达到，就直接返回结果，若达到，继续下面的运算。 而反转 k 个元素之后，……
面试经典算法-链表反转、链表合并等
业余码农Amazing10的博客
01-31 1872
01 认识『链表』 链表的结构十分简单，其本身是一种线性的存储结构，通过物理地址不连续的节点相连接成链。最简单的单链表只包含一条链，并且每一个节点包括两部分内容，数据元素和下一个节点的地址。因此可通过已知节点访问它的下一个节点。 相比于数组而言，由于链表不必须按顺序存储，因而在插入的时候可以达到O(1)的复杂度，一般而言比数组的效率要高得多；但是查找一个节点或者访问特定编号的节点则需要O(n)的...
学习笔记 | 合并K个升序链表
大虎牙的博客
09-09 401
合并K个升序链表 给你一个链表数组，每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中，返回合并后的链表。 示例 1： 输入：lists = [[1,4,5],[1,3,4],[2,6]] 输出：[1,1,2,3,4,4,5,6] 解释：链表数组如下： [ 1->4->5, 1->3->4, 2->6 ] 将它们合并到一个有序链表中得到。 1->1->2->3->4->4->5->6 示例 2： 输入：l
剑指offer例题——链表中倒数第K个结点
weixin_34270606的博客
04-01 86
题目描述 输入一个链表，输出该链表中倒数第k个结点。 编程过程 此处采用两个指针依次后移的方法来求解，首先，用一个指针移到第k个位置，之后将第二个指针放在第一位，与第二个指针一同移动，当第二个指针移动到最后的时候，第一个指针即处于倒数第k个结点。 考虑：链表为空、k为小于等于零的数，以及k的长度大于链表长度等情况。 1 /* 2 public class ListNod...
python数据结构剑指offer-链表中倒数最后k个结点
漫漫行程路
02-16 428
例题 描述 输入一个长度为 n 的链表，设链表中的元素的值为 ai ，返回该链表中倒数第k个节点。 如果该链表长度小于k，请返回一个长度为 0 的链表。 数据范围：0 \leq n \leq 10^50≤n≤10 5 ，0 \leq a_i \leq 10^90≤a i ​ ≤10 9 ，0 \leq k \leq 10^90≤k≤10 9 要求：空间复杂度 O(n)O(n)，时间复杂度 O(n)O(n) 进阶：空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n) 例如输入{1,2,3,4,5},2时
剑指Offer——链表
Tommenx的博客
08-20 554
链表 链表是一种动态的数据结构，当需要插入一个节点的时候，我们只需要为新创建的节点分配内存空间，将当前节点的next指向新创建的节点，并没有闲置的内存空间。 例题解答 本文中所有的链表的定义如下： struct ListNode{ int val; ListNode *next; ListNode(int v):val(v),next(nullptr){} ...
python实现链表（含剑指offer例题）
陈工一的博客
06-05 373
问题背景：面临秋招，需要刷《剑指offer》了 /惨 参考链接：https://www.cnblogs.com/kumata/p/9147077.html 一、链表简介 链表是通过一个个节点（Node）组成的，每个节点都包含了称为数据域(value)和指针域(next)的基本单元。示意图如下： 数据域/值域：用来存放用户数据； 指针域：用来存放指向下一个元素的指针。 head: 指向第一个...
[剑指offer]反转链表python实现
Chrispink
04-14 220
[牛客网]反转链表 输入一个链表，反转链表后，输出链表的所有元素。 Stupid Solution class Solution: # 返回ListNode def ReverseList(self, pHead): if not pHead or not pHead.next: return pHead e...
2021-12-2 剑指 Offer 22.26.链表倒数k， 树的子结构
kkzzjx
12-02 63
剑指 Offer 26. 树的子结构 输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构) B是A的子结构， 即 A中有出现和B相同的结构和节点值。 class Solution { public: bool isSubStructure(TreeNode* A, TreeNode* B) { if(A==NULL||B==NULL) return false; //进行一个先根遍历 return recu
链表
Top_xiao的博客
12-12 464
链表 数组和链表是在面试中经常问到的知识点。数组在内存中是连续存放的，所以支持随机访问，但是不支持在任意位置插入或删除元素。链表在内存中不是连续存放的，所以不支持随机访问，只能按顺序依次访问其中的元素，但是支持在任意位置插入或者删除元素。 链表可以想象成是若干个节点组成的，每个节点有自己的数据，还有指向下一个节点地址的指针。 单向链表 单向链表里面的每个节点包含自己的数据和指向下一个节点的指针。 链表的插入 如果在节点A 节点B 之间加入 节点D， 就直接把节点A 的指针指向节点D， 节点D 的指针指向
剑指offer第二版（leetcode）Java题解（不断更新）
tianyouououou的博客
09-15 1464
1 数组中的重复数字 题目 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 代码 class Solution { public int findRepeatNumber(int[] nums) { for(int i =0;i<nums.length;i++){ //如果当前数不是应该在的位置，就放过去，交换对应位
【每日算法】链表 & 例题选讲
jiange_zh的博客
02-24 2456
单链表 链表是常用的数据结构，其优点是插入和删除元素时不需要移动，表的容量可扩充，且存储空间可以不连续。 另外，由于涉及到指针，所以很受面试官的青睐。 本文将主要介绍单链表，并简单介绍下双链表和环形链表，并通过一系列的题目来强化这方面的知识。 链表节点的结构： templateclass DataType> struct Node { DataType data; N
leetcode刷题 链表相关 python
wordplay_的博客
03-08 218
leetcode python 链表
Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递
最新发布
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
04-22 1209
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数据结构知识和算法刷题及其平台、问题为导向的十大类刷题算法(数组和字符串、链表、栈和队列、二叉树、堆、图、哈希表、排序和搜索、回溯算法、枚举/递归/分治/动态规划/贪心算法)总结 目录 相关文章 数据结构的最强学习路线之问题为导向的十大类刷题算法总结 一、学习相关的讲解与刷题平台 二、刷题集合 三、常见的十大类考试题型 相关文章 DSt：数据结构的简介、最强学习路线(逻辑结构【数组
常见数据结构——完全二叉树（定义、特征、节点个数的判断以及C++简单实现）
热门推荐
JMW1407的博客
09-02 7万+
1、https://blog.csdn.net/troubleshooter/article/details/7706772?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159825431419195239741199%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=159825431419195239741199&biz_id
什么是状态机（Finite-state machine）？
JMW1407的博客
09-12 3万+
有限状态机有限状态机(FSM)1、 什么是“状态”2、什么是状态机？3、状态机图怎么画？参考 有限状态机(FSM) 1、 什么是“状态” 先来解释什么是“状态”（ State ）。现实事物是有不同状态的，例如一个自动门，就有 open 和 closed 两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed 。 状态机，也就是 State Machine ，不是指一台实际机器，而是指一个数学模型。说白了，一般就是指一张状态转换
C++ 打印菱形（实心和空心）
JMW1407的博客
09-19 1万+
打印菱形 打印菱形1、打印实心菱形2、打印空心菱形 打印菱形 1、打印实心菱形 #include<iostream> using namespace std; int main() { cout << "Please enter the side length of the diamond:"; int n; cin >> n; for (int i = 0; i<n; i++) // 分为上半层打印和下半层打印，首先打
C++实现生产者和消费者模型
JMW1407的博客
09-17 1万+
C++实现生产者和消费者模型 C++实现生产者和消费者模型1、实现细节1、单生产者-单消费者模型参考 C++实现生产者和消费者模型 1、实现细节 具体的实现逻辑是构建一个queue来存储生产的数据，queue不满时可以生产，不空时可以消费。 对于这个队列，采用阻塞队列的实现思路。 先实现构造函数，初始化一个unique_lock供condition_variable使用。 如何在类里面使用unique_lock等需要初始化，并且初始化会加锁的对象。这要研究下。我的理解是构造列表初始化，然后函数体里unl
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值