数据结构与算法之美 课程笔记六 链表（下）如何轻松写出正确的链表代码？

技巧一：理解指针或引用的含义

将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存指针，指向了这个变量，通过指针就能找到这个变量。

p->next = q, 表示p结点的next指针存储了q结点的内存地址。

p->next = p->next->next，表示p结点的next指针存储了p结点的下下一个结点的内存地址。

技巧二：警惕指针丢失和内存泄漏

在结点a和结点b之间插入结点x时，如果这样写代码，就会出现指针丢失：

p->next = x;  // 将 p 的 next 指针指向 x 结点；
x->next = p->next;  // 将 x 的结点的 next 指针指向 b 结点；

p->next 指针在完成第一步操作之后，已经不再指向结点b，而是指向结点x。第 2 行代码相当于将 x 赋值给 x->next，自己指向自己。因此，整个链表就断成了两半。

在插入结点时，一定要注意操作的顺序，要先将结点x的next指针指向结点b，再将a的next指针指向结点x，这样才不会丢失指针。

删除表结点时，也一定要记得手动释放内存空间，否则，会出现内存泄漏的问题。

技巧三：利用哨兵简化实现难度

针对链表的插入、删除操作，需要对插入第一个结点和删除最后一个几点的情况进行特殊处理。这时，可以引入哨兵结点，在任何时候，不管链表是否为空，head指针都会一直指向这个哨兵结点。这种有哨兵结点的链表叫做带头链表，相反，没有哨兵结点的链表叫做不带头链表。

哨兵结点不存储数据，因为哨兵结点一直存在，所以插入第一个结点和插入其他结点，删除最后一个结点和删除其他结点，都可以统一为相同的代码实现逻辑。

利用哨兵简化编程难度的技巧，在很多代码实现中都有用到，如插入排序、冰柜排序、动态规划等。

技巧四：重点留意边界条件处理

常用的检查链表代码是否正确的边界条件：
如果链表为空，代码是否能正常工作？
如果链表只包含一个结点，代码是否能正常工作？
如果链表只包含两个结点，代码是否能正常工作？
代码逻辑在处理头结点和尾结点的时候，是否能正常工作？

技巧五：举例画图，辅助思考

往单链表中插入一个数据时，把各种情况都举一个例子，画出插入前和插入后的链表变化。

技巧六：多写多练，没有捷径

5个常见的链表操作：

单链表反转
链表中环的检查
两个有序的链表合并
删除链表倒数第n个结点
求链表的中间结点

from typing import Optional

class Node(object):
    def __init__(self, value):
        self.value = value
        self.next = None

#反序链表（自己实现）
def reverse_linkedlist(list_a: Node) -> Optional[Node]:
    cur = list_a
    list_reverse = None
    while cur:
        new_node = Node(cur.value)
        if not list_reverse:
            list_reverse = new_node
        else:
            new_node.next = list_reverse
            list_reverse = new_node
        cur = cur.next
    return list_reverse

#反序链表（简洁的实现）
def reverse(head: Node) -> Optional[Node]:
    reversed_head = None
    current = head
    while current:
        reversed_head, reversed_head.next, current = current, reversed_head, current.next
    return reversed_head

#检查链表是否有环
def check_cycle(list_a: Node) -> bool:
    fast = list_a
    slow = list_a
    while fast and fast.next:
        fast = fast.next.next
        slow = slow.next
        if fast == slow:
            return True
    return False

#合并两个有序链表
def merge_sorted_linkedlist(list_a: Node, list_b: Node) -> Optional[Node]:
    if list_a and list_b:
        merged = Node(None)  #添加哨兵结点
        cur = merged
        head_a = list_a
        head_b = list_b
        while head_a and head_b:
            if head_a.value <= head_b.value:
                cur.next, head_a = head_a, head_a.next
            else:
                cur.next, head_b = head_b, head_b.next
            cur = cur.next
        cur.next = head_a if head_a else head_b
        return merged.next # 去除哨兵结点
    return list_a or list_b

