剑指offer 14、15、16 、25、36、55、56 链表

最新推荐文章于 2024-09-22 11:42:19 发布
最新推荐文章于 2024-09-22 11:42:19 发布
阅读量160 收藏
点赞数
分类专栏： 剑指offer 文章标签： 算法 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38147421/article/details/107529026
版权

14、链表中倒数第K个节点

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

方法二：严格的O(n)解法，快慢指针
如下图：
在这里插入图片描述

我们从图中可以看出，倒数第k个节点与最后的空节点之间有2个指针，此时的2正好就是k，于是我们可以想到可以通过平移来到达最后的状态。
如图：
在这里插入图片描述

如果懂了上面的过程，接下来再说说具体编程要怎么写？
图片说明

使用如图的快慢指针，首先让快指针先行k步，然后让快慢指针每次同行一步，直到快指针指向空节点，慢指针就是倒数第K个节点。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        if head is None:
            return None
        slow = head
        fast = head
        between = 0
        
        while between != k-1:
            fast = fast.next
            if fast is None:
                return None
            between += 1
        
        while fast.next != None:
            slow = slow.next
            fast = fast.next
        return slow

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        ListNode p,q;
        p=q=head;
        //记录k的值
        int a=k;
        //记录节点的个数
        int count=0;
        while (q!=null){
            q = q.next;
            count ++;
            //q指针先跑，并且记录节点数，当p指针跑了k-1个节点后，p指针开始跑，
            //当q指针跑到最后时，p所指指针就是倒数第k个节点
            if(k < 1){
                p = p.next;
            }
            k--;
        }
        //如果节点个数小于所求的倒数第k个节点，则返回空
        if (count<a)return null;
        return p;
    }
}

15、反转链表

输入一个链表，反转链表后，输出新链表的表头。

以3个节点为例：

用pre记录当前节点的前一个节点

用next记录当前节点的后一个节点

当前节点a不为空，进入循环，先记录a的下一个节点位置next = b;再让a的指针指向pre

移动pre和head的位置，正因为刚才记录了下一个节点的位置，所以该链表没有断，我们让head走向b的位置。

当前节点为b不为空，先记录下一个节点的位置，让b指向pre的位置即a的位置，同时移动pre和head

当前节点c不为空，记录下一个节点的位置，让c指向b，同时移动pre和head，此时head为空，跳出，返回pre。
在这里插入图片描述

反转链表

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
         // 判断链表为空或长度为1的情况
        if(head == null || head.next == null){
            return head;
        }
        ListNode pre = null; // 当前节点的前一个节点
        ListNode next = null; // 当前节点的下一个节点
        while( head != null){
            next = head.next; // 记录当前节点的下一个节点位置；
            head.next = pre; // 让当前节点指向前一个节点位置，完成反转
            pre = head; // pre 往右走
            head = next;// 当前节点往右继续走
        }
        return pre;
    }
}

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回ListNode
    def ReverseList(self, pHead):
        # write code here
        if not pHead:
            return None
        h_pre = None
        while(pHead):
            h_next = pHead.next
            pHead.next= h_pre
            h_pre = pHead
            pHead = h_next
        return h_pre

16、合并两个排序的列表

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

直接看图：

在这里插入图片描述

/**
 * 题目描述
 * 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
 *
 * @author shijiacheng
 * @date 2018/2/23
 */
public class MergeSortedListsSolution {
    /**
     * 链表1的头结点的值小于链表2的头结点的值，因此链表1的头结点是合并后链表的头结点。
     * 在剩余的结点中，链表2的头结点的值小于链表1的头结点的值，因此链表2的头结点是剩
     * 余结点的头结点，把这个结点和之前已经合并好的链表的尾结点链接起来。
     */
    public ListNode Merge(ListNode list1, ListNode list2) {
        if (list1 == null) {
            return list2;
        } else if (list2 == null) {
            return list1;
        }
        ListNode mergeNode = null;
        if (list1.val < list2.val) {
            mergeNode = list1;
            mergeNode.next = Merge(list1.next, list2);
        } else {
            mergeNode = list2;
            mergeNode.next = Merge(list1, list2.next);
        }
 
        return mergeNode;
    }
}

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    # 返回合并后列表
    def Merge(self, pHead1, pHead2):
        # write code here
        if not pHead1:
            return pHead2
        elif not pHead2:
            return pHead1
