Python数据结构（树）

 

 

模拟文件系统：

class Node:
    def __init__(self,name,type='dir'):
        self.name=name
        self.type=type
        self.children=[]
        self.parent=None
    
    def __repr__(self):
        return self.name
        
class FileSystemTree:
    def __init__(self):
        self.root=Node('/')
        self.now=self.root
        
    def mkdir(self,name):
        if name[-1]!='/':   #判断文件名以/结尾
            name+='/'
        node=Node(name)
        self.now.children.append(node)
        node.parent=self.now
        
    def ls(self,name):
        return self.now.children
    
    def cd(self,name):
        if name[-1]!='/':
            name+='/'
        if name=='../':
            self.now=self.now.parent
            return 
        for child in self.now.children:
            if child.name==name:
                self.now=child
                return
        raise ValueError('invalid dir')
    

二叉树：

class BiTreeNode:
    def __init__(self,data):
        self.data=data
        self.lchild=None    #左孩子
        self.rchild=None    #右孩子

 

遍历：

import collections

from collections import deque

class BiTreeNode:
    def __init__(self,data):
        self.data=data
        self.lchild=None    #左孩子
        self.rchild=None    #右孩子
        
def pre_order(root):    #前序遍历
    if root:
        print(root.data,end=',')
        pre_order(root.lchild)
        pre_order(root.rchile)
        
def in_order(root):    #中序遍历
    if root:
        pre_order(root.lchild)
        print(root.data, end=',')
        pre_order(root.rchile)
        
def past_order(root):    #后续遍历
    if root:
        pre_order(root.lchild)
        pre_order(root.rchile)
        print(root.data, end=',')
        
def level_order(root):    #层次遍历
    queue=deque()
    queue.append(root)
    while len(queue)>0:     #队不为空
        node=queue.popleft()
        print(node.data,end=',')
        if node.lchild:
            queue.append(node.lchild)
        if node.rchild:
            queue.append(node.rchild)
            
    

 

 

 

 

插入、查询、删除

from collections import deque

class BiTreeNode:
    def __init__(self,data):
        self.data=data
        self.lchild=None    #左孩子
        self.rchild=None    #右孩子
        self.parent=None

class BST:
    def __init__(self,li=None):
        self.root=None
        if li:
            for val in li:
                self.insert_no_rec(val)

    #递归版本 插入
    def insert(self,node,val):
        if not node:
            node=BiTreeNode(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
        return node

    #非递归版本 插入
    def insert_no_rec(self,val):
        p=self.root
        if not p:
            self.root=BiTreeNode(val)
            return
        while True:
            if val<p.data:
                if p.lchild:
                    p=p.lchild
                else:
                    p.lchild=BiTreeNode(val)
                    p.lchild.parent=p
                    return
            elif val>p.data:
                if p.rchild:
                    p=p.lrchild
                else:
                    p.lrchild=BiTreeNode(val)
                    p.lrchild.parent=p
                    return
            else:
                return

    #递归版本 查询
    def query(self,node,val):
        if not node:
            return None
        if node.data<val:
            return self.query(node.rchild,val)
        elif node.data>val:
            return self.query(node.lchild,val)
        else:
            return node

    #非递归版本 查询
    def query_no_rec(self,val):
        p=self.root
        while p:
            if p.data<val:
                p=p.rchild
            elif p.data>val:
                p=p.lchild
            else:
                return p
        return None

    def pre_order(self,root):  # 前序遍历
        if root:
            print(root.data, end=',')
            self.pre_order(root.lchild)
            self.pre_order(root.rchile)

    def in_order(self,root):  # 中序遍历
        if root:
            self.pre_order(root.lchild)
            print(root.data, end=',')
            self.pre_order(root.rchile)

    def past_order(self,root):  # 后续遍历
        if root:
            self.pre_order(root.lchild)
            self.pre_order(root.rchile)
            print(root.data, end=',')

    def level_order(self,root):  # 层次遍历
        queue = deque()
        queue.append(root)
        while len(queue) > 0:  # 队不为空
            node = queue.popleft()
            print(node.data, end=',')
            if node.lchild:
                queue.append(node.lchild)
            if node.rchild:
                queue.append(node.rchild)

    def __remove_node_1(self,node):
        if not node.parent: #node是叶子节点
            self.root=None
        if node==node.parent.lchild:    #node是他父亲的左孩子
            node.parent.lchild=None
        else:   #右孩子
            node.parent.rchild=None

    def __remove_node_2_1(self,node):
        # node只有一个左孩子
        if not node.parent: #根节点
            self.root=node.lchild
            node.lchild.parent=None
        elif node==node.parent.lchild:
            node.parent.lchild=node.lchild
            node.lchild.parent=node.parent
        else:
            node.parent.rchild = node.lchild
            node.rchild.parent = node.parent

    def __remove_node_2_2(self,node):
        # node只有一个右孩子
        if not node.parent: #根节点
            self.root=node.rchild
        elif node==node.parent.lchild:
            node.parent.lchild=node.rchild
            node.rchild.parent=node.parent
        else:
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent

    def delete(self,val):
        if self.root:   #不是空树
            node=self.query_no_rec(val)
            if not node:    #不存在
                return False
            if not node.lchild and not node.rchild: #叶子节点
                self.__remove_node_1(node)
            elif not node.rchild:   #只有一个左孩子
                self.__remove_node_2_1(node)
            elif not node.lchild:   #只有一个右孩子
                self.__remove_node_2_2(node)
            else:   #两个孩子都有
                min_node=node.rchild
                while min_node.lchild:
                    min_node=min_node.lchild
                node.data=min_node.data
                #删除min_node
                if min_node.rchild:
                    self.__remove_node_2_2(min_node)
                else:
                    self.__remove_node_1(min_node)