【python版】算法与数据结构【树】

目录

二叉树和它的四种遍历

二叉搜索树

测试

二叉树和它的四种遍历

from collections import deque
class tree:
    def __init__(self,data):
        self.data=data
        self.lchild=None
        self.rchild=None
a=tree('a')
b=tree('b')
c=tree('c')
d=tree('d')
e=tree('e')
f=tree('f')
g=tree('g')
e.lchild=a
e.rchild=g
a.rchild=c
c.lchild=b
c.rchild=d
g.rchild=f
root=e
# 四种遍历：
def pre_order(root:tree):
    if root:
        print(root.data,end=', ')
        pre_order(root.lchild)
        pre_order(root.rchild)


def in_order(root:tree):
    if root:
        in_order(root.lchild)
        print(root.data, end=', ')
        in_order(root.rchild)

def post_order(root:tree):
    if root:
        post_order(root.lchild)
        post_order(root.rchild)
        print(root.data, end=', ')

def level_order(root:tree):
    queue=deque()
    queue.append(root)
    while len(queue)>0:
        node:tree=queue.popleft()
        print(node.data,end=', ')
        if node.lchild:
            queue.append(node.lchild)
        if node.rchild:
            queue.append(node.rchild)


pre_order(root)
print()
in_order(root)
print()
post_order(root)
print()
level_order(root)

二叉搜索树

def getele()->list:
    li=[]
    ele=input()
    ele=ele.replace(" ",'')
    for i in ele:
        i=int(i)
        li.append(i)
    return li
from collections import deque
class tree:
    def __init__(self,data):
        self.data=data
        self.lchild=None
        self.rchild=None
        self.parent=None


class BST:
    def __init__(self,li):
        self.root=None
        self.k = 1
        if li:
            for val in li:
                while self.k>0:
                    self.k-=1
                    self.root=tree(val)
                self.k-=1
                while self.k<-1:
                    self.insert(self.root,val)
                    break
    #这个初始化循环写的很差，主要是通过调试发现self.root并不能通过插入直接初始化，
    # 于是写了个专门初始化根节点的循环，不过不影响复杂度，能跑出来正确答案哈哈哈哈

    def find(self,node,val):
        if not node:
            return None
        if node.data>val:
            return self.find(node.lchild,val)
        elif node.data<val:
            return self.find(node.rchild,val)
        else:
            return node

    def insert(self,node:tree,val):
        if not node:
          node=tree(val)
        elif val<node.data:
            node.lchild=self.insert(node.lchild,val)
            node.lchild.parent=node
        elif val>node.data:
            node.rchild=self.insert(node.rchild,val)
            node.rchild.parent=node
        else:# 相等
            pass
        return node

    def pre_order(self,root: tree):
        if root:
            print(root.data, end=', ')
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self,root: tree):
        if root:
            self.in_order(root.lchild)
            print(root.data, end=', ')
            self.in_order(root.rchild)

    def post_order(self,root: tree):
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end=', ')

    def level_order(self,root: tree):
        queue = deque()
        queue.append(root)
        while len(queue) > 0:
            node: tree = queue.popleft()
            print(node.data, end=', ')
            if node.lchild:
                queue.append(node.lchild)
            if node.rchild:
                queue.append(node.rchild)
li=getele()
Tree=BST(li)

findnode=Tree.find(Tree.root,4)
findnode.data=9
print(Tree.find(Tree.root,4))


Tree.pre_order(Tree.root)
print()
Tree.in_order(Tree.root)
print()
# 中序遍历是有序的结果哦
Tree.post_order(Tree.root)
print()
Tree.level_order(Tree.root)

测试

• 查找功能：

•  遍历功能;