#         p = ListNode(0)
        if pHead1.val <= pHead2.val:
            pHead1.next = self.Merge(pHead1.next,pHead2)
            return pHead1
        else:
            pHead2.next = self.Merge(pHead1,pHead2.next)
            return pHead2

25、复杂链表的复制

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

首先理解下什么是深拷贝和浅拷贝在这里插入图片描述

public class Solution {
    public RandomListNode Clone(RandomListNode pHead) {
        if(pHead == null) {
            return null;
        }

        RandomListNode currentNode = pHead;
        //1、复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
        while(currentNode != null){
            RandomListNode cloneNode = new RandomListNode(currentNode.label);
            RandomListNode nextNode = currentNode.next;
            currentNode.next = cloneNode;
            cloneNode.next = nextNode;
            currentNode = nextNode;
        }

        currentNode = pHead;
        //2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
        while(currentNode != null) {
            currentNode.next.random = currentNode.random==null?null:currentNode.random.next;
            currentNode = currentNode.next.next;
        }

        //3、拆分链表，将链表拆分为原链表和复制后的链表
        currentNode = pHead;
        RandomListNode pCloneHead = pHead.next;
        while(currentNode != null) {
            RandomListNode cloneNode = currentNode.next;
            currentNode.next = cloneNode.next;
            cloneNode.next = cloneNode.next==null?null:cloneNode.next.next;
            currentNode = currentNode.next;
        }

        return pCloneHead;
    }
}

36、两个链表的第一个公共节点（记忆）

输入两个链表，找出它们的第一个公共结点。

首先理解什么是公共节点：
在这里插入图片描述
看下面的链表例子：

双指针法。创建两个指针p1和p2,分别指向两个链表的头结点，然后依次往后遍历。如果某个指针到达末尾，则将该指针指向另一个链表的头结点；如果两个指针所指的节点相同，则循环结束，返回当前指针指向的节点。比如两个链表分别为：1->3->4->5->6和2->7->8->9->5->6。短链表的指针p1会先到达尾部，然后重新指向长链表头部，当长链表的指针p2到达尾部时，重新指向短链表头部，此时p1在长链表中已经多走了k步(k为两个链表的长度差值)，p1和p2位于同一起跑线，往后遍历找到相同节点即可。其实该方法主要就是用链表循环的方式替代了长链表指针先走k步这一步骤。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if (pHead1==null || pHead2 == null) return null;
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
        while(p1!=p2){
            p1=p1.next;
            p2=p2.next;
            if(p1!=p2){
                if(p1==null)p1=pHead2;
                if(p2==null)p2=pHead1;
            }
        }
        return p1;
    }
}

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        if  headA == None or headB == None:
            return None
        pA=headA
        pB=headB
        while(pA!=pB):
            pA = pA.next
            pB = pB.next
            if(pA!=pB):
                if(pA is None):
                    pA = headB
                if(pB is None):
                    pB = headA
        return pA

55、链表中环的入口结点

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

思路：
设置快慢指针，都从链表头出发，快指针每次走两步，慢指针一次走一步，假如有环，一定相遇于环中某点(结论1)。接着让两个指针分别从相遇点和链表头出发，两者都改为每次走一步，最终相遇于环入口(结论2)。以下是两个结论证明：
两个结论：
1、设置快慢指针，假如有环，他们最后一定相遇。
2、两个指针分别从链表头和相遇点继续出发，每次走一步，最后一定相遇与环入口。
证明结论1：设置快慢指针fast和low，fast每次走两步，low每次走一步。假如有环，两者一定会相遇（因为low一旦进环，可看作fast在后面追赶low的过程，每次两者都接近一步，最后一定能追上）。
证明结论2：
设：
链表头到环入口长度为–a
环入口到相遇点长度为–b
相遇点到环入口长度为–c
环入口：q
快指针和慢指针相遇点：p
在这里插入图片描述

