镜像二叉树、平衡二叉树、二叉搜索树

1. 镜像二叉树

将二叉树交换结点变成其镜像

1.1 递归

def mirror(node):
    if node is None:
        return
    node.left, node.right = node.right, node.left
    mirror(node.left)
    mirror(node.right)

1.2 非递归

类似层次遍历

def mirror1(node):
    if node is None:
        return
    stack = [node]
    while stack:
        node = stack.pop()
        node.left, node.right = node.right, node.left
        if node.left:
            stack.append(node.left)
        if node.right:
            stack.append(node.right)

1.3 判断是否为镜像二叉树（对称二叉树）

def is_mirror_tree(node):
    if node is None:
        return True
    return fun(node.left, node.right)


def fun(n1, n2):
    if (n1 is None) and (n2 is None):
        return True
    if n1 and n2:
        return (n1.val == n2.val) and (fun(n1.left, n2.right)) and (fun(n1.right, n2.left))
    return False

1.4 测试

node1 = TreeNode(1)
node2 = TreeNode(2)
node3 = TreeNode(3)
node4 = TreeNode(4)
node5 = TreeNode(5)
node6 = TreeNode(6)
node7 = TreeNode(7)
root = node1
root.left = node2
root.right = node3
node2.right = node5
node2.left = node4
node3.right = node7
node3.left = node6

mirror1(root)
level(root)
# 1 3 2 7 6 5 4

2. 平衡二叉树

2.1 求树高

def depth(node):
    if node is None:
        return 0
    return max(depth(node.left), depth(node.right))+1

2.2 判断是否为平衡二叉树

def is_balance_tree(node):
    if node is None:
        return True
    return (abs(depth(node.left)-depth(node.right)) <= 1) \
           and (is_balance_tree(node.left)) and (is_balance_tree(node.right))

2.3 优化

针对判断平衡二叉树的逻辑进行优化。

在求树高时，判断是否为平衡树。

子树是否为平衡二叉树？

Y --> 返回子树高度；

N --> 返回-1（停止遍历）。

def is_balance_tree1(node):
    return depth1(node) != -1


def depth1(node):
    if node is None:
        return 0
    left = depth1(node.left)
    # 左子树非平衡时
    if left == -1:
        return -1
    right = depth1(node.right)
    if right == -1:
        return -1
    if abs(left-right) > 1:
        return -1
    return max(left, right)+1

3. 二叉搜索树

求二叉搜索树（BST二叉排序树）的第k(小)个结点。

中序遍历寻找第k个（BST中序遍历有序）

cnt = 0
def kth_node(root, k):
    global cnt
    if not root:
        return None
    node = kth_node(root.left, k)
    if node:
        return node
    cnt += 1
    if cnt == k:
        return root
    node = kth_node(root.right, k)
    if node:
        return node

测试

node1 = TreeNode(1)
node2 = TreeNode(2)
node3 = TreeNode(3)
node4 = TreeNode(4)
node5 = TreeNode(5)
node6 = TreeNode(6)
node7 = TreeNode(7)
root = node4
root.left = node2
root.right = node6
node2.right = node3
node6.left = node5
print(kth_node(root, 3).val)
# 4

4. 二叉树中序遍历的下一个结点

next 为指向父结点的指针。

可能有问题，需验证！！！

def next_node(node):
    if node is None:
        return None
    # 若该结点有右子树，则为右子树最左边结点（最左边结点可以有右孩子）
    if node.right:
        temp = node.right
        while temp.left:
            temp = temp.left
        return temp
    while node.next:
        # 找到第一个当前结点是父结点左孩子的结点
        if node.next.left == node:
            return node.next
        # 沿着父结点向上遍历
        node = node.next
    return None

对于中序遍历的下一个结点，如果它有右子树，则一定是右子树中最左侧的结点；若没有右子树，则判断是否存在以它为左子树的父结点，一直回溯，找到第一个这样的父结点并返回，否则它就是根结点且无右子树。