📜  用于查找两个链表的交点的Python程序

📅  最后修改于: 2022-05-13 01:54:29.958000             🧑  作者: Mango

用于查找两个链表的交点的Python程序

一个系统中有两个单链表。由于一些编程错误,其中一个链表的结束节点链接到了第二个链表,形成了一个倒 Y 形链表。编写一个程序来获取两个链表合并的点。

Y形链表

上图显示了一个示例,其中两个链表具有 15 个作为交点。

方法1(只需使用两个循环):
使用 2 个嵌套的 for 循环。外部循环将针对第一个列表的每个节点,内部循环将针对第二个列表。在内部循环中,检查第二个链表的任何节点是否与第一个链表的当前节点相同。此方法的时间复杂度为 O(M * N),其中 m 和 n 是两个列表中的节点数。

方法2(标记访问节点):
该解决方案需要修改基本的链表数据结构。每个节点都有一个已访问标志。遍历第一个链表并不断标记访问过的节点。现在遍历第二个链表,如果再次看到访问过的节点,则有一个交点,返回相交的节点。此解决方案在O(m+n)中有效,但需要每个节点的附加信息。不需要修改基本数据结构的该解决方案的变体可以使用散列来实现。遍历第一个链表并将访问节点的地址存储在哈希中。现在遍历第二个链表,如果您看到哈希中已经存在的地址,则返回相交节点。

方法3(使用节点数的差异):

  • 获取第一个列表中的节点数,设 count 为 c1。
  • 获取第二个列表中的节点数,设 count 为 c2。
  • 获得计数的差异d = abs(c1 – c2)
  • 现在遍历从第一个节点到 d 个节点的更大列表,以便从这里开始两个列表的节点数相等
  • 然后我们可以并行遍历这两个列表,直到遇到一个公共节点。 (注意,获取普通节点是通过比较节点的地址来完成的)

下图是上述方法的试运行:

以下是上述方法的实现:

Python3
# Python program to implement
# the above approach
# Defining a node for LinkedList
class Node:
  def __init__(self, data):
    self.data = data
    self.next = None 
  
def getIntersectionNode(head1, head2):
    
    # Finding the total number of elements 
    # in head1 LinkedList
    c1=getCount(head1)
    
    # Finding the total number of elements 
    # in head2 LinkedList
    c2=getCount(head2)
    
    # Traverse the bigger node by 'd' so that
    # from that node onwards, both LinkedList
    # would be having same number of nodes and 
    # we can traverse them together.
    if c1 > c2:
        d = c1 - c2
        return _getIntersectionNode(d, head1,
                                    head2)
    else:
        d = c2 - c1
        return _getIntersectionNode(d, head2,
                                    head1) 
    
  def _getIntersectionNode(d, head1, head2):     
    current1 = head1
    current2 = head2   
  
    for i in range(d):
        if current1 is None:
            return -1
        current1 = current1.next
      
    while current1 is not None and current2 is not None:
      
    # Instead of values, we need to check 
    # if there addresses are same because 
    # there can be a case where value is 
    # same but that value is not an 
    # intersecting point.
        if current1 is current2:
  
            # or current2.data (the value 
            # would be same)
            return current1.data 
      
        current1 = current1.next
        current2 = current2.next
    
    # Incase, we are not able to find 
    # our intersecting point.
    return -1
    
# Function to get the count of a LinkedList
def getCount(node):
    cur=node
    count=0
    while cur is not None:
        count+=1
        cur=cur.next
    return count
      
# Driver code
if __name__ == '__main__':
  
  # Creating two LinkedList
  # 1st one: 3->6->9->15->30
  # 2nd one: 10->15->30
  # We can see that 15 would be 
  # our intersection point
    
  # Defining the common node  
  common = Node(15)
    
  #Defining the first LinkedList  
  head1 = Node(3)
  head1.next = Node(6)
  head1.next.next = Node(9)
  head1.next.next.next = common
  head1.next.next.next.next = Node(30)
    
  # Defining the second LinkedList  
  head2 = Node(10)
  head2.next = common
  head2.next.next = Node(30)
    
  print("The node of intersection is ",
         getIntersectionNode(head1,head2))
# This code is contributed by Ansh Gupta.


输出:

The node of intersection is 15

时间复杂度: O(m+n)
辅助空间: O(1)

方法4(在第一个列表中画圈):
感谢Saravanan Man提供以下解决方案。
1.遍历第一个链表(计数元素),制作一个循环链表。 (记住最后一个节点,以便我们以后可以打破圆圈)。
2. 现在将问题视为在第二个链表中找到循环。所以问题就解决了。
3. 由于我们已经知道循环的长度(第一个链表的大小),我们可以遍历第二个链表中的许多节点,然后从第二个链表的开头开始另一个指针。我们必须遍历直到它们相等,这就是所需的交点。
4. 从链表中删除圆圈。

时间复杂度: O(m+n)
辅助空间: O(1)

方法5(反转第一个列表并制作方程式):
感谢Saravanan Mani提供这种方法。

1) Let X be the length of the first linked list until intersection point.
   Let Y be the length of the second linked list until the intersection point.
   Let Z be the length of the linked list from the intersection point to End of
   the linked list including the intersection node.
   We Have
           X + Z = C1;
           Y + Z = C2;
2) Reverse first linked list.
3) Traverse Second linked list. Let C3 be the length of second list - 1. 
     Now we have
        X + Y = C3
     We have 3 linear equations. By solving them, we get
       X = (C1 + C3 – C2)/2;
       Y = (C2 + C3 – C1)/2;
       Z = (C1 + C2 – C3)/2;
      WE GOT THE INTERSECTION POINT.
4)  Reverse first linked list.

优点:没有指针比较。
缺点:修改链表(倒排表)。
时间复杂度: O(m+n)
辅助空间: O(1)

方法6(遍历两个列表并比较最后一个节点的地址):该方法仅用于检测是否存在交叉点。 (感谢 NeoTheSaviour 的建议)

1) Traverse list 1, store the last node address
2) Traverse list 2, store the last node address.
3) If nodes stored in 1 and 2 are same then they are intersecting.

该方法的时间复杂度为O(m+n),使用的辅助空间为O(1)

有关详细信息,请参阅关于编写函数以获取两个链表的交点的完整文章!