数据结构与算法之复制含有随机指针节点的链表和两个链表相交的一系列问题

最新推荐文章于 2020-07-29 19:03:40 发布
最新推荐文章于 2020-07-29 19:03:40 发布
阅读量174 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41910694/article/details/93913019
版权

数据结构与算法复制含有随机指针节点的链表和两个链表相交的一系列问题

目录

  1. 复制含有随机指针节点的链表
  2. 两个链表相交的一系列问题

1. 复制含有随机指针节点的链表

  1. 题目概述
    在这里插入图片描述

  2. 思路：创建一个HashMap结构，key放当前Node，value放需要复制的Node。

  3. 代码实现


import java.util.HashMap;

public class Code_CopyListWithRandom {

    public static class Node {
        public int value;
        public Node next;
        public Node rand;

        public Node(int data) {
            this.value = data;
        }
    }

    public static Node copyListWithRand1(Node head) {
        HashMap<Node, Node> map = new HashMap<Node, Node>();
        Node cur = head;
        while (cur != null) {
            map.put(cur, new Node(cur.value));
            cur = cur.next;
        }
        cur = head;
        while (cur != null) {
            map.get(cur).next = map.get(cur.next);
            map.get(cur).rand = map.get(cur.rand);
            cur = cur.next;
        }
        return map.get(head);
    }

    public static Node copyListWithRand2(Node head) {
        if (head == null) {
            return null;
        }
        Node cur = head;
        Node next = null;
        // copy node and link to every node
        while (cur != null) {
            next = cur.next;
            cur.next = new Node(cur.value);
            cur.next.next = next;
            cur = next;
        }
        cur = head;
        Node curCopy = null;
        // set copy node rand
        while (cur != null) {
            next = cur.next.next;
            curCopy = cur.next;
            curCopy.rand = cur.rand != null ? cur.rand.next : null;
            cur = next;
        }
        Node res = head.next;
        cur = head;
        // split
        while (cur != null) {
            next = cur.next.next;
            curCopy = cur.next;
            cur.next = next;
            curCopy.next = next != null ? next.next : null;
            cur = next;
        }
        return res;
    }

    public static void printRandLinkedList(Node head) {
        Node cur = head;
        System.out.print("order: ");
        while (cur != null) {
            System.out.print(cur.value + " ");
            cur = cur.next;
        }
        System.out.println();
        cur = head;
        System.out.print("rand:  ");
        while (cur != null) {
            System.out.print(cur.rand == null ? "- " : cur.rand.value + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Node head = null;
        Node res1 = null;
        Node res2 = null;
        printRandLinkedList(head);
        res1 = copyListWithRand1(head);
        printRandLinkedList(res1);
        res2 = copyListWithRand2(head);
        printRandLinkedList(res2);
        printRandLinkedList(head);
        System.out.println("=========================");

        head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);
        head.next.next.next.next = new Node(5);
        head.next.next.next.next.next = new Node(6);

        head.rand = head.next.next.next.next.next; // 1 -> 6
        head.next.rand = head.next.next.next.next.next; // 2 -> 6
        head.next.next.rand = head.next.next.next.next; // 3 -> 5
        head.next.next.next.rand = head.next.next; // 4 -> 3
        head.next.next.next.next.rand = null; // 5 -> null
        head.next.next.next.next.next.rand = head.next.next.next; // 6 -> 4

        printRandLinkedList(head);
        res1 = copyListWithRand1(head);
        printRandLinkedList(res1);
        res2 = copyListWithRand2(head);
        printRandLinkedList(res2);
        printRandLinkedList(head);
        System.out.println("=========================");

    }

}

2. 两个链表相交的一系列问题

1. 题目描述

在这里插入图片描述

2. 思路

  1. 得到入环节点：

    1. 如果节点个数为0,1，2，那么不能形成环，返回null。
    2. 设置两个节点node1，node2，node1为慢节点，一次走一步，node2为快节点，一次走两步
    3. 遍历链表，如果可以相交即为有环
    4. 将node2重新置为head节点，一次走一步，重新从头节点出发，遇到node1即为入环节点
    5. 可以自行测试

  2. 无环链表相交问题

