114. 二叉树展开为链表

给你二叉树的根结点 root ，请你将它展开为一个单链表：
展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。
展开后的单链表应该与二叉树 先序遍历 顺序相同。

示例 1：
输入：root = [1,2,5,3,4,null,6]
输出：[1,null,2,null,3,null,4,null,5,null,6]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [0]
输出：[0]

提示：
树中结点数在范围 [0, 2000] 内
-100 <= Node.val <= 100
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list

题目明确说要与二叉树的前序遍历的顺序相同，那么很简单想到的暴力法就是将前序遍历存下来，然后一个一个放回树上。

class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        # 暴力法
        result = []
        if not root:
            return []
        if not root.left and not root.right:
            return root
        def pre_order(node):
            result.append(node)
            if node.left:
                pre_order(node.left)
            if node.right:
                pre_order(node.right)
        
        pre_order(root)
        temp = root
        while result:
            temp.right = result.pop(0)
            temp.left = None
            temp = temp.right

这个方法简单，但是消耗比较大。
时间复杂度为O(N)，空间复杂度为O(N)。

第二种方法是在前序遍历的基础上直接把树生成，也就是说，当前遍历到的节点为上一轮次遍历节点的右子节点，而左子节点置空。就会遇到问题：直接放过来的话会破坏树的结构，让树的遍历出现问题，故不能这么做。那么我们只能反过来，从末尾开始找，然后以末尾为右子节点再向上建树。
发现顺序是与前序遍历的倒序（并不是后序遍历）。
这里还有一个问题是，我们不能通过global来简单声明全局变量。global的用法，但是我们可以直接在类声明中声明变量。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def __init__(self):
        self.pre = None

    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        # pre = None
        # 前序遍历的逆序
        def order(node):
            # global pre
            if not node:
                return
            order(node.right)
            order(node.left)
            # 将节点接上去
            node.right = self.pre
            node.left = None
            self.pre = node
        
        order(root)

比较巧妙，用pre来记录当前节点的右子节点
时间复杂度是O(N)
空间复杂度是O(1)

第三种方法就是题目中要求的inplace法，要求只在原本的树上进行顺序修改，得到新的返回结果。

    1
   / \
  2   5
 / \   \
3   4   6

//将 1 的左子树插入到右子树的地方
    1
     \
      2         5
     / \         \
    3   4         6        
//将原来的右子树接到左子树的最右边节点
    1
     \
      2          
     / \          
    3   4  
         \
          5
           \
            6
            
 //将 2 的左子树插入到右子树的地方
    1
     \
      2          
       \          
        3       4  
                 \
                  5
                   \
                    6   
        
 //将原来的右子树接到左子树的最右边节点
    1
     \
      2          
       \          
        3      
         \
          4  
           \
            5
             \
              6         
  
  ......

作者：windliang
链接：https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by--26/

上面的是大佬的示意图，很适合理解。那么接下来代码也很顺利写出来。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        # 接尾法
        while root:
            if not root.left:
                root = root.right
            else:
                # 记录下right的情况，之后放在末尾
                temp = root.right
                # 把right换成left，left置空
                root.right = root.left
                root.left = None
                # root往下走
                root = root.right
                # 把temp放到末尾
                temp_ = root
                while temp_.right:
                    temp_ = temp_.right
                temp_.right = temp

时间复杂度为O(N)
空间复杂度为O(1)