#删除链表倒数第n个结点
def remove_rev_nth_node(list_a: Node, n: int) -> Optional[Node]:
    count = 0
    cur = list_a
    while cur:
        count += 1
        cur = cur.next
        if count >= n:
            break
    if not cur and count < n: # 链表的长度小于n
        return list_a
    if not cur and count == n: # 链表的长度等于n
        return list_a.next
    slow = list_a    # 链表的长度大于n
    while cur.next:
        slow = slow.next
        cur = cur.next
    slow.next = slow.next.next
    return list_a


#求链表的中间结点
def find_middle_node(list_a: Node):
    fast = list_a
    slow = list_a
    fast = fast.next if fast else None
    while fast and fast.next:
        fast = fast.next.next
        slow = slow.next
    return slow


def generate_a_linkedlist(data) -> Optional[Node]:
    list_head = None
    cur = None
    for i in data:
        if not list_head:
            list_head = Node(i)
            cur = list_head
        else:
            cur.next = Node(i)
            cur = cur.next
    return list_head

def get_linkedlist_info(list_head):
    info = ""
    cur = list_head
    while cur:
        info += str(cur.value) + ","
        cur = cur.next
    return info[:-1]

def get_tail_node(list_head):
    cur = list_head
    while cur.next:
        cur = cur.next
    return cur

    

def main():
    print("-------------reverse list----------------")
    list_head = generate_a_linkedlist([1, 2, 3, 4, 5])
    print("origin list: %s" % get_linkedlist_info(list_head))
    list_head_rev = reverse_linkedlist(list_head)
    print("reverse linkedlist: %s" % get_linkedlist_info(list_head_rev))

    print("-------------check in cycle----------------")
    print("list %s has cycle or not: %s" % (get_linkedlist_info(list_head), check_cycle(list_head)))
    get_tail_node(list_head).next = list_head
    print("list has cycle or not: %s" % (check_cycle(list_head)))

    print("-------------merge two sorted list----------------")
    list_a = generate_a_linkedlist([1, 3, 5, 8,10])
    print("list a: %s" % get_linkedlist_info(list_a))
    list_b = generate_a_linkedlist([2, 4, 5, 7, 9])
    print("list b: %s" % get_linkedlist_info(list_b))
    merged = merge_sorted_linkedlist(list_a, list_b)
    print("merged: %s" % get_linkedlist_info(merged))
   
    print("-------------remove nth node from list end----------------")
    list_head = generate_a_linkedlist([1, 2, 3, 4, 5, 6])
    print("origin list: %s" % get_linkedlist_info(list_head))
    removed = remove_rev_nth_node(list_head, 3)
    print("remove %dth node from end: %s " %  (3, get_linkedlist_info(removed)))
    list_head = generate_a_linkedlist([1, 2, 3, 4, 5, 6])
    removed = remove_rev_nth_node(list_head, 6)
    print("remove %dth node from end: %s " %  (6, get_linkedlist_info(removed)))
    list_head = generate_a_linkedlist([1, 2, 3, 4, 5, 6])
    removed = remove_rev_nth_node(list_head, 7)
    print("remove %dth node from end: %s " %  (7, get_linkedlist_info(removed)))

    print("-------------find middle node----------------")
    list_head = generate_a_linkedlist([1, 2, 3, 4, 5])
    print("middle node of list %s : %s" % (get_linkedlist_info(list_head), find_middle_node(list_head).value))
    list_head = generate_a_linkedlist([1, 2, 3, 4, 5, 6])
    print("middle node of list %s : %s" % (get_linkedlist_info(list_head), find_middle_node(list_head).value))

if __name__ == "__main__":
    main()

运行结果：

-------------reverse list----------------
origin list: 1,2,3,4,5
reverse linkedlist: 5,4,3,2,1
-------------check in cycle----------------
list 1,2,3,4,5 has cycle or not: False
list has cycle or not: True
-------------merge two sorted list----------------
list a: 1,3,5,8,10
list b: 2,4,5,7,9
merged: 1,2,3,4,5,5,7,8,9,10
-------------remove nth node from list end----------------
origin list: 1,2,3,4,5,6
remove 3th node from end: 1,2,3,5,6 
remove 6th node from end: 2,3,4,5,6 
remove 7th node from end: 1,2,3,4,5,6 
-------------find middle node----------------
middle node of list 1,2,3,4,5 : 3
middle node of list 1,2,3,4,5,6 : 3