    1. 如果head1或head2一方为null，则不会相交，返回null
    2. 创建cur1和cur2节点，n变量。其中，cur1指向head1节点，cur2指向head2节点，n记录两个链表的长度。
    3. 判断cur1和cur2是否相同，即最后一个节点如果不相同，则不会相交。
    4. 遍历head1，每走一步n++，遍历head2，每走一步n–。最后得到的n值即为两个链表的长度差。
    5. 复用cur1和cur2，当n>0时，说明head1比较长，将cur1指向head1，否则head2比较长，将cur1，指向head2。cur2指向短的链表head1或head2。将n取绝对值。
    6. cur1先走n步，跟cur2一样长时，两者一起走，当两者值一样时即为无环链表相交点。返回cur1即可。
      在这里插入图片描述

  3. 有环链表相交问题

    1. 创建两个变量cur1，cur2.

    2. 如果两个入环节点相同，则将head1赋给cur1，head2赋给cur2.创建一个变量n记录head1和head2的长度。

    3. 遍历head1，每走一步n++，遍历head2，每走一步n–。最后得到的n值即为两个链表的长度差。

    4. 复用cur1和cur2，当n>0时，说明head1比较长，将cur1指向head1，否则head2比较长，将cur1，指向head2。cur2指向短的链表head1或head2。将n取绝对值。

    5. cur1先走n步，跟cur2一样长时，两者一起走，当两者值一样时即为无环链表相交点。返回cur1即可。

    6. 如果两个入环节点不同，则可能相交也可能不相交。

    7. 使cur1 = loop1.next，遍历环结构，如果途中遇到loop2，即为相交，否则不相交。

在这里插入图片描述

3. 代码实现

public class Code_FindFirstIntersectNode {

    public static class Node {
        public int value;
        public Node next;

        public Node(int data) {
            this.value = data;
        }
    }

    public static Node getIntersectNode(Node head1, Node head2) {
        if (head1 == null || head2 == null) {
            return null;
        }
        Node loop1 = getLoopNode(head1);
        Node loop2 = getLoopNode(head2);
        if (loop1 == null && loop2 == null) {
            return noLoop(head1, head2);
        }
        if (loop1 != null && loop2 != null) {
            return bothLoop(head1, loop1, head2, loop2);
        }
        return null;
    }

    //得到入环节点
    public static Node getLoopNode(Node head) {
        if (head == null || head.next == null || head.next.next == null) {
            return null;
        }
        Node n1 = head.next; // n1 -> slow
        Node n2 = head.next.next; // n2 -> fast
        while (n1 != n2) {
            if (n2.next == null || n2.next.next == null) {
                return null;
            }
            n2 = n2.next.next;
            n1 = n1.next;
        }
        n2 = head; // n2 -> walk again from head
        while (n1 != n2) {
            n1 = n1.next;
            n2 = n2.next;
        }
        return n1;
    }

    //无环链表相交问题
    public static Node noLoop(Node head1, Node head2) {
        if (head1 == null || head2 == null) {
            return null;
        }
        Node cur1 = head1;
        Node cur2 = head2;
        int n = 0;
        while (cur1.next != null) {
            n++;
            cur1 = cur1.next;
        }
        while (cur2.next != null) {
            n--;
            cur2 = cur2.next;
        }
        if (cur1 != cur2) {
            return null;
        }
        cur1 = n > 0 ? head1 : head2;
        cur2 = cur1 == head1 ? head2 : head1;
        n = Math.abs(n);
        while (n != 0) {
            n--;
            cur1 = cur1.next;
        }
        while (cur1 != cur2) {
            cur1 = cur1.next;
            cur2 = cur2.next;
        }
        return cur1;
    }

//    两个有环链表相交问题
    public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
        Node cur1 = null;
        Node cur2 = null;
        if (loop1 == loop2) {
            cur1 = head1;
            cur2 = head2;
            int n = 0;
            while (cur1 != loop1) {
                n++;
                cur1 = cur1.next;
            }
            while (cur2 != loop2) {
                n--;
                cur2 = cur2.next;
            }
            cur1 = n > 0 ? head1 : head2;
            cur2 = cur1 == head1 ? head2 : head1;
            n = Math.abs(n);
            while (n != 0) {
                n--;
                cur1 = cur1.next;
            }
            while (cur1 != cur2) {
                cur1 = cur1.next;
                cur2 = cur2.next;
            }
            return cur1;
        } else {
            cur1 = loop1.next;
            while (cur1 != loop1) {
                if (cur1 == loop2) {
                    return loop1;
                }
                cur1 = cur1.next;
            }
            return null;
        }
    }

    public static void main(String[] args) {
        // 1->2->3->4->5->6->7->null
        Node head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);
        head1.next.next.next = new Node(4);
        head1.next.next.next.next = new Node(5);
        head1.next.next.next.next.next = new Node(6);
        head1.next.next.next.next.next.next = new Node(7);

