算法学习之树与算法

树结构

树结构：

关键组成：根节点，叶子节点。
成员相对关系：父节点，子节点，兄弟节点。

树的遍历：

按照广度遍历：分层遍历，顺序为从上到下，从左到右。

按照深度遍历：根据递归顺序，分为三种，前序即按照中、左、右的顺序，中序即按照左、中、右的顺序，后序按照左、右、中的顺序。

算法实现

节点类定义：

class Node(object):
    def __init__(self, item, litem=None, ritem=None):
        self.item = item
        self.litem = litem
        self.ritem = ritem

树类定义：

class trees(object):
    def __init__(self, nodes=None):
        self.root = nodes
    def add(self, item):
        node = Node(item)
        if self.root == None:
            self.root = node
            return
        que = [self.root]
        while que:
            cur = que.pop(0)
            if cur.litem == None:
                cur.litem = node
                return
            if cur.ritem == None:
                cur.ritem = node
                return
            que.append(cur.litem)
            que.append(cur.ritem)
    def showalls(self):
        if self.root == None:
            return
        que = [self.root]
        while que:
            cur = que.pop(0)
            print(cur.item, end=' ')
            if cur.litem != None:
                que.append(cur.litem)
            if cur.ritem != None:
                que.append(cur.ritem)
    def befores(self, node):
        if node == None:
            return
        print(node.item, end=' ')
        self.befores(node.litem)
        self.befores(node.ritem)
    def middles(self, node):
        if node == None:
            return
        self.middles(node.litem)
        print(node.item, end=' ')
        self.middles(node.ritem)
    def afters(self, node):
        if node == None:
            return
        self.afters(node.litem)
        self.afters(node.ritem)
        print(node.item, end=' ')