leetcode-160-Intersection of Two Linked Lists

最新推荐文章于 2022-08-06 10:20:24 发布

别哔哔好伐

最新推荐文章于 2022-08-06 10:20:24 发布

阅读量587

点赞数

CC 4.0 BY-SA版权

分类专栏：链表 LeetCode Python 文章标签： leetcode 链表

本文链接：https://blog.youkuaiyun.com/u014705854/article/details/47053169

LeetCode 同时被 3 个专栏收录

64 篇文章

订阅专栏

链表

9 篇文章

订阅专栏

Python

4 篇文章

订阅专栏

本博客介绍了一种高效算法，用于在O(n)时间内确定两个单链表是否相交及其相交节点，同时保持原始链表结构不变。

Intersection of Two Linked Lists

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

A:          a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗            
B:     b1 → b2 → b3

begin to intersect at node c1.

Notes:

If the two linked lists have no intersection at all, return null.
The linked lists must retain their original structure after the function returns.
You may assume there are no cycles anywhere in the entire linked structure.
Your code should preferably run in O(n) time and use only O(1) memory.

求两个链表的相交处的节点。不想交则返回NULL。

若两链表相交，则它们的后半部分一定相同。将两链表的后半部分对齐，即先将长的链表往后走，直到与短的链表长度一样，开始遍历两链表，找到的第一个相同的节点就是相交处的节点。

C++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int nA = 0,nB = 0,n;// 链表长度
        ListNode* p;
        
        p = headA; //headA的长度nA
        while (p) {
            nA++;
            p = p->next;
        }
        p = headB; //headB的长度nB
        while (p) {
            nB++;
            p = p->next;
        }
    
        if (nA < nB) {
            n = nB - nA;
            while (n--) headB = headB->next;
        } 
        else if (nA > nB) {
            n = nA - nB;
            while (n--) headA = headA->next;
        }
        
        while (headA && headB) {
            if (headA == headB) return headA;
            headA = headA->next;
            headB = headB->next;
        }
        return NULL;
    }
};

python

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

class Solution:
    # @param two ListNodes
    # @return the intersected ListNode
    def getIntersectionNode(self, headA, headB):
        nA = nB = 0
        p = headA
        while (p is not None) :
            nA = nA + 1
            p = p.next
        p = headB
        while (p is not None) :
            nB = nB + 1
            p = p.next
        
        if (nA < nB) :
            n = nB - nA
            while (n) :
                headB = headB.next
                n = n - 1
        elif (nA > nB) :
            n = nA - nB
            while (n) :
                headA = headA.next
                n = n - 1
        
        while (headA  and headB ) :
            if (headA == headB):
                return headA
            headA = headA.next
            headB = headB.next
        
        return None