则：相遇时
快指针路程=a+(b+c)k+b ，k>=1 其中b+c为环的长度，k为绕环的圈数（k>=1,即最少一圈，不能是0圈，不然和慢指针走的一样长，矛盾）。
慢指针路程=a+b
快指针走的路程是慢指针的两倍，所以：
（a+b）*2=a+(b+c)k+b
化简可得：
a=(k-1)(b+c)+c 这个式子的意思是： 链表头到环入口的距离=相遇点到环入口的距离+（k-1）圈环长度。其中k>=1,所以k-1>=0圈。所以两个指针分别从链表头和相遇点出发，最后一定相遇于环入口。

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        ListNode fast = pHead;
        ListNode slow = pHead;
                //判断是否有环，没有环，输出null。
        if(fast==null||fast.next==null){
            return null;
        }
        while(fast!=null||fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow){
                break;
            }
        }
        slow = pHead;
        while(fast!=slow){
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, pHead):
        # write code here
        slow = pHead
        fast = pHead
#       判断有无环
        if slow == None or fast.next == None:
            return None
#         判断有无环，如果有，则break，往下求出入口节点
        while fast!=None and fast.next!=None:
            fast = fast.next.next
            slow = slow.next
            if(fast == slow):
                break
 #下面这两种写法都是可以的
 #       slow = pHead
 #      while fast!=slow:
 #           fast = fast.next
 #          slow = slow.next
 #       return slow
        fast = pHead  # 如果能够执行到此步，说明必定是有环的了
        
        while slow != fast:
            slow = slow.next
            fast = fast.next
            
        return slow

56、删除链表中重复的节点（记忆）

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

