【算法 in python | 树】其他试题

1. 对称二叉树

判断一个树是否是对称的。（递归）

def sym(head):
    if head is None:
        return True
    else:
        return cmp(head.left, head.right)
def cmp(left,right):
    if left is None and right is None:
        return True
    elif left is None or right is None:
        return False
    elif left.val != right.val:
        return False
    else:
        return cmp(left.left, right.right) and cmp(left.right, right.left)

2. 镜像二叉树（递归）

def mirrorTree(head):
    if head is None or (head.left is None and head.right is None):
        return
    else:
        temp = head.left
        head.left = head.right
        head.right = temp
        if head.left:
            mirrorTree(head.left)
        if head.right:
            mirrorTree(head.right)

3. 二叉树深度（递归）

def depthTree(head):
    if head is None:
        return 0
    else:
        return 1+ max(depthTree(head.left), depthTree(head.right))

4. 二叉树宽度（层次遍历二叉树，逐行打印二叉树）：

def widthTree(head):
    res = []
    width = 0
    if head is None:
        return 0
    queue = [head]
    while len(queue) > 0:
        res.append([i.val for i in queue])
        width = len(queue)
        for i in range(len(queue)):
            p = queue.pop(0)
            if p.left:
                queue.append(p.left)
            if p.right:
                queue.append(p.right)
    return width

5. 平衡二叉树（递归）

一棵树，若左右子树高度差不超过1，则为平衡二叉树

def balance(head):
    if head is None:
        return True
    if abs(depthTree(head.left) - depthTree(head.right)) > 1:
        return False
    return balance(head.left) and balance(head.right)

6. 重建二叉树（已知前序，中序）（递归）

def rebuild(pre,mid):
    if len(pre) == 0:
        return 
    if len(pre) == 1:
        return TreeNode(pre[0])
    index = mid.index(pre[0])
    t = TreeNode(pre[0])
    t.left = rebuild(pre[1:index + 1], mid[:index])
    t.right = rebuild(pre[index+1:], mid[index+1:])
    return t

7. 二叉搜索树（二叉排序树）第k个节点

二叉搜索树：左子树>跟>右子树，与中序遍历对应

class Solution:
    # 返回对应节点TreeNode,中序遍历即可
    def __init__(self):
        self.result = []
    def KthNode(self, pRoot, k):
        if k <= 0:
            return None
        else:
            self.midsort(pRoot)
            if k > len(self.result):
                return None
            return self.result[k-1]
        
    def midsort(self, p):
        if p == None:
            return None
        else:
            self.midsort(p.left)
            self.result.append(p)
            self.midsort(p.right)

8. 二叉搜索树后序遍历

判断某序列是否为二叉搜索树后续遍历的结果。

class Solution:
    def VerifySquenceOfBST(self, sequence):
        # 二叉搜索树后序序列，最后一个节点是根节点，剩下的可以分成两个序列
        #左边的都比根小，右边的都比根大
        if sequence == []:
            return False
        return self.judge(sequence)
    
    def judge(self,sequence):
        if len(sequence) == 0:
            return True
        root = sequence.pop(-1)
        left = [i for i in sequence if i < root]
        right = [i for i in sequence if i > root]
        if left +right == sequence:
            return self.judge(left) and self.judge(right)
        else:
            return False