python与和数据结构练习---树的简单实现

基于python 的列表很容易实现了一个简单的树结构以及遍历

声明了一个对象类来建立树，并赋予一些方法进行节点操作，如遍历输出、节点查找等

见代码

class Tree_node(object):
    def __init__(self,data,parent=None):
        self.parent = parent
        self.data = data
        self.children = []
        self.isRoot = self.is_root()
    
    def is_root(self):
        """判断是否为根节点
        """
        if self.parent != None:
            return False
        else:
            return True
    def get_root(self):
        """返回根节点node
        """
        if self.is_root():
            return self
        else:
            return self.parent.get_root()
    def append(self,child):
        """向当前节点加入子节点
        """
        child.set_parent(self)
        self.children.append(child)
        self.isRoot = self.is_root()
    def delete(self, node):
        """从子节点中删除节点
        """
        if node in self.children:
            self.children.remove(node)
        else:
            return False

    def set_parent(self,parent):
        """设置当前节点的父节点
        """
        self.parent = parent
        self.isRoot = self.is_root()
    def index(self,node):
        """返回子节点的索引
        """
        if node in self.children:
            return self.children.index(node)
        else:
            return False
    def print_children(self):
        """遍历输出子节点data
        """
        print(self.data)
        if len(self.children) > 0:
            for child in self.children:
                child.print_children()
    def depth(self):
        """以当前节点为root返回深度
        """
        d = 0
        if len(self.children) > 0:
            d += 1
            if len(self.children[0].children) > 0:
                d += self.children[0].depth()
        return d

    def num_of_children(self):
        """返回子节点数量
        """
        return len(self.children)
    def get_child(self,node):
        """查找子节点,返回相对位置，否则返回 False,
        """
        if node in self.children:
            return self.children.index(node)
        else:
            return False
 

    def next(self):
        """返回相邻节点node,失败返回 False
        """
        if self.isRoot == False:
            if self.parent.num_of_children() > self.parent.children.index(self) + 1:
                return self.parent.children[self.parent.children.index(self) + 1]
            else:
                return False

        else:
            return False

    def find(self,data):
        """寻找子树节点是否包含有data，找到返回第一个节点node，失败返回False
        """
        if self.data == data:
            return self
        else:
            if len(self.children) > 0:
                for i in range(len(self.children)):
                    return self.children[i].find(data)

            return False

    def find_node(self,node):
        """寻找子树节点是否包含有节点，找到返回节点位置(depth,index)，失败返回False
        """
        if self == node:
            return self.depth(),self.parent.get_child(self)

        else:
            if len(self.children) > 0:
                for i in range(len(self.children)):
                    return self.children[i].find_node(node)

            return False


def generate_nodes(node,max,n=0):
    """生成叶结点层
    """
    node_ = node
    if len(node.children) < max:

        t = Tree_node(n+1)
        node_.append(t)
        #t.set_parent(node_)
        n += 1
        return generate_nodes(node_,max,n)
    else:
        return node_


def generate_trunks(node,max,n=0):
    """生成枝干节点
    """
    node_ = node
    root = node_.get_root()
    t = Tree_node(n+1,node_)
    d = root.depth()
    if d < max:
        node_.append(t)
        n += 1
        return generate_trunks(t,max,n)
    else:
        return t.get_root()



if __name__ == '__main__':

    t0 = Tree_node(0)

    t = generate_trunks(t0,3)
    t.print_children()
    print('树深度: {}'.format(t.depth()))
    print(t.find(3))
    print(t.find_node(t.children[0]))