python-树与二叉树

树与二叉树

如果你了解linux文件结构(tree命令),它的结构也是一棵树。我们快速看下树涉及到的一些概念:

---

二叉树

了解完树的结构以后，我们来看树结构里一种简单但是却比较常用的数-二叉树。二叉树是一种简单的树，它的每个节点最多只能包含两个孩子，以下都是一些合法的二叉树:

通过上边这幅图再来看几个二叉树相关的概念:

1.节点深度(depth):节点对应的level数字
2.树的高度(height):二叉树的高度就是level数+1,因为level从0开始计算的
3.树的宽度(width):二叉树的宽度指的是包含最多节点的层级的节点数
4.树的size:二叉树的节点总个数

---

一些特殊的二叉树

满二叉树(full binary tree)

如果每个内部节点(非叶节点)都包含两个孩子，就成为满二叉树。下边是一些例子，它可以有多种形状:

完美二叉树(perfect binary tree)

当所有的叶子节点都在同一层就是完美二叉树，毫无间隙填充了h层

完全二叉树(complete binary tree)

当一个高度为h的完美二叉树减少到h-1,并且最底层的槽被毫无间隙地从左到右填充，我们就叫它完全二叉树。下图就是完全二叉树的例子:

二叉树的表示

说了那么多，那么怎么表示一棵二叉树呢？其实你发现会和链表有一些相似之处，
一个节点，然后节点需要保存孩子的指针，
我以构造下边这个二叉树为例子:我们先定义一个类表示节点:

# -*- coding:utf-8 -*-

class BinTreeNode(object):
    def __init__(self,data,left=None,right=None):
        self.data,self.left,self.right = data,left,right

'''
    当然和链表类似，root 节点是我们的入口，于是乎定义一个二叉树

class BinTree(object):
    def __init__(self,root=None):
        self.root = root
'''



'''
    怎么构造上图的二叉树呢，我自己定义了一种方法,
    首先我们输入节点信息，仔细看下边代码，
    叶子节点的left和right都是None,并且只有一个根节点A:
'''

node_list = [
    {'data':'A','left':'B', 'right':'C', 'is_root':True},
    {'data':'B','left':'D', 'right':'E', 'is_root':False},
    {'data':'D','left':None,'right':None,'is_root':False},
    {'data':'E','left':'H', 'right':None,'is_root':False},
    {'data':'H','left':None,'right':None,'is_root':False},
    {'data':'C','left':'F', 'right':'G', 'is_root':False},
    {'data':'F','left':None,'right':None,'is_root':False},
    {'data':'G','left':'I', 'right':'J', 'is_root':False},
    {'data':'I','left':None,'right':None,'is_root':False},
    {'data':'J','left':None,'right':None,'is_root':False},

]

#然后我们给BinTreeNode定义一个 build_from 方法:

class BinTree(object):
    def __init__(self,root=None):
        self.root = root

    @classmethod
    def build_from(cls,node_list):
        '''
            通过节点信息构造二叉树
            第一次遍历我们构造 node 节点
            第二次遍历我们给root和孩子赋值
            最后我们用 root 初始化这个类并返回一个对象

            param node_list:{'data':'A','left':None,'right':None,
            'is_root':False}
        '''

        node_dict = {}
        for node_data in node_list:
            data = node_data['data']
            node_dict[data] = BinTreeNode(data)
        for node_data in node_list:
            data = node_data['data']
            node = node_dict[data]
            if node_data['is_root']:
                root = node
            node.left = node_dict.get(node_data['left'])
            node.right = node_dict.get(node_data['right'])

        return cls(root)

btree = BinTree.build_from(node_list)

二叉树的遍历

不知道你有没有发现,二叉树其实是一种递归结构,
因为单独拿出来一个subtree子树出来,其实它还是一棵树。
那遍历它就很方便了，我们可以直接用递归的方式来遍历它。
但是当处理顺序不同的时候，树又分为三种遍历方式:

1.先(根)序遍历:先处理根，之后是左子树，然后是右子树
2.中(根)序遍历:先处理左子树，之后是根，最后是右子树
3.后(根)序遍历:先处理左子树，之后是右子树，最后是根

我们来实现一下:

# -*- coding:utf-8 -*-

class BinTreeNode(object):
    def __init__(self,data,left=None,right=None):
        self.data,self.left,self.right = data,left,right

class BinTree(object):
    def __init__(self,root=None):
        self.root = root

    '''
        在def前面加上@classmethod，这种类方法的一个特点就是可以通过类名去调用，
        但是也必须传递一个参数，一般用cls表示class，表示可以通过类直接调用
    '''
    @classmethod
    def build_from(cls,node_list):
        '''
            通过节点信息构造二叉树
            第一次遍历我们构造 node 节点
            第二次遍历我们给root和孩子赋值
            最后我们用 root 初始化这个类并返回一个对象

            param node_list:{'data':'A','left':None,'right':None,
            'is_root':False}
        '''

        node_dict = {}
        for node_data in node_list:
            data = node_data['data']
            node_dict[data] = BinTreeNode(data)
        for node_data in node_list:
            data = node_data['data']
            node = node_dict[data]
            if node_data['is_root']:
                root = node
            node.left = node_dict.get(node_data['left'])
            node.right = node_dict.get(node_data['right'])

        return cls(root)

    def preorder_trav(self,subtree):
        '''
            先(根)序遍历
        '''
        if subtree is not None:
            print(subtree.data)         #递归函数里先处理根
            self.preorder_trav(subtree.left)    #递归处理左子树
            self.preorder_trav(subtree.right)   #递归处理右子树

node_list = [
    {'data':'A','left':'B', 'right':'C', 'is_root':True},
    {'data':'B','left':'D', 'right':'E', 'is_root':False},
    {'data':'D','left':None,'right':None,'is_root':False},
    {'data':'E','left':'H', 'right':None,'is_root':False},
    {'data':'H','left':None,'right':None,'is_root':False},
    {'data':'C','left':'F', 'right':'G', 'is_root':False},
    {'data':'F','left':None,'right':None,'is_root':False},
    {'data':'G','left':'I', 'right':'J', 'is_root':False},
    {'data':'I','left':None,'right':None,'is_root':False},
    {'data':'J','left':None,'right':None,'is_root':False},

]
btree = BinTree.build_from(node_list)
btree.preorder_trav(btree.root)     #输出 A,B,D,E,H,C,F,G,I,J

先(根)序遍历
先遍历左子树，再遍历右子树

---

反转二叉树