Python与数据结构[0] -> 链表/LinkedList[2] -> 链表有环与链表相交判断的 Python 实现

链表有环与链表相交判断的 Python 实现

---

目录

1. 有环链表
2. 相交链表

 

1 有环链表

判断链表是否有环可以参考链接，

有环链表主要包括以下几个问题（C语言描述）：

1. 判断环是否存在： 可以使用追赶方法，定义两个指针slow和fast，分别以1步和2步前进，若存在环则两者会相遇，否则fast遇到NULL时则退出；
2. 获取环的长度：若存在环，则以相遇点为起点，fast和slow再次开始前进，第二次碰相遇slow走过的步数（1圈）即为环长度；
3. 找出入环点：相遇点到连接点的距离 = 头指针到连接点的距离，因此，让头指针和slow同时开始前进，相遇的点即为连接点；
4. 带环链表长度：问题3的连接点与头指针长度 + 问题2的环长度即为总长。

下面为关于有环链表几个问题的具体实现代码，

完整代码

from linked_list import LinkedList


def check_loop(chain):
    has_loop, entry_node, loop_length, chain_length = False, None, 0, 0

    # Get header for fast and slow
    step = 0
    fast = slow = head = chain.header
    while fast and fast.next:
        fast = fast.next.next
        slow = slow.next
        step += 1
        # Note:
        # Do remember to use ,is' rather than '==' here (assure the id is same).
        if fast is slow:    
            break
    has_loop = not(fast is None or fast.next is None)
    pass_length = (step * 2) if fast is None else (step * 2 + 1)

    if has_loop:
        step = 0
        while True:
            if head is slow:
                entry_node = slow
                pass_length = step
            if not entry_node:
                head = head.next
            fast = fast.next.next
            slow = slow.next
            step += 1
            if fast is slow:
                break
        loop_length = step

    chain_length = pass_length + loop_length
    return has_loop, entry_node, loop_length, chain_length


if __name__ == '__main__':
    print('------------ Loop check ------------------')
    print('''
    0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
    ''')
    loop_chain = LinkedList(range(10))
    print('Linked list has loop: %s, entry node: %s, loop length: %s, chain length: %s' % check_loop(loop_chain))

    # Create a loop for linked list.
    print('''
                    _____________________________
                   |                             |
                   V                             |
    0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
    ''')
    node_9 = loop_chain.find(9)
    node_3 = loop_chain.find(3)
    node_9.next = node_3
    print('Linked list has loop: %s, entry node: %s, loop length: %s, chain length: %s' % check_loop(loop_chain))

分段解释

首先导入单链表类，

from linked_list import LinkedList

然后定义一个函数，用于检测链表是否有环，并最终返回4个信息，1. 是否有环，2. 入环点，3. 环长度，4. 链表长度，

具体过程为，

1. 分别获取fast、slow和head结点，均以头结点为起始
2. 开始循环，slow和fast分别以1步和2步前进，并记录slow所走步数
3. 每一步都判断fast和slow是否相遇，此处需要用is而不能用==，这样才能判断是否是相同对象（指针引用）
4. 当fast遇到None或两结点相遇时，退出循环，并记录下是否有环和经过的步数
5. 判断是否有环，若无环则链表长度即经过长度的2倍或2倍加1，环长为0
6. 若有环，则同时驱动fast（2步）、slow（1步）和head（1步）前进
7. 当slow和head相遇的点即为入环点，停止head，slow继续前进
8. 在slow和fast再次相遇的点，记录走过的长度，即为环长
9. 更新pass_length及链表长度信息，并返回结果

def check_loop(chain):
    has_loop, entry_node, loop_length, chain_length = False, None, 0, 0

    # Get header for fast and slow
    step = 0
    fast = slow = head = chain.header
    while fast and fast.next:
        fast = fast.next.next
        slow = slow.next
        step += 1
        # Note:
        # Do remember to use 'is' rather than '==' here (assure the id is same).
        if fast is slow:    
            break
    has_loop = not(fast is None or fast.next is None)
    pass_length = (step * 2) if fast is None else (step * 2 + 1)

    if has_loop:
        step = 0
        while True:
            if head is slow:
                entry_node = slow
                pass_length = step
            if not entry_node:
                head = head.next
            fast = fast.next.next
            slow = slow.next
            step += 1
            if fast is slow:
                break
        loop_length = step

    chain_length = pass_length + loop_length
    return has_loop, entry_node, loop_length, chain_length

