2 数据结构与算法初步 二叉树与排序二叉树

数据结构与算法初步

1 二叉树与排序二叉树

1.1 二叉树

1.1.1 二叉树介绍

二叉树，Binary tree，是指树中节点的度不大于2的有序树结构。

节点：包含一个数据元素及若干指向子树分支的信息；
节点的度：一个节点拥有子树的数目称为节点的度；
根节点：树状结构最上层的一个节点；
叶子节点：包括左叶子节点和右叶子节点；
完整的子树：由根节点，左叶子节点和右叶子节点组成的子树；
非完整的子树：根节点 或者 根节点+左叶子节点 或者 根节点+右叶子节点。

二叉树中的任意一个节点都可以被视为另一颗子树的根节点。
如果需要区分不同的子树，可以使用根节点作为区分的标准。

（a）空二叉树
（b）只有一个根结点的二叉树
（c）只有左子树
（d）只有右子树
（e）完全二叉树

1.1.2 代码实现

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


class Tree():
    def __init__(self):  # 构建一颗空树
        self.root = None  # 指向根节点，空树的根节点为None。

    def add_node(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 traval(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()
tree.add_node(1)
tree.add_node(2)
tree.add_node(3)
tree.add_node(4)
tree.add_node(5)
tree.add_node(6)
tree.traval()

1.1.3 二叉树的遍历

1.1.3.1 广度遍历

广度遍历是自上而下逐层遍历二叉树的节点。

1.1.3.2 深度遍历

深度遍历是以子树为单位进行遍历，遍历方式包括前序遍历、中序遍历和后序遍历。

以子树为单位，
前序遍历：根左右
中序遍历：左根右
后序遍历：左右根

以递归的方式实现。

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

class Tree:
    def __init__(self):
        self.root = None

    def add_node(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)

1.2 排序二叉树

1.2.1 介绍

排序二叉树，也称为二叉排序树，Binary Sort Tree。

1. 若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
2. 若右子树不空，则右子树上所有结点的值均大于它的根结点的值；
3. 左、右子树也分别为二叉排序树；
4. 没有键值相等的结点。

1.2.2 代码实现

对排序二叉树进行中序遍历，可以实现排序。

class SortTree:
    def __init__(self):
        self.root = None

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

    def middle(self, root):
        if root is None:
            return
        self.middle(root.left)
        print(root.item)
        self.middle(root.right)

test_list = [3, 8, 5, 7, 6, 2, 1]
tree = SortTree()
for item in test_list:
    tree.add(item)
tree.middle(tree.root)