LeetCode 160. 相交链表（C、C++、python）_python实现leetcode160

编写一个程序，找到两个单链表相交的起始节点。

例如，下面的两个链表：

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

在节点 c1 开始相交。

注意：

如果两个链表没有交点，返回 null。

在返回结果后，两个链表仍须保持原有的结构。

可假定整个链表结构中没有循环。

程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。

C

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
    struct ListNode* p=headA;
    struct ListNode* q=headB;
    struct ListNode* h1=NULL;
    struct ListNode* h2=NULL;
    if(p==NULL || q==NULL)
    {
        return NULL;
    }
    else
    {
        int m=1,n=1;
        while(p->next)
        {
            m++;
            p=p->next;
        }
        while(q->next)
        {
            n++;
            q=q->next;
        }
        if(p!=q)
        {
            return NULL;
        }
        else
        {
            if(m>n)
            {
                h1=headA;
                h2=headB;
            }
            else
            {
                h1=headB;
                h2=headA;
            }
            m=abs(m-n);
            for(int i=0;i<m;i++)
            {
                h1=h1->next;
            }
            while(h1!=h2)
            {
                h1=h1->next;
                h2=h2->next;
            }
            return h1;
        }
    }    
}

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) 
    {
        ListNode* p=headA;
        ListNode* q=headB;
        stack<ListNode*> s1;
        stack<ListNode*> s2;
        if(p==NULL || q==NULL)
        {
            return NULL;
        }
        while(p)
        {
            s1.push(p);
            p=p->next;
        }
        while(q)
        {
            s2.push(q);
            q=q->next;
        }
        ListNode* res=NULL;
        while(!s1.empty() && !s2.empty() && s1.top()==s2.top())
        {           
            res=s1.top();
            s1.pop();
            s2.pop();
        }
        return res;        
    }
};

python

# 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
        """
        p=headA
        q=headB
        if p==None or q==None:
            return None
        else:
            m=1
            n=1
            while p.next:
                m += 1
                p=p.next
            while q.next:
                n += 1
                q=q.next
            if p!=q:
                return None
            else:
                m=m-n
                if m>0:
                    h1=headA
                    h2=headB
                else:
                    h1=headB
                    h2=headA
                m=abs(m)
                while m:
                    h1=h1.next
                    m -= 1
                while h1!=h2 and h1!=None and h2!=None:
                    h1=h1.next
                    h2=h2.next
                return h1