数据结构与算法--两个链表中第一个公共节点

生病的毛毛虫

已于 2022-02-21 11:12:49 修改

阅读量373

点赞数

分类专栏：数据结构算法文章标签：数据结构算法

于 2021-06-15 18:40:49 首次发布

本文链接：https://blog.csdn.net/liaojiamin0102/article/details/117929304

版权

数据结构同时被 2 个专栏收录

59 篇文章 3 订阅

订阅专栏

算法

59 篇文章 1 订阅

订阅专栏

链表中第一个公共节点

公节点定义：同一个节点在两个链表中，并不是节点值相同
题目：输入两个节点，找出他们的第一个公共节点，节点定义如需

/**
 * 链表元素节点
 *
 * @author liaojiamin
 * @Date:Created in 12:17 2021/3/5
 */
public class ListNode implements Comparable<ListNode> {
    private String key;
    private Integer value;
    private ListNode next;
    private ListNode before;
    ...

本文中所有有关链表定义以及操作都使用自己实现的链表相关方法，如需看详细实现可装到对应章节：数据结构与算法–链表实现以及应用
两个单向链表，特点在于只能同头开始遍历，因此最简单方案，还是双循环，每次遍历链表A的节点时候，与链表B中节点逐个比较，直到找到相同的节点问题
这种方法实现简单，但是时间复杂度是最大的，如果A有m个阶段，B有n个阶段那么时间复杂度是O(mn)，应该有更好的方案
方案二：
- 单向链表有共同节点，因为每个节点都是有一个next指针
- 因此从共同节点开始，之后的所有节点都是相同的，因此这个两个链表应该是个Y字形状，如下图
- 因为两个链表可能节点个数不同，因此从头开始遍历不能直接得到，
- 那么如果从后开始遍历，那边一定就是相同的节点
- 如果能将链表反转，从后向前遍历，最后一个相同的节点就是我们需要求解的值，如下图解

在这里插入图片描述

从后向前

在这里插入图片描述

如上图，第一个想到的方法是反转链表，因为单向链表只能从头开始，反转后可以从尾部开始遍历，反转后出现如下情况：

在这里插入图片描述

当修改第一个链表时候，第二个链表其实也被修改了，并且此时已经找不到地儿个链表的尾部节点，因此方法是不成了。
还有另外方法，我们将链表的每个节点存储到另外一个数组中，然后从数组尾部开始遍历
那么用栈来存储链表节点，此时是最适合的
遍历两个链表，分别存储两个栈，stack1， stack2,
接着遍历stack1， stack2，因为后进先出，因此先处理的必然是相等的，我们只需要找到第一个不相等的节点
如下实现，此处对栈的定义以及相关方法的实现都是用的自己对栈的实现方法，可到之前对应章节查看详细的实现：数据结构与算法–简单栈实现及其应用

/**
 * 寻找两个单向链表的第一个公共节点
 * 公共节点定义：同一个节点在两个链表中，并不是节点值相同
 *
 * @author liaojiamin
 * @Date:Created in 15:30 2021/6/15
 */
public class FindFirstCommonNode {

    public static void main(String[] args) {
        Random random = new Random();
        Integer number1 = random.nextInt(100);
        ListNode node1 = new ListNode(number1.toString(), number1);
        for (int i = 0; i < 3; i++) {
            Integer number = random.nextInt(100);
            ListNode newNode = new ListNode(number.toString(), number);
            MyLinkedList.addToTail(node1, newNode);
        }

        Integer number2 = random.nextInt(100);
        ListNode node2 = new ListNode(number2.toString(), number2);
        for (int i = 0; i < 6; i++) {
            Integer number = random.nextInt(100);
            ListNode newNode = new ListNode(number.toString(), number);
            MyLinkedList.addToTail(node2, newNode);
        }

        ListNode node3 = new ListNode("x", 3);
        MyLinkedList.addToTail(node1, node3);
        MyLinkedList.addToTail(node2, node3);
        for (int i = 0; i < 3; i++) {
            Integer number = random.nextInt(100);
            ListNode newNode = new ListNode(number.toString(), number);
            MyLinkedList.addToTail(node1, newNode);
        }
        MyLinkedList.print(node1);
        System.out.println();
        MyLinkedList.print(node2);
        ListNode commonNode = findFirstCommonNodeStack(node1, node2);
        System.out.println();
        System.out.println(commonNode.getKey());
    }

   
    /**
     * 方法一，栈方法，后进先出
     */
    public static ListNode findFirstCommonNodeStack(ListNode node1, ListNode node2) {
        if (node1 == null || node2 == null) {
            return null;
        }
        if (node1.getNext() == null && node2.getNext() == null) {
            return node1.equals(node2) ? node1 : null;
        }
        MyStack stack1 = new MyStack();
        ListNode head = node1;
        while (head != null) {
            stack1.push(head);
            head = head.getNext();
        }
        MyStack stack2 = new MyStack();
        head = node2;
        while (head != null) {
            stack2.push(head);
            head = head.getNext();
        }
        ListNode commonNode = null;
        while (!stack1.isEmpty() && !stack2.isEmpty()) {
            ListNode popStack1 = (ListNode) stack1.pop();
            ListNode popStack2 = (ListNode) stack2.pop();
            if (popStack1.equals(popStack2)) {
                commonNode = popStack1;
            }
        }
        return commonNode;
    }
}

利用栈额外存储了一份节点数据，来找到对应的相同节点，用空间换时间的方法，时间复杂度O(m+n)，空间复杂度O(m+n)
方法三
- 如果题目有更苛刻的要求，不能使用额外空间
- 在这种情况下，我先想到的是双指针法，我们在之前的文章：数据结构与算法–代码鲁棒性案例分析中详细介绍了双指针法获取链表中倒数第N个数
- 此处有两个链表自然想到双指针。
- 但是分析发现，此时两个链表可能元素个数不同，双指针同样也需要O(mn)的时间复杂度
- 还是受到：数据结构与算法–代码鲁棒性案例分析中双指针的启发，其中A指针先走了n步骤，B指针才开始遍历，当A指针到尾部，B指针就是倒数第n个数据
- 此处同样的思想，我们先查询A，B链表长度，如果A比B长N，那么让A指针先走N不，那么A，B指针则在统一起跑线。
- 此时同时遍历A，B并且比较对应节点，直到找到相同的第一个节点为止
- 经如上分析有如下代码：

/**
 * 寻找两个单向链表的第一个公共节点
 * 公共节点定义：同一个节点在两个链表中，并不是节点值相同
 *
 * @author liaojiamin
 * @Date:Created in 15:30 2021/6/15
 */
public class FindFirstCommonNode {

