数据结构基础: 树

树的类型

满二叉树：除最后一层无任何子节点外，每一层上的所有结点都有两个子结点的二叉树。（节点数为n 深度为log(n+1), 深度为 k 节点数为2**k-1）

完全二叉树：从根结点到倒数第二层满足完美二叉树，最后一层可以不完全填充。

二叉搜索树：亦叫二叉查找树，二叉排序树。需满足：a.若左子树不空，则左子树上所有结点的值均小于它的根结点的值；b.若右子树不空，则右子树上所有结点的值均大于它的根结点的值；c.左、右子树也分别为二叉排序树；d.没有键值相等的结点。
注：二叉搜索树的中序遍历的结果是顺序的。

树的遍历

• 层次遍历：从上至下，从左至右遍历。
• 前序遍历：根左右
• 中序遍历：左根右
• 后序遍历：左右根

树：

class TreeNode:
	def __init__(self, x):
	    self.val = x
	    self.left = None
	    self.right = None

层次遍历:

def levelOrder(root):
	if not root:
	    return []
	res = []
	que = [root]
	while que:
	    cur = que.pop(0)
	    res.append(cur.val)
	    
	    if cur.left:
	        que.append(cur.left)
	        
	    if cur.right:
	        que.append(cur.right)
	return res

前序遍历：

def preorderTraversal(root):
    if not root:
        return []
    
    stack = [root]
    res = []
    while stack:
        cur = stack.pop()
        res.append(cur.val)
        
        if cur.right:
            stack.append(cur.right)
        
        if cur.left:
            stack.append(cur.left)
    return res

中序遍历

def inorderTraversal(root):
    if not root:
        return []
    
    res = []
    
    stack = []
    cur = root
    while stack or cur:
        if cur:
            stack.append(cur)
            cur = cur.left
        else:
            cur = stack.pop()
            res.append(cur.val)
            cur = cur.right
    return res

后序遍历

def postorderTraversal(self, root: TreeNode) -> List[int]:
    if not root:
        return []
    
    res = []
    stack = [root]
    while stack:
        cur = stack.pop()
        res.append(cur.val)
        
        if cur.left:
            stack.append(cur.left)
        
        if cur.right:
            stack.append(cur.right)
    # 根右左 翻转为 左右根
    # res[::-1] 等于 res[-1:-len(res)-1:-1]，从-1 到 -len(res)-1复制
    return res[::-1]

树的构造

由于需要中序遍历分离左右子树，所以必须有中序遍历的情况下才能构造树。注：中序遍历分类左右子树同时会明确左右子树的个数，从而在前(后)序遍历中明确左右子树的具体节点。

前序，中序构造树：递归实现，前序的第一个数确定树(子树)的根节点，中序分离左右子树。注意每个子递归前序个数与中序个数须一致。

def buildTree(self, preorder, inorder):
    if len(preorder) == 0:
        return None
    
    root = TreeNode(preorder[0])
    i = inorder.index(preorder[0])
    
    root.left = buildTree(preorder[1:i+1], inorder[:i])
    root.right = buildTree(preorder[i+1:], inorder[i+1:])    
    return root

中序，后序构造树：递归实现，由后序的最后一个数确定根节点，中序遍历确定左右子树。

def buildTree(self, inorder, postorder):
    if len(inorder) == 0:
        return None
    
    root = TreeNode(postorder[-1])
    i = inorder.index(postorder[-1])
    
    root.left = buildTree(inorder[:i], postorder[:i])
    root.right = buildTree(inorder[i+1:], postorder[i:-1])
    return root