数据结构与算法-二叉树和排序二叉树

二叉树

• 根节点
  • 柱状结构最上层的一个节点
• 叶子节点
  • 左叶子节点
  • 右叶子节点
• 完整的子树
  • 是由根节点，左右叶子节点组成
• 非完整的子树
  • 根节点，左叶子节点
  • 根节点，右叶子节点
  • 根节点
• 特性：二叉树中的任意一个节点都可以被视为另一颗子树的根节点
  • 如果我们想要区分不同的子树，使用根节点作为区分的标准。

# 创建节点类
class Node():
    def __init__(self,item):
        self.item = item
        self.left = None
        self.right = None

        
# 创建一棵树
class Tree():
    def __init__(self): # 构建一颗空树
        self.root = None # 链头，指向最上边的根节点
        
    def addNode(self, item):
        node = Node(item)
        # 如果self.root指向为，则是一颗空树
        if self.root == None:
            self.root = node
            return
        
        # 树为非空
        cur = self.root
        q = [cur]
        while True:
            pop_node = q.pop(0) # 将第一个节点取出
            if pop_node.left == None: # 判断这个节点左边是不是为空
                pop_node.left = node  # 如果为空就将数据添加进去
                break  # 添加进去数据就结束循环
            else:
                q.append(pop_node.left) # 如果不为空，就把它加到列表当中                
            if pop_node.right == None: # 判断这个节点右边是不是为空
                pop_node.right = node   # 如果为空就将数据添加进去
                break  # 添加进去数据就结束循环
            else:
                q.append(pop_node.right) # 如果不为空，就把它加到列表当中
                
    # 广度遍历，遍历整棵树            
    def travel(self):
        cur = self.root
        q = [cur]
        while q:
            pop_node = q.pop(0)
            print(pop_node.item)
            if pop_node.left != None:
                q.append(pop_node.left)
            if pop_node.right != None:
                q.append(pop_node.right)


tree = Tree()
l = [1,2,3,4,5,6]
for i in l:
    tree.addNode(i)
tree.travel()

1
2
3
4
5
6

二叉树的遍历

• 广度遍历
  • 自上而下逐层遍历节点
• 深度遍历：基于子树遍历。可以将前中后序遍历以此作用在不同的子树中即可。每一颗子树中都会有一个根节点。
  • 竖向遍历的方式
  • 方式：以此作用在每一个子树
    • 前序：根左右
    • 中序：左根右
    • 后序：左右根

 　　　　

 

class Node():
    def __init__(self, item):
        self.item = item
        self.right = None
        self.left = None
        

class Tree():
    def __init__(self):
        self.root = None
        
    def addNode(self, item):
        node = Node(item)
        if self.root == None:
            self.root = node
            return
            
        cur = self.root
        q = [cur]
        while True:
            pop_node = q.pop(0)
            if pop_node.left != None:
                q.append(pop_node.left)
            else:
                pop_node.left = node
                break
                
            if pop_node.right != None:
                q.append(pop_node.right)
            else:
                pop_node.right = node
                break
    
    # 深度遍历：前序遍历：根左右
    def forward(self, root): # root表示不同子树的根节点
        # 结束递归的条件
        if root == None:  # 结束标志，如果根节点为空就结束递归
            return
        print(root.item) # 根
        self.forward(root.left) # 左 运用递归 
        self.forward(root.right) # 右
        
    # 深度遍历：中序遍历：左根右
    def middle(self,root):
        if root == None:
            return
        self.middle(root.left) # 左
        print(root.item) # 根
        self.middle(root.right) # 右
        
    # 深度遍历：后序遍历：左右根
    def back(self, root):
        if root == None:
            return
        self.back(root.left) # 左
        self.back(root.right) # 右
        print(root.item) # 根


tree = Tree()
l = [1,2,3,4,5,6]
for i in l:
    tree.addNode(i)
tree.forward(tree.root)  # 1,2,4,5,3,6
tree.middle(tree.root)  # 4,2,5,1,6,3
tree.back(tree.root)  # 4,5,2,6,3,1

排序二叉树

• 排序二叉树和上述普通二叉树对应的插入节点的方式是截然不同。正是由于排序二叉树独有的插入节点的方式，才可以实现基于二叉树进行排序。
• 插入方式：从根部开始比节点大往右插，比节点小往左插 (使用深度遍历中的中序遍历可以实现对数据的排序)

　　　　

class Node():
    def __init__(self, item):
        self.item = item
        self.right = None
        self.left = None

        
class SortTree():
    def __init__(self):
        self.root = None
        
    def add(self, item):
        node = Node(item)
        if self.root == None:
            self.root = node
            return
        cur = self.root
        while True:
            if item < cur.item: # 如果插入节点的值小于根节点，向左侧插入
                if cur.left == None:
                    cur.left = node
                    break
                else:# 插入的左侧不为空
                    cur = cur.left
            else: # 向右侧插入
                if cur.right == None:
                    cur.right = node
                    break
                else: # 插入右侧不为空
                    cur = cur.right
                
    def middle(self, root):
        if root == None:
            return
        self.middle(root.left)
        print(root.item)
        self.middle(root.right)

tree = SortTree()
l = [8,9,3,7,2,6,4]
for i in l:
    tree.add(i)
tree.middle(tree.root)    

2
3
4
6
7
8
9