完成函数定义后，首先生成一个基本链表，检测是否有环，

if __name__ == '__main__':
    print('------------ Loop check ------------------')
    print('''
    0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
    ''')
    loop_chain = LinkedList(range(10))
    print('Linked list has loop: %s, entry node: %s, loop length: %s, chain length: %s' % check_loop(loop_chain))

得到结果

------------ Loop check ------------------

    0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
    
Linked list has loop: False, entry node: None, loop length: 0, chain length: 10

再将链表的3和9结点相接，形成一个新的有环链表，然后利用函数进行判断。

    # Create a loop for linked list.
    print('''
                    _____________________________
                   |                             |
                   V                             |
    0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
    ''')
    node_9 = loop_chain.find(9)
    node_3 = loop_chain.find(3)
    node_9.next = node_3
    print('Linked list has loop: %s, entry node: %s, loop length: %s, chain length: %s' % check_loop(loop_chain))

得到结果

                    _____________________________
                   |                             |
                   V                             |
    0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
    
Linked list has loop: True, entry node: 3, loop length: 7, chain length: 10

 

2 相交链表

 

判断链表是否相交及交点的方法主要有两种，

1. 遍历两个链表，得到最后的结点，若两个结点指向同一个结点（指针相等），则说明两个链表相交，此时记录下链表长度long_length和short_length，以较长的链表为起始点，先前进 (long_length - short_length) 步，再驱动两个结点同时前进，相遇点即为交点。
2. 将其中一个链表首尾相接，形成一个环，再判断另一个链表是否有环；若有环则入环点即为交点；

利用代码分别实现上面的两种判断方法，

完整代码

from linked_list import LinkedList
from linked_list_loop_check import check_loop


def check_intersect_one(c_1, c_2):
    def _traversal(c):
        node = c.header
        while node and node.next:
            yield node
            node = node.next
        yield node

    is_intersect, intersect_node = False, None
    # Get tail node and length
    step_1 = step_2 = 0
    for node_1 in _traversal(c_1):
        step_1 += 1
    for node_2 in _traversal(c_2):
        step_2 += 1
    tail_1, length_1 = node_1, step_1
    tail_2, length_2 = node_2, step_2

    if tail_1 is tail_2:
        # Intersected, fetch the first same node encountered as intersect node.
        is_intersect = True
        offset = length_1 - length_2
        long, short = (_traversal(c_1), _traversal(c_2)) if offset >= 0 else (_traversal(c_2), _traversal(c_1))
        for i in range(offset):
            next(long)
        for node_1, node_2 in zip(long, short):
            if node_1 is node_2:
                break
        intersect_node = node_1
    return is_intersect, intersect_node


def check_intersect_two(c_1, c_2):
    def _traversal(c):
        node = c.header
        while node and node.next:
            yield node
            node = node.next
        yield node

    # Create a loop for one of linked lists.
    for node in _traversal(c_1): pass
    node.next = c_1.header
    is_intersect, intersect_node = check_loop(c_2)[:2]
    # Un-loop
    node.next = None
    return is_intersect, intersect_node


if __name__ == '__main__':
    print('------------ intersect check ------------------')
    print('''
    chain_1:  0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6
    chain_2:  3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13
    ''')
    chain_1 = LinkedList(range(7))
    chain_2 = LinkedList(range(3, 14))
    print('Linked lists are intersected: %s, intersected node is: %s' % check_intersect_one(chain_1, chain_2))
    print('Linked lists are intersected: %s, intersected node is: %s' % check_intersect_two(chain_1, chain_2))

    # Merge two linked lists
    print('''Merge two linked lists:
    chain_1:  0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 _
                                               \\
    chain_2:                 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13
    ''')
    node_6 = chain_1.find(6)
    node_7 = chain_2.find(7)
    node_6.next = node_7

    # Method one:
    print('Linked lists are intersected: %s, intersected node is: %s' % check_intersect_one(chain_1, chain_2))
    # Method two:
    print('Linked lists are intersected: %s, intersected node is: %s' % check_intersect_two(chain_1, chain_2))