        // 0->9->8->6->7->null
        Node head2 = new Node(0);
        head2.next = new Node(9);
        head2.next.next = new Node(8);
        head2.next.next.next = head1.next.next.next.next.next; // 8->6
        System.out.println(getIntersectNode(head1, head2).value);

        // 1->2->3->4->5->6->7->4...
        head1 = new Node(1);
        head1.next = new Node(2);
        head1.next.next = new Node(3);
        head1.next.next.next = new Node(4);
        head1.next.next.next.next = new Node(5);
        head1.next.next.next.next.next = new Node(6);
        head1.next.next.next.next.next.next = new Node(7);
        head1.next.next.next.next.next.next = head1.next.next.next; // 7->4

        // 0->9->8->2...
        head2 = new Node(0);
        head2.next = new Node(9);
        head2.next.next = new Node(8);
        head2.next.next.next = head1.next; // 8->2
        System.out.println(getIntersectNode(head1, head2).value);

        // 0->9->8->6->4->5->6..
        head2 = new Node(0);
        head2.next = new Node(9);
        head2.next.next = new Node(8);
        head2.next.next.next = head1.next.next.next.next.next; // 8->6
        System.out.println(getIntersectNode(head1, head2).value);

    }

}
Lumos`
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode—相交链表双指针解法
德发大陆
02-15 176
题目 查找两个单链表相交的起始节点 输入：相交节点的值、两个单链表listA和listB以及各自相交节点的索引值（每个单链表的第一个节点的索引值为0)； 输出：两个单链表相交节点的值，如果两个节点不相交则返回null； 注意事项： 如果两个链表没有交点，返回null； 在返回结果后，两个链表仍须保持原有的结构； 假定整个链表结构中没有循环； 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存； 解法思路： 　　使用一个节点指针node1通过对链表A的遍历，遍历完成后再将node1指针重新指向
leetcode160相交链表
lgy54321的博客
12-16 578
题目 编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8...
编写一个程序，找到两个单链表相交的起始节点
Brain的博客
03-23 1729
编写一个程序，找到两个单链表相交的起始节点。 定义两个结点：如果两个链表不一样长，就要消除长度差 定义两个结点 ：让结点向后走，当一个链表走完，让它这个结点指向另一个节点的头部；另一个走完，指向另一个结点的头部，这样就消除了长度差：第二次循环的时候就可以一起走到相交结点 快慢指针（） public class Solution { public ListNode getIntersec...
算法：求两个单链表相交的第一个节点
Yufail的博客
03-06 1271
判断两个单链表是否相交以及相交的情况下求第一个相交节点，两个链表可以有环，也可以无环。因此我们可以从以下几个步骤分析： 判断一个单链表是否存在环路，如果无环，返回null，反之，返回入环节点。 如果两个单链表均无环，进入相应的子程序，如果无相交，返回null，反之，返回第一个相交节点。 如果一个有环，一个无环，进入相应的子程序，如果无相交，返回null，反之，返回第一个相交节点。 如果两个单链表...
【面试题】-判断两个单链表是否相交并求出相交的第一结点
zengwh
05-15 5949
问题描述判断两个单链表是否相交,如果相交，给出相交的第一个点（假设两个链表都不存在环）。相交的链表示意图如下所示。 解题思路方法一两个没有环的链表如果是相交于某一结点，如上图所示，这个结点后面都是共有的。所以如果两个链表相交，那么两个链表的尾结点的地址也是一样的。程序实现时分别遍历两个单链表，直到尾结点。判断尾结点地址是否相等即可。时间复杂度为O(L1+L2)。方法二代码实现方法一void Is_
判断链表是否相交的几种算法1
08-03
该方法通过将h1链表的尾节点的next指针指向h2链表的头节点，如果两个链表相交，此时h2会形成一个循环链表。接下来只需判断h2是否为循环链表，可以使用Floyd判断环算法或龟兔赛跑算法。这种方法的时间复杂度同样是O...
算法大全-面试题-链表-栈-二叉树-数据结构.docx
最新发布
09-01
链表是一种线性数据结构，其中元素以节点的形式存储，每个节点包含数据和指向下一个节点的引用。在单链表中，每个节点只有一个指向后继节点的指针，而链表的末尾节点指向null。在C#中，可以使用类`Link`来表示链表...
数据结构课设的一道题，带环相交链表
07-25
在IT领域，数据结构是计算机科学的...在完成这个课设后，你将对链表有更深入的理解，并能熟练地处理环形链表和链表相交问题。这些知识对于学习更复杂的数据结构，如图、树，甚至是算法设计与分析都有着重要的铺垫作用。
[剑指-Offer] 52. 两个链表的第一个公共节点(思维、快慢指针、巧妙解法）
01-08
快慢指针的原理基于这样一个事实：如果两个链表在某个点相交，那么它们在相交点之后的路径是一样的。快指针会比慢指针更快地完成一个环，然后再次遇到慢指针。这种方法的代码更简洁，时间复杂度同样是O(n)，空间...
面试题快慢链表和快慢指针
08-30
快慢链表和快慢指针是一种常见的数据结构和算法设计模式，广泛应用于各种面试题中，例如腾讯的一道面试题：如何快速找到位置长度单链表的中间节点？本文将详细介绍快慢链表和快慢指针的原理、实现和应用。 快慢链表...
两个单链表相交，找出第一个交点
zzl429556205的专栏
01-04 1337
目录 题目 理解 解法 题目 给两个单链表，如何判断两个单链表是否相交？若相交，则找出第一个相交的节点 理解 解这道题之前，我们需要首先明确一个概念： 如果两个单链表有共同的节点，那么从第一个共同节点开始，后面的节点都会重叠，直到链表结束 因为两个链表中有一个共同节点，则这个节点里的指针域指向的下一个节点地址一样，所以下一个节点也会相交，依次类推。所以，若相交，则两个链表呈“Y”...
判断两个单链表是否相交及找到第一个交点
热门推荐
rotation博客
12-24 4万+
题目：给两个单链表，如何判断两个单链表是否相交？若相交，则找出第一个相交的节点。 这道题的思路和解法有很多，在这把这道题的解法做一个详细的总结。解这道题之前，我们需要首先明确一个概念： 如果两个单链表有共同的节点，那么从第一个共同节点开始，后面的节点都会重叠，直到链表结束。 因为两个链表中有一个共同节点，则这个节点里的指针域指向的下一个节点地址一样，所以下一个节点也会相交，依次类推。所以，若相
160. 相交链表 判断链表是否有交点 双指针
口袋里的星星的博客
07-29 162
编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 相交的链表从相交点开始后面的节点全部共用。 解题思路 双指针。我们通常做这种题的思路是设定两个指针分别指向两个链表头部，一起向前走直到其中一个到达末端，另一个与末端距离则是两链表的 长度差。再通过长链表指针先走的方式消除长度差，最终两链表即可同时走到相交点。 # Definition for singly-linked list. # class ListNode(object): # def __init__(self, x):
Intersection of Two Linked Lists找出两个链表相交的结点
Agiz的博客
03-16 150
Write a program to find the node at which the intersection of two singly linked lists begins. For example, the following two linked lists: ![在这里插入图片描述](https://img-blog.csdnimg.cn/2019031601000677.pn...
LeetCode160.相交链表（双指针解法）
DIDI___的博客
04-02 191
题目： 编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注...
双指针问题---链表---单链表
gy的博客
05-31 245
链表是用指针连接的用于存储数据的数组，它的最大的优点是可以有效的利用零碎的内存空间，在很多语言中数组需要提前定义，而且定义后不可以进行修改，存储同一类型的数据。在Python中没有指针，需要使用模拟指针， 链表可以修改长度，并且存储不同类型的元素 # 单链表： 链表的每个元素 要存储值 + 下一个指针的值 这样才能被连接 最后一个元素的的指针为空指针 # 单链表遍历： 从没有指针指向的...
链表——双指针的应用（相交链表）
chanfun的博客
01-12 576
文章目录场景描述C语言实现初步思路具体细节代码实现Java语言实现代码实现总结反思 场景描述 原题描述链接 编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Ref...
160相交链表（双指针法）
Revendell的博客
05-27 152
1、题目描述 编写一个程序，找到两个单链表相交的起始节点。 注意： 如果两个链表没有交点，返回 null. 在返回结果后，两个链表仍须保持原有的结构。 可假定整个链表结构中没有循环。 程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。 如下面的两个链表： 在节点 c1 开始相交。 2、示例 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Refer
数据结构与算法解析：链表、栈、队列与二叉树
"该资源是一本由艾孜尔江编写的《数据结构算法大全》，主要针对面试中的数据结构和算法问题进行讲解，涵盖单链表、栈和队列、二叉树等多个主题，旨在帮助读者理解和掌握数据结构与算法的基础知识，提升面试竞争力。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值