yanglee0
关注
专栏目录
《剑指offer》Java版全系列题解（2021版，持续更新！）
m0_55070913的博客
06-18 1659
本系列记录了最新版 《剑指Offer》 的题解过程与代码，因为原书是c语言。这里用Java代码复现并优化，并包含解题分析。希望各位能够点赞，收藏！关注我！ 每日更新！ 2021.4.24 完结如果在准备java面试，可以看看我的另外一篇文章！ Java面试复习体系总结（2021版,持续更新）csdn题解（包含详细分析过程，代码）力扣链接剑指Offer系列（java版，详细解析） 03. 数组中重复的数字剑指 Offer 03. 数组中重复的数字剑指Offer系列（java版，详细解析）04.二维数组中的查找
【LeetCode】剑指Offer
Arthur的博客
06-19 651
LeetCode剑指Offer
剑指Offer--链表中环的入口节点(JS)
橘导的博客
11-10 152
题目描述 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 思路 ：遍历链表，环的存在，遍历遇见第一个重复的即为入口节点 function EntryNodeOfLoop(pHead){ let temp=[]; while(pHead){ if(!temp.includes(pHead)){ temp.pu...
链表中环的入口结点
growthmindset的博客
05-22 182
题目描述 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 思路： 设置快慢指针，都从链表头出发，快指针每次走两步，慢指针一次走一步，假如有环，一定相遇于环中某点(结论1)。接着让两个指针分别从相遇点和链表头出发，两者都改为每次走一步，最终相遇于环入口(结论2)。以下是两个结论证明： 两个结论： 1、设置快慢指针，假如有环，他们最后一定相遇。 2、两个指针分别从链表头和相遇点继续出发，每次走一步，最后一定相遇与环入口。 证明结论1：设置快慢指针fast和low，fast每次走两步，
38.链表中环的入口结点
坤健的博客
05-30 448
public class Solution { ListNode EntryNodeOfLoop(ListNode pHead){ if(pHead == null || pHead.next == null) return null; ListNode p1 = pHead; ListNode p2 = pHea
剑指offer-js 链表中环的入口节点
baobaohui
08-04 320
链表中环的入口节点 相似推荐 判断链表中有无环 判断是否有环并返回入口节点(java) 题目描述： 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 问题分析： 两种方法： 1，哈希表法 创建一个数组，遍历所有链表元素，判断是否在数组内，若不在，则加入；若在，就将第一个在的节点返回 2，快慢指针，floyd算法 借用两张官方解法放出的图片 第一张图告诉我们，对于快慢指针，当slow和fast相遇时，相遇点在C, 同时推导出 =>2(AB+BC) = A
链表中环的入口——js
qq_40608516的博客
06-05 262
链表中环的入口 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。 思路 还是用双指针解决。找到两个指针相遇的位置。相遇的位置到入口节点的距离就是头结点到入口节点距离。 第一种是断链了的，如果题目要求不能破坏链表就不能用了。 可用第二种： 假设x为环前面的路程（黑色路程），a为环入口到相遇点的路程（蓝色路程，假设顺时针走）， c为环的长度（蓝色+橙色路程） 当快慢指针相遇...
《剑指Offer》题目及代码.zip
06-28
《剑指Offer》 1. 赋值运算函数 2. 单例设计模式 3. 二维数组中查找目标值 4. 替换字符串中的空格 5. 从尾到头打印链表 6. 由前序和中序遍历重建二叉树 7. 用两个栈实现队列 8. 求旋转数组的最小数字 9. ...
《剑指Offer》题目及代码.pdf
05-31
《剑指Offer》是一本广受欢迎的算法面试书籍，主要针对中国的IT面试市场。该书中包含了大量面试题以及针对这些题目的解题思路和代码实现。本书涵盖的知识点广泛，难度从基础到进阶不等，非常适合准备面试和提高编程...
LeetCode-剑指 Offer 题目集
HeavenDan的博客
12-21 726
题目集汇总 题号 题目链接 知识点 博客题解链接 完成时间 备注 题号 题目 题解链接 标签 备注 遍数 03 数组中重复的数字 【LeetCode-剑指Offer】03. 数组中重复的数字 数组、哈希表 04 二维数组中的查找 数组、双指针 05 替换空格 06 从尾到头打印链表 链表 07 重建二叉树 树、递归 09 用两个栈实现队列 栈、设计 10- I 斐波那契数列 递归 10- II 青蛙跳台阶问题 递归
剑指Offer--056-链表中环的入口结点
OSKernelLAB(gatieme)
06-07 4144
链接 牛客OJ：链表中环的入口结点 九度OJ：未收录 GitHub代码： 056-链表中环的入口结点 CSDN题解：剑指Offer–056-链表中环的入口结点 牛客OJ 九度OJ CSDN题解 GitHub代码 056-链表中环的入口结点 未收录 剑指Offer–056-链表中环的入口结点 056-链表中环的入口结点 题目描述 一个链
AcWing 34. 链表中环的入口结点
yj_coder的博客
05-10 766
题目描述 给定一个链表，若其中包含环，则输出环的入口节点。 若其中不包含环，则输出null。 样例 给定如上所示的链表： [1, 2, 3, 4, 5, 6] 2 注意，这里的2表示编号是2的节点，节点编号从0开始。所以编号是2的节点就是val等于3的节点。 则输出环的入口节点3. 问题分析 先等慢指针和快指针相遇，然后快指针原地不动，将慢指针置为head，然后两个指针以相同...
链表中环的入口结点(两种方法)
God_Mood的博客
01-28 775
1 . 断链法 public class Solution { public ListNode EntryNodeOfLoop(ListNode pHead) { if(pHead==null||pHead.next==null) return null; ListNode pre=pHead; List...
《剑指offer》【链表中环的入口结点】（python版）
SevenEleven的博客
07-05 2106
题目描述：一个链表中包含环，请找出该链表的环的入口结点。 思路： /* public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } */ public class Solution { public Li...
链表中环的入口结点（快指针慢指针相遇）
wangdongli_1993的博客
08-28 334
题目描述 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。   （1）快的指针一下走两个节点，慢的指针一下有一个节点，当两个指针相遇时，说明肯定有环 （2）相遇时，快的一共走过的节点是2x，慢的一共走过的节点是x；而两个指针都是从起点开始出发，到环入口点走过的节点是一样的，所以2x-x就是环节点的整数倍，刚好就x，刚好就是慢的节点所走的节点数目，也就是慢的节点从头...
【剑指Offer】链表中环的入口结点 解题报告（Python）
负雪明烛
03-27 1465
【剑指Offer】链表中环的入口结点 解题报告（Python） 标签（空格分隔）： 剑指Offer 题目地址：https://www.nowcoder.com/ta/coding-interviews 题目描述： 一个链表中包含环，请找出该链表的环的入口结点。 解题方法 就是leetcode的142. Linked List Cycle II题目，使用快慢指针，如果相遇了，那么把一...
atcoder abc372 启发式合并， dp
最新发布
2201_75845839的博客
09-22 470
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
O(1)时间删除链表节点：剑指Offer算法详解
在《剑指Offer》这本书中，包含了丰富的IT算法题和数据结构问题，主要针对Java程序员，旨在帮助求职者提升面试中的各项能力。以下是一些关键知识点的详细讲解： 1. **O(1)时间删除链表节点**：此部分讨论的是在链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值