分段解释

首先导入链表类和有环检测函数，

from linked_list import LinkedList
from linked_list_loop_check import check_loop

接着定义第一种检测方法，

1. 定义遍历函数，用于遍历链表
2. 分别遍历两个链表，记录下步数即为链表长度，最后的结点即链表尾结点
3. 判断尾结点是否相同，若不同则不想交
4. 若相同则根据长度判断，让长链表先前进长度差的步数
5. 随后同时前进两个链表，找到第一个相遇点即为相交结点。

def check_intersect_one(c_1, c_2):
    def _traversal(c):
        node = c.header
        while node and node.next:
            yield node
            node = node.next
        yield node

    is_intersect, intersect_node = False, None
    # Get tail node and length
    step_1 = step_2 = 0
    for node_1 in _traversal(c_1):
        step_1 += 1
    for node_2 in _traversal(c_2):
        step_2 += 1
    tail_1, length_1 = node_1, step_1
    tail_2, length_2 = node_2, step_2

    if tail_1 is tail_2:
        # Intersected, fetch the first same node encountered as intersect node.
        is_intersect = True
        offset = length_1 - length_2
        long, short = (_traversal(c_1), _traversal(c_2)) if offset >= 0 else (_traversal(c_2), _traversal(c_1))
        for i in range(offset):
            next(long)
        for node_1, node_2 in zip(long, short):
            if node_1 is node_2:
                break
        intersect_node = node_1
    return is_intersect, intersect_node

再定义第二种检测方法，

1. 定义遍历函数，遍历其中一个链表并找到尾结点
2. 首尾相接形成一个环
3. 判断另一个链表是否有环，并获取结果信息
4. 解除前面的链表环，还原链表，并返回结果

def check_intersect_two(c_1, c_2):
    def _traversal(c):
        node = c.header
        while node and node.next:
            yield node
            node = node.next
        yield node

    # Create a loop for one of linked lists.
    for node in _traversal(c_1): pass
    node.next = c_1.header
    is_intersect, intersect_node = check_loop(c_2)[:2]
    # Un-loop
    node.next = None
    return is_intersect, intersect_node

最后，通过下面的函数进行测试，首先生成两个不相交的链表并用两种方法进行判断，接着讲其中一个链表和另一个链表相交，再进行判断。

if __name__ == '__main__':
    print('------------ intersect check ------------------')
    print('''
    chain_1:  0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6
    chain_2:  3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13
    ''')
    chain_1 = LinkedList(range(7))
    chain_2 = LinkedList(range(3, 14))
    print('Linked lists are intersected: %s, intersected node is: %s' % check_intersect_one(chain_1, chain_2))
    print('Linked lists are intersected: %s, intersected node is: %s' % check_intersect_two(chain_1, chain_2))

    # Merge two linked lists
    print('''Merge two linked lists:
    chain_1:  0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 _
                                               \\
    chain_2:                 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13
    ''')
    node_6 = chain_1.find(6)
    node_7 = chain_2.find(7)
    node_6.next = node_7

    # Method one:
    print('Linked lists are intersected: %s, intersected node is: %s' % check_intersect_one(chain_1, chain_2))
    # Method two:
    print('Linked lists are intersected: %s, intersected node is: %s' % check_intersect_two(chain_1, chain_2))

输出结果

------------ intersect check ------------------

    chain_1:  0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6
    chain_2:  3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13
    
Linked lists are intersected: False, intersected node is: None
Linked lists are intersected: False, intersected node is: None
Merge two linked lists:
    chain_1:  0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 _
                                               \
    chain_2:                 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 -> 11 -> 12 -> 13
    
Linked lists are intersected: True, intersected node is: 7
Linked lists are intersected: True, intersected node is: 7

 

参考链接

---

http://blog.csdn.net/liuxialong/article/details/6555850

http://www.cppblog.com/humanchao/archive/2008/04/17/47357.html