二叉树与表达式解析树详解-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43477550/article/details/104934898

本文介绍了树的特点，特别是二叉树的性质，包括层序遍历和深度遍历。详细讨论了二叉树的添加元素、遍历方法，并通过例子解释如何根据先序和中序遍历重建后序遍历。最后，讲述了树的应用，以表达式解析树为例，展示了如何构造全括号表达式的解析树。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

树的特点
（1）每个节点有0个或多个子节点
（2）没有父节点的节点称为根节点
（3）每一个非根节点有且只有一个父节点
（4）除根节点外，每个子节点可以分为多个不相交的子树
二叉树
每个节点最多有两个子节点。
性质1: 在二叉树的第i层上至多有2^(i-1)个结点（i>0）
性质2: 深度为k的二叉树至多有2^(k-1)个结点（k>0）
性质3: 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1;
性质4:具有n个结点的完全二叉树的深度必为 log₂(n+1)
性质5:对完全二叉树，若从上至下、从左至右编号，则编号为i 的结点，其左孩子编号必为2i，其右孩子编号必为2i＋1；其双亲的编号必为i/2（i＝1 时为根,除外）
二叉树添加元素代码，添加方式为层次遍历。一层填满再填下一层。

class Node:
    def __init__(self,elem):
        self.elem = elem
        self.lchild = None   #左子树
        self.rchild = None   #右子树

class Tree:
    def __init__(self):
        self.root = None
    def add(self,item):
        #广度遍历/层次遍历
        node = Node(item)
        if self.root is None:
            self.root = node
            return
        queue = [self.root]   #用队列操作
        while queue:
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)
            if cur_node.rchild is None:
                cur_node.rchlid = node
                return
            else:
                queue.append(cur_node.rchlid)

二叉树遍历
（1）广度遍历

def breadth_travel(self):
    if self.root is None:
        return
    queue = [self.root]
    while queue:   #当queue为空，则停止循环
        cur_node = queue.pop(0)
        print(cur_node.elem)
        if cur_node.lchild is not None:
            queue.append(cur_node.lchild)
        if cur_node.rchild is not None:
            queue.append(cur_node.rchild)

（2）深度遍历
深度遍历有三种方法。先序遍历（preorder），中序遍历（inorder），后序遍历（postorder）。
在这里插入图片描述
先序遍历根节点 - > 左子树 - > 右子树

def preorder(self,node):
    if node is None:
        return
    print(node.elem,end=' ')
    self.preorder(node.lchild)
    self.preorder(node.rchild)

中序遍历左子树 - > 根节点 - > 右子树

def inorder(self,node):
    if node is None:
        return
    self.inorder(node.lchild)
    print(node.elem,end=' ')
    self.inorder(node.rchild)

后序遍历左子树 - > 右子树 - > 根节点

def postorder(self,node):
    if node is None:
        return
    self.postorder(node.lchild)
    self.postorder(node.rchild)    
    print(node.elem,end=' ')

题目：给出先序遍历和中序遍历，写出后序遍历
或：给出后序遍历和中序遍历，写出先序遍历
解析：先序遍历的第一个是根节点，后序遍历的最后一个是根节点，找到根节点就可以在中序中划分出左子树和右子树

用嵌套列表实现二叉树

def binaryTree(r):
    return [r,[],[]]

def insertLeft(root,newBranch):
    t=root.pop(1)
    root.insert(1,[newBranch,t,[]])
    return root

def insertRight(root,newBranch):
    t=root.pop(2)
    root.insert(2,[newBranch,[],t])
    return root

def getRootVal(root):
    return root[0]

def setRootVal(root,newVal):
    root[0]=newVal
    
def getLeftChild(root):
    return root[1]

def getRightChild(root):
    return root[2]

r=binaryTree(3)
insertLeft(r,4)
insertRight(r,5)
insertLeft(r,9)
insertRight(r,7)
l=getLeftChild(r)
print(r)
print(l)
insertLeft(l,11)
print(r)

输出

[3, [9, [4, [], []], []], [7, [], [5, [], []]]]
[9, [4, [], []], []]
[3, [9, [11, [4, [], []], []], []], [7, [], [5, [], []]]]

树的应用
表达式解析树全括号表达式（3 *（ 5 + 6 ））

步骤：从左到右扫描全括号表达式的每个单词，

若当前单词为"("：则在当前节点添加一个新节点作为其左子节点，当前节点下降为这个新结点
如果当前单词是操作数：将当前节点的值设为此数，当前节点上升到父节点
如果当前单词是操作符 “+,-,*,/”：将当前节点的值设为此符号，为当前节点添加一个新节点作为其右子节点，当前节点下降为这个新节点
如果当前单词是")"：则当前节点上升到父节点

import operator

class binaryTree:
    def __init__(self,root):
        self.root=None
        self.leftChild=None
        self.rightChild=None
        
    def insertLeft(self,newNode):
        if self.leftChild==None:
            self.leftChild=binaryTree(newNode)
        else:
            t=binaryTree(newNode)
            t.leftChild=self.leftChild
            self.leftChild=t
            
    def insertRight(self,newNode):
        if self.rightChild==None:
            self.rightChild=binaryTree(newNode)
        else:
            t=binaryTree(newNode)
            t.rightChild=self.rightChild
            self.rightChild=t  
    
    def getRightChild(self):
        return self.rightChild
    
    def getLeftChild(self):
        return self.leftChild
    
    def setRootVal(self,item):
        self.root=item
        
    def getRootVal(self):
        return self.root

def buildParseTree(fplist):
    pStack=[]
    eTree=binaryTree('')
    pStack.append(eTree)
    currentTree=eTree
    
    for i in fplist:
        if i=='(':
            currentTree.insertLeft('')
            pStack.append(currentTree)
            currentTree=currentTree.getLeftChild()
        elif i not in ['+','-','*','/',')']:
            currentTree.setRootVal(int(i))
            parent=pStack.pop()
            currentTree=parent
        elif i in ['+','-','*','/']:
            currentTree.setRootVal(i)
            currentTree.insertRight('')
            pStack.append(currentTree)
            currentTree=currentTree.getRightChild()
        elif i==')':
            pStack.pop()
        else:
            raise ValueError       
    return eTree

def evaluate(parseTree):
    opers={'+':operator.add,'-':operator.sub,\
           '*':operator.mul,'/':operator.truediv}
    
    leftC=parseTree.getLeftChild()
    rightC=parseTree.getRightChild()
    
    if leftC and rightC:
        fn=opers[parseTree.getRootVal()]
        return fn(evaluate(leftC),evaluate(rightC))
    else:
        return parseTree.getRootVal()
    
alist=['(','5','*','(','7','+','8',')',')']
e=buildParseTree(alist)
print(evaluate(e))   #75

树，表达式解析树