LeetCode 160 — Intersection of Two Linked Lists（C++ Python）

最新推荐文章于 2023-11-15 20:24:25 发布

lilongmark

最新推荐文章于 2023-11-15 20:24:25 发布

阅读量2.9k

点赞数 1

分类专栏： LeetCode 文章标签： C++

本文链接：https://blog.csdn.net/lilong_dream/article/details/41683563

版权

LeetCode 专栏收录该内容

50 篇文章 0 订阅

订阅专栏

题目： https://oj.leetcode.com/problems/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；先遍历链表得到A、B的长度，如果最后一个节点不同，返回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) {
        if(headA == NULL || headB == NULL)
        {
            return NULL;
        }
        
        int lenA = 1;
        ListNode *hA = headA;
        while(hA->next != NULL)
        {
            ++lenA;
            hA = hA->next;
        }
        
        int lenB = 1;
        ListNode *hB = headB;
        while(hB->next != NULL)
        {
            ++lenB;
            hB = hB->next;
        }
        
        if(hA != hB)
        {
            return NULL;
        }
        
        hA = headA;
        hB = headB;
        if(lenA > lenB)
        {
            for(int i = 0; i < lenA - lenB; ++i)
            {
                hA = hA->next;
            }
        }
        else
        {
            for(int i = 0; i < lenB - lenA; ++i)
            {
                hB = hB->next;
            }
        }
        while(hA != hB)
        {
            hA = hA->next;
            hB = hB->next;
        }
        return hA;
    }
};

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):
        if headA == None or headB == None:
            return None
        
        lenA = 1
        hA = headA
        while hA.next != None:
            lenA += 1
            hA = hA.next
            
        lenB = 1
        hB = headB
        while hB.next != None:
            lenB += 1
            hB = hB.next
        
        if hA != hB:
            return None
        
        hA = headA
        hB = headB
        if lenA > lenB:
            for i in range(lenA - lenB):
                hA = hA.next
        else:
            for i in range(lenB - lenA):
                hB = hB.next
        
        while hA != hB:
            hA = hA.next
            hB = hB.next
        
        return hA