算法-二叉树-先序/中序/后序遍历

一、实现二叉树的先序、中序、后序遍历
递归实现：

class Solution:
    def threeOrders(self , root ):
        # write code here
        preorder, inorder, postorder = [], [], []
        def find(root):
            if not root:
                return None
            preorder.append(root.val)
            find(root.left)
            inorder.append(root.val)
            find(root.right)
            postorder.append(root.val)
            
        find(root)
        return [preorder, inorder, postorder]

迭代实现-利用栈：栈的作用就是记录下来遍历的路径，我们可以用栈代替任何用递归做的事情
快速排序就是个二叉树的前序遍历，归并排序就是个二叉树的后续遍历。

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        stack = []
        res = []
        cur = root
        while cur or stack:
            while cur:
                res.append(cur.val) #先序-根左右
                stack.append(cur)
                cur = cur.left  #先走到最左下角
            cur = stack.pop()
            #stack.append(cur) #中序-左根右
            cur = cur.right
        return res

二叉树题目的一个难点就是，如何把题目的要求细化成每个节点需要做的事情。

二、翻转二叉树：
解法：先序遍历的基础上，交换左右节点

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return root
        tmp = root.left
        root.left = root.right
        root.right = tmp
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

三、给定一棵二叉搜索树，请找出其中的第k小的TreeNode结点。
解法：根据中序遍历拿到递增序列，然后取第k个即可

#中序遍历思想。
class Solution:
    # 返回对应节点TreeNode
    def KthNode(self, pRoot, k):
        # write code here
        if not pRoot or k<1:
            return
        ans = []
        def inorder(pRoot):
            if not pRoot:
                return 
            inorder(pRoot.left)
            ans.append(pRoot)
            inorder(pRoot.right)
            return 
        inorder(pRoot)
        n = len(ans)
        if n>=k:
            return ans[k-1]
        return 

四、leetcode 116. 填充每个节点的下一个右侧节点指针
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL

解法思想：1、逐层从最左边开始遍历：
~同一父节点下的相连
~相邻父节点通过父节点的next连接。已由上一层连接好

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return None
        first = root  #双指针
        while first.left: #从每层最左侧开始，逐层遍历
            cur = first
            while cur:
                cur.left.next = cur.right  #同一父节点下的相连
                if cur.next:      #相邻父节点通过父节点的next连接。已由上一层连接好
                    cur.right.next = cur.next.left
                cur = cur.next
            first = first.left
    
        return root