二叉数 任意数

二叉数;

二叉树在图论中是这样定义的：

二叉树是一个连通的无环图，并且每一个顶点的度不大于3。

有根二叉树还要满足根结点的度不大于2。有了根结点之后，

每个顶点定义了唯一的父结点，和最多2个子结点。然而，没

有足够的信息来区分左结点和右结点。如果不考虑连通性，允

许图中有多个连通分量，这样的结构叫做森林。

定义编辑；

中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树

若二叉树为空则结束返回，

否则：

（1）中序遍历左子树

（2）访问根结点

（3）中序遍历右子树

     如右图所示二叉树

     中序遍历结果：DBEAFC

如下例;

class BTree:

    root=None

    class Node:

        data=None

        left=None

        right=None

        def zhongxu(self):

            if self.left is not None:

                self.left.zhongxu()

            print(self.data)

            if self.right is not None:

                self.right.zhongxu()

        def add(self,node):

            if self.data > node.data:

                if self.left is None:

                    self.left=node

                else:

                    self.left.add(node)

            if self.data < node.data:

                if self.right is None:

                    self.right=node

                else:

                    self.right.add(node)

    def add(self,data):

        node=self.Node()

        node.data=data

        if self.root is None:

            self.root=node

        else:

            self.root.add(node)

    def zhongxu(self):

        self.root.zhongxu()

if __name__ == '__main__':

    btree = BTree()

    btree.add(13)

    btree.add(7)

    btree.add(21)

    btree.add(11)

    btree.add(17)

    btree.add(9)

    btree.add(14)

    btree.add(5)

    btree.add(3)

    btree.add(10)

    btree.zhongxu()

===========================================

任意数：

         例：

                    学校

  商学院     法学院    电子学院       计算机学院

                                  软件   网络   数据

                                      网1 网2 网3

1.根据当前节点 获取父节点

2.根据当前节点 获取所有子节点

3.根据当前节点 获取所有祖先节点

4.根据当前节点 获取所有子孙节点

5.根据当前节点 获取所有兄弟节点

    如下：

class Tree:

    childToParent=None

    parentToChildren=None

    def add(self,parent,child):

        if self.childToParent  is None:  #如果childToParent 是空的话：

            self.childToParent={child:parent} #转集合

        else:

            self.childToParent[child]=parent

        if self.parentToChildren is None:

            self.parentToChildren={parent:[]} #父亲对应 多个孩子

        children=self.parentToChildren.get(parent,[])

        if len(children)==0:

            self.parentToChildren[parent]=children

        children.append(child) # 直接追加

    def getParent(self,child):

        return self.childToParent.get(child,'没有父亲的节点')

    def getChildren(self,parent):

        return self.parentToChildren.get(parent,'没下级')

    def getZuXian(self,zisun):

# 思想就是 递归问爹

# 1.可以获取上一级 getParent

# 2.如果我能够让上一级返回的数据在 执行 

# getParent 依次执行 直到没有上级终止              

   parent = self.getParent(zisun)

      if parent is None:

         return []

      zupu= self.getZuXian(parent)

      zupu.append(parent)

      return zupu

def zisun(self,zs,zu):

    # 1.得到当前节点的孩子

    # 2。遍历当前节点的孩子，每一个孩子去得到他们的孩

    children = self.getChildren(zu)

    if children == '没下级':

        return

    for c in children:

        self.zisun(zs,c)

    zs.extend(children)

def getSibling(self,s):

    parent = self.getParent(sibling)

    children = self.getChildren(parent)

    children.remove(sibling)

    return  children

if __name__=='__main__':

    tree=Tree()

    tree.add(None,'学校')

    tree.add('学校','商学院 ')

    tree.add('学校','法学院')

    tree.add('学校','电子学院 ')

    tree.add('学校','计算机学院')

    tree.add('计算机学院','软件')

    tree.add('计算机学院','网络')

    tree.add('计算机学院','数据')

    tree.add('网络','网1')

    tree.add('网络','网2')

    tree.add('网络','网3')

# 1.根据当前节点获取父节点  网路

    child='网络'

    parent=tree.getParent(child)

    print('{1}的上级是：{0}'.format(parent,child))

# 2.根据当前节点 获取所有子节点

    parent = '计算机学院'

    children = tree.getChildren(parent)

    print('{0}的子级是:{1}'.format(parent,children))

# 3.根据当前节点 获取所有祖先节点 ancestor

    zisun = '网3'

    zuxian=tree.getZuXian(zisun)

    print('{0}的祖先是:{1}'.format(zisun, zuxian))

# 4.根据当前节点 获取所有子孙节点

    zu='学校'

    zs=[]

    tree.zisun(zs,zu)

    print('{0}的子孙是：{1}'.format(zu,zs))

 # 5.根据当前节点获取所有兄弟节点

    sibling = '法学院'

    rs = tree.getSibling(sibling)

    print('{0}的兄弟是：{1}'.format(sibling, rs))