数据结构-邓俊辉视频（Python代码-树Chap5）

文件1——BinNode.py

#长子兄弟表示法：父节点指向first child，且first child指向next sibling
#利用长子兄弟表示法，二叉树能表示所有类型的树
class BinNode:
    def __init__(self,data,parent = None):
        self.parent = parent
        self.lChild = None
        self.rChild = None
        self.data = data
        self.height = 0

    def size(self):
        s = 1
        if self.lChild is not None:
            s += self.lChild.size()
        if self.rChild is not None:
            s += self.rChild.size()
        return s

    def insertAsLC(self,e):
        '''作为左孩子插入新节点'''
        newnode = BinNode(e,self)
        self.lChild = newnode
        return newnode

    def insertAsRC(self,e):
        '''作为右孩子插入新节点'''
        newnode = BinNode(e,self)
        self.rChild = newnode
        return newnode

    def __str__(self):
        st = " "*3 + str(self.data)+"\n"
        if self.lChild is not None and self.rChild is not None:
            st += " "*2+"/"+" "*2+"\\"+"\n"
            st += str(self.lChild.data)+" "*4 + str(self.rChild.data)
        elif self.lChild is not None:
            st += " " * 2 + "/" + "\n"
            st += str(self.lChild.data)
        elif self.rChild is not None:
            st += " "*5 + "\\"+"\n"
            st += " "*6 + str(self.rChild.data)
        return st

    def succ(self):
        '''中序意义下，当前节点的直接后继'''
        pass

if __name__ == '__main__':
    tree = BinNode(15)
    tree.insertAsLC(12)
    tree.insertAsRC(15)
    print(tree)

文件2——BinTree.py

import BinNode as BN
import Chap3.stack as Stack
import Chap3.Queque as Queque
class BinTree:
    def __init__(self,root = None):
        self.__root = root
        self.__size = 1
        self.value = []
        self.S = Stack.Stack()
        self.Q = Queque.Queque()

    def empty(self):
        return self.__root is None

    def root(self):
        return self.__root

    def size(self):
        return self.__size

    def stature(self,x):
        if x is None:
            return -1
        else:
            return x.height

    def updateHeight(self,x):
        '''更新节点x的高度'''
        x.height = max(self.stature(x.lChild),self.stature(x.rChild)) + 1
        return x.height

    def updateHeightAbove(self,x):
        '''更新节点x及祖先的高度'''
        while x is not None:
            UB = x.height
            if UB != self.updateHeight(x):
                x = x.parent
            else:
                break

    def insertAsLC(self,x,e):
        '''为x插入值为e的左节点'''
        newnode = BN.BinNode(e,x)
        x.lChild = newnode
        self.updateHeightAbove(x)
        self.__size += 1
        return newnode

    def insertAsRC(self,x,e):
        '''作为x插入值为e的右节点'''
        newnode = BN.BinNode(e,x)
        x.rChild = newnode
        self.updateHeightAbove(x)
        self.__size += 1
        return newnode

    #前序遍历，将右节点推入栈中
    def visitAlongLeftBranch(self,x):
        while(x is not None):
            self.value.append(x.data)
            if x.rChild is not None:
                self.S.push(x.rChild)
            x = x.lChild

    def travPre(self):
        '''子树先序遍历'''
        prob = self.__root
        while(True):
            self.visitAlongLeftBranch(prob)
            if self.S.size == 0:
                break
            prob = self.S.pop()

    #中序遍历
    def goAlongLeftBranch(self,x):
        while(x is not None):
            self.S.push(x)
            x = x.lChild

    def travIn(self):
        prob = self.__root
        while(True):
            self.goAlongLeftBranch(prob)
            if self.S.size == 0:
                break
            prob = self.S.pop()
            self.value.append(prob.data)
            prob = prob.rChild

    #层次遍历
    def travLevel(self):
        self.Q.enqueue(self.__root)
        while(self.Q.size != 0):
            prob = self.Q.dequeue()
            self.value.append(prob.data)
            if prob.lChild is not None:
                self.Q.enqueue(prob.lChild)
            if prob.rChild is not None:
                self.Q.enqueue(prob.rChild)


if __name__ == '__main__':
    #        12
    #       /  \
    #     12   15
    #    / \     \
    #  23  77    88
    #创建树：
    rootNode = BN.BinNode(12)
    tree = BinTree(root = rootNode)
    tree.insertAsLC(rootNode,12)
    tree.insertAsRC(rootNode,15)
    node1 = rootNode.lChild
    node2 = rootNode.rChild
    tree.insertAsLC(node1,23)
    tree.insertAsRC(node1,77)
    #print(node1)
    tree.insertAsRC(node2,88)
    #先序遍历
    # tree.travPre()
    # print("先序遍历：",tree.value)
    # print("根节点的深度：",rootNode.height)
    # print("第二层节点15的深度：",node2.height)
    # print("树的总节点数：",tree.size())
    #中序遍历
    #tree.travIn()
    #print("中序遍历：",tree.value)
    #层次遍历
    tree.travLevel()
    print("层次遍历：",tree.value)

二叉树的重构

刚巧在leetcode上刷到一个二叉树的重构题，邓俊辉老师视频没给代码模板当时就没写，今天恰巧在leetcode上补了
tag：数组；题号：105
leetcode 105题，二叉树重构

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        def subtree(pre_left:int,pre_right:int,in_left:int,in_right:int):
            if pre_left > pre_right:
                return None
            rootindex = pre_left
            pindex = index[preorder[rootindex]]
            root = TreeNode(preorder[rootindex])
            left_size = pindex - in_left

            root.left = subtree(pre_left+1,pre_left + left_size,in_left,pindex-1)
            root.right = subtree(pre_left+left_size+1,pre_right,pindex+1,in_right)
            return root
        
        n = len(preorder)
        index = {value:index for index,value in enumerate(inorder)}
        return subtree(0,n-1,0,n-1)