二叉树-转化问题

108. 将有序数组转换为二叉搜索树
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

      0
     / 
   -3   9
   /   /
 -10  5

class Solution:
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        def helper(left, right):
            if left > right:
                return None

            # 总是选择中间位置右边的数字作为根节点
            mid = (left + right + 1) // 2

            root = TreeNode(nums[mid])
            root.left = helper(left, mid - 1)
            root.right = helper(mid + 1, right)
            return root

        return helper(0, len(nums) - 1)

109. 有序链表转换二叉搜索树
给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定的有序链表： [-10, -3, 0, 5, 9],

一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：

      0
     / 
   -3   9
   /   /
 -10  5

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

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

class Solution:
    def findMiddle(self, head):
        prevPtr = None
        slowPtr = head
        fastPtr = head
        while fastPtr and fastPtr.next:
            prevPtr = slowPtr
            slowPtr = slowPtr.next
            fastPtr = fastPtr.next.next
        if prevPtr:
            prevPtr.next = None
        return slowPtr
    def sortedListToBST(self, head):
        if not head:
            return None
        mid = self.findMiddle(head)
        node = TreeNode(mid.val)
        if head == mid:
            return node
        node.left = self.sortedListToBST(head)
        node.right = self.sortedListToBST(mid.next)
        return node

114. 二叉树展开为链表
给定一个二叉树，原地将它展开为一个单链表。
例如，给定二叉树

    1
   / 
  2   5
 /    
3   4   6
将其展开为：

1
 
  2
   
    3
     
      4
       
        5
         
          6
输入
[1,2,5,3,4,null,6]

class Solution(object):
    def flatten(self, root):
        if not root:
            return
        queue = []
        # 前序遍历整棵二叉树，并将遍历的结果放到数组中
        def dfs(root):
            if not root:
                return
            queue.append(root)
            dfs(root.left)
            dfs(root.right)
        dfs(root)
        head = queue.pop(0)
        head.left = None
        # 遍历链表，将链表中的TreeNode节点前后串联起来
        while queue:
            tmp = queue.pop(0)
            tmp.left = None
            head.right,head = tmp,tmp

#使用辅助栈，先右后左
class Solution(object):
    def flatten(self, root):
        if not root:
            return
        stack = [root]
        pre = TreeNode(-1)
        while stack:
            # 用栈作为辅助数据结构，从栈中弹出元素后
            # 先将右节点放到栈中，再将左节点放入栈中，模拟前序遍历
            tmp = stack.pop()
            pre.left,pre.right = None,tmp
            # 先放入右节点，再放入左边点，顺序不能反了
            if tmp.right:
                stack.append(tmp.right)
            if tmp.left:
                stack.append(tmp.left)
            pre = tmp