    public static void main(String[] args) {
        Random random = new Random();
        Integer number1 = random.nextInt(100);
        ListNode node1 = new ListNode(number1.toString(), number1);
        for (int i = 0; i < 3; i++) {
            Integer number = random.nextInt(100);
            ListNode newNode = new ListNode(number.toString(), number);
            MyLinkedList.addToTail(node1, newNode);
        }

        Integer number2 = random.nextInt(100);
        ListNode node2 = new ListNode(number2.toString(), number2);
        for (int i = 0; i < 6; i++) {
            Integer number = random.nextInt(100);
            ListNode newNode = new ListNode(number.toString(), number);
            MyLinkedList.addToTail(node2, newNode);
        }

        ListNode node3 = new ListNode("x", 3);
        MyLinkedList.addToTail(node1, node3);
        MyLinkedList.addToTail(node2, node3);
        for (int i = 0; i < 3; i++) {
            Integer number = random.nextInt(100);
            ListNode newNode = new ListNode(number.toString(), number);
            MyLinkedList.addToTail(node1, newNode);
        }
        MyLinkedList.print(node1);
        System.out.println();
        MyLinkedList.print(node2);
        System.out.println();
        ListNode commonNode2 = findFirstCommonNode(node1, node2);
        System.out.println(commonNode2.getKey());
    }

    /**
     * 方法二，错位遍历
     * */
    public static ListNode findFirstCommonNode(ListNode node1, ListNode node2){
        if (node1 == null || node2 == null) {
            return null;
        }
        if (node1.getNext() == null && node2.getNext() == null) {
            return node1.equals(node2) ? node1 : null;
        }
        Integer countNode1 = 0;
        ListNode header = node1;
        while (header != null){
            countNode1 ++;
            header = header.getNext();
        }
        Integer countNode2 = 0;
        header = node2;
        while (header != null){
            countNode2 ++;
            header = header.getNext();
        }
        Integer prefix = Math.abs(countNode1 - countNode2);
        ListNode header1 = node1;
        ListNode header2 = node2;
        if(countNode1 > countNode2){
            for (int i =0; i< prefix; i++){
                if(header1 != null){
                    header1 = header1.getNext();
                }

            }
        }else {
            for (int i =0; i< prefix; i++){
                if(header2 != null){
                    header2 = header2.getNext();
                }
            }
        }
        while (header1 != null && header2 != null){
            if(header1.equals(header2)){
                return header1;
            }
            header1 = header1.getNext();
            header2 = header2.getNext();
        }
        return null;
    }
}

方法三中没有用到额外的存储空间，时间复杂度同样也是O(m+n)，要优于方法二，这是目前想到的最优方案。

上一篇：数据结构与算法–数组中的逆序对
 下一篇：数据结构与算法–最小的k个数

生病的毛毛虫

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
4
评论
数据结构与算法--两个链表中第一个公共节点

链表中第一个公共节点公节点定义：同一个节点在两个链表中，并不是节点值相同题目：输入两个节点，找出他们的第一个公共节点，节点定义如需/** * 链表元素节点 * * @author liaojiamin * @Date:Created in 12:17 2021/3/5 */public class ListNode implements Comparable<ListNode> { private String key; private Integer va
复制链接

扫一扫

专栏目录