数据结构算法——链表

一、反转链表

• 要点：代码可以极度简洁（4行）
  

二、两两对换

• 要点：需要4个指针
  

• 题解：
  为什么需要4个指针？
  1、一个用来做真正的头指针
  2、一个用来作为每次动刀的标志位（并且作为要屡回两两交换后的和前束的链接，因为两两交换只完成了后续指针链接的变动，没有纠正前束）
  3、两个用来交换指针

三、是否有环

1、命中自己
2、龟兔赛跑

• 要点：循环的条件注意不要error
  

四、二叉树展开为链表（Leetcode 114）

4.1 解法1（前序遍历全保存下来，再连成链表）

*时间复杂度O（N）
*空间复杂度O（N）

class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        self.ret = TreeNode(0)
        self.cur = self.ret
        self.stack = []
        if not root:
            return root
        self.DFS_reverse(root)
        if len(self.stack)<=1:
            return root
        for v in self.stack:
            self.cur.right = v
            v.left = None
            v.right = None
            self.cur = self.cur.right

        return self.ret.right

    def DFS_reverse(self, root):
        self.stack.append(root)
        if root.left:
            self.DFS_reverse(root.left)
        if root.right:
            self.DFS_reverse(root.right)

4.2 解法2（用栈，一边前序遍历一边连成链表）

*时间复杂度O（N）
*空间复杂度O（N）

class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        if not root: return root
        stack = [root]
        pre = TreeNode(0)
        # DFS
        while stack:
            cur = stack.pop()
            if cur.right:
                stack.append(cur.right)
            if cur.left:
                stack.append(cur.left)
            pre.right = cur
            pre.left = None
            pre = cur
        return root

4.3 解法3（直接在树上改造）

*时间复杂度O（N）
*空间复杂度O（1）

class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        cur = root
        while cur:
            if cur.left:
                pre = nxt = cur.left
                while pre.right:
                    pre = pre.right
                pre.right = cur.right
                cur.left = None
                cur.right = nxt
            cur = cur.right
        return root