剑指offer部分题目（三）

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

class BinaryTree:
    def __init__(self):
        self.root = None
    def mk_tree(self, lst):
        lst = [Node(x) for x in lst]
        quant = len(lst)
        self.root = lst[0]
        for i in range(quant):  # 0 - 11  ,quant = 12
            cur = lst[i]
            if i == 0:
                self.root = cur
            if i * 2 + 1 <= quant - 1:
                cur.left = lst[i * 2 + 1]
            if i * 2 + 2 <= quant - 1:
                cur.right = lst[i * 2 + 2]

    def bst_tree(self,val):#建立二叉搜索树：左节点永远小于右节点
        n = Node(val)
        if not self.root:
            self.root = n
        else:
            cur = self.root
            while True:
                n_left = cur.left
                n_right = cur.right
                if val <= cur.val:#比节点小有两种情况：1、左节点空，直接插入 2、 左节点有值，进行比较后决定下一轮循环还是插入左节点
                    if not n_left:
                        cur.left = n
                        break
                    else:
                        if val < cur.left.val:#进入下一次循环
                            cur = cur.left
                            continue
                        else:#插入左节点
                            cur.left = n
                            cur.left.left = n_left
                else:
                    if not n_right:
                        cur.right = n
                        break
                    else:
                        if val >cur.right.val:
                            cur= cur.right
                            continue
                        else:
                            cur.right = n
                            cur.right.right = n_right
    # 从上到下打印二叉树，相当于层序遍历
    @property
    def traver(self):
        l1, l2 = [self.root], []
        while True:
            for i in l1:
                n = print(i.val) if i != None else 1
                if n == 1:  # 如果n 是1，说明i是none ，就返回
                    return None
                l2.append(i.left)
                l2.append(i.right)

            if l2[-1] == None:
                for i in [x.val for x in l2 if x != None]:
                    print(i)
                return None
            l1 = l2
            l2 = []

tree = BinaryTree()
tree.mk_tree(list(range(10)))
l=[]

# 二叉树镜像：1、递归实现  2、层序遍历，每个节点的左右子节点互换，实现过就不重写了。
def mirror(root):
    if not root:
        return None
    else:
        root.left, root.right = root.right, root.left
        mirror(root.left) if root.left != None else None
        mirror(root.right) if root.right != None else None


# 输入二叉树的根节点和整数，打印出二叉树节点值和为输入整数的所有路径。dfs找到所有路径然后算和.. 未完成
def dfs_pre(L):
    pass
    
# 之字型打印二叉树：第一行左往右，第二行右往左
def zhi(tree):
    l1 = [tree.root]
    l2 = []
    n = 2
    while True:
        for i in l1:
            l2.append(i.left)
            l2.append(i.right)
        if n % 2 == 0:
            print(*[x.val for x in l1])
            n += 1
        else:
            print(*[x.val for x in l1[::-1]])  # 偶数行逆序打印
            n += 1
        if l2[-1] is None:
            lll = [x.val for x in l2 if x != None]
            l1 = lll if 0 == n % 2 else lll[::-1]
            print(*l1)
            break
        l1 = l2
        l2 = []

# 求深度：两个列表，加一个计数器
def get_depth(tree):
    cur = tree.root
    l, next_l = [cur], []
    depth = 0
    while True:
        depth +=1
        for i in l:#非None就加入
            if i.left:
                next_l.append(i.left)
            if i.right:
                next_l.append(i.right)
        l = next_l[:]
        next_l.clear()
        if not l:
            print('max depth is {}'.format(depth))
            return depth

# 二叉搜索树的第K小个节点：中序遍历，然后输出列表的第K个数就行了。
def mid_k(tree,K):
    l = []
    def handle(root):
        if len(l) == K or root == None:
            return
        else:
            handle(root.left)
            l.append(root.val)
            handle(root.right)
    handle(tree.root)
    print(l)
    print(l[K-1])
    return l[K-1]

# 判断是否平衡二叉树:1、左右子树高度差不超过1 ，2、左右子树都是平衡二叉树  注意：平衡二叉树就是AVL树
def is_balanced(tree):#层序遍历，一旦少于存在None，子节点深度不能再超过2层。
    l1 = [tree.root]
    l2 = []
    n = 1
    while True:
        for i in l1:
            left = i.left if i.left is not None else None
            right = i.right if i.right is not None else None
            l2.append(left)
            l2.append(right)
        l1 = l2[:]
        l2 = []
        if None in l1:
            break
    if l1.count(None) == len(l1):
        return True
    [l2.append(i) for i in l1 if i is not None]
    for i in l2:
        if i.left is not None or i.right is not None:
            return False
    return True

# 二叉搜索树转化成排序的双向链表：中序遍历放到一个列表，遍历弄成双向链表即可

# 判断是否为一对称的二叉树： 用实现了的镜像函数，一一输出值，如果相等则是对称

# 重建二叉树，未实现