樹由n個節點組成的集合，可以遞迴定義資料結構，如果n=0就是空樹
如果n>那麼有樹

概念

• 根節點、葉子節點
• 樹的深度（高度）
• 樹的度
• 孩子節點、父節點
• 子樹

二叉樹-遍歷

# 樹型圖示意
            E
        A        G
          C         F
       B     D

• 前序遍歷：EACBDGF
• 中序遍歷：ABCDEGF
• 後序遍歷：BDCAFGE
• 層次遍歷：EAGCFBD

二叉搜尋樹

所有節點左邊都比右邊小的情況下

二叉搜尋樹操作： 查詢、插入、刪除

class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None  # 左孩子
        self.rchild = None  # 右孩子
        self.parent = None


class BST:
    def __init__(self, li=None):
        self.root = None
        if li:
            for
 
 val in li:
                self.insert_no_rec(val)

    def insert(self, node, val):
        """插入"""
        if not node:
            node = BiTreeNode(val)
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node
        elif val >
 
 node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node
        return node

    def insert_no_rec(self, val):
        p = self.root
        if not p:  # 空樹
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:  # 左孩子不存在
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    return
            else:
                return

    def query(self, node, val):
        if not node:
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

    def query_no_rec(self, val):
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None

    def pre_order(self, root):
        if root:
            print(root.data, end=',')
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self, root):
        if root:
            self.in_order(root.lchild)
            print(root.data, end=',')
            self.in_order(root.rchild)

    def post_order(self, root):
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end=',')

    def __remove_node_1(self, node):
        # 情況1：node是葉子節點
        if not node.parent:
            self.root = None
        if node == node.parent.lchild:  # node是它父親的左孩子
            node.parent.lchild = None
        else:  # 右孩子
            node.parent.rchild = None

    def __remove_node_21(self, node):
        # 情況2.1：node只有一個左孩子
        if not node.parent:  # 根節點
            self.root = node.lchild
            node.lchild.parent = None
        elif node == node.parent.lchild:
            node.parent.lchild = node.lchild
            node.lchild.parent = node.parent
        else:
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    def __remove_node_22(self, node):
        # 情況2.2：node只有一個右孩子
        if not node.parent:
            self.root = node.rchild
        elif node == node.parent.lchild:
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else:
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent

    def delete(self, val):
        if self.root:  # 不是空樹
            node = self.query_no_rec(val)
            if not node:  # 不存在
                return False
            if not node.lchild and not node.rchild:  # 1. 葉子節點
                self.__remove_node_1(node)
            elif not node.rchild:  # 2.1 只有一個左孩子
                self.__remove_node_21(node)
            elif not node.lchild:  # 2.2 只有一個右孩子
                self.__remove_node_22(node)
            else:  # 3. 兩個孩子都有
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                # 刪除min_node
                if min_node.rchild:
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)


tree = BST([1, 4, 2, 5, 3, 8, 6, 9, 7])
tree.in_order(tree.root)
print("")

tree.delete(4)
tree.delete(1)
tree.delete(8)
tree.in_order(tree.root)

AVL樹

AVL樹是自平衡的二叉搜尋樹

根的左右樹高度只差絕對值不能超過1

根的左右子樹都是平衡樹

# 旋轉插入
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# Date: 2018/3/24

from bst import BiTreeNode, BST

class AVLNode(BiTreeNode):
    def __init__(self, data):
        BiTreeNode.__init__(self, data)
        self.bf = 0

class AVLTree(BST):
    def __init__(self, li=None):
        BST.__init__(self, li)

    def rotate_left(self, p, c):
        s2 = c.lchild
        p.rchild = s2
        if s2:
            s2.parent = p

        c.lchild = p
        p.parent = c

        p.bf = 0
        c.bf = 0
        return c

    def rotate_right(self, p, c):
        s2 = c.rchild
        p.lchild = s2
        if s2:
            s2.parent = p

        c.rchild = p
        p.parent = c

        p.bf = 0
        c.bf = 0
        return c

    def rotate_right_left(self, p, c):
        g = c.lchild

        s3 = g.rchild
        c.lchild = s3
        if s3:
            s3.parent = c
        g.rchild = c
        c.parent = g

        s2 = g.lchild
        p.rchild = s2
        if s2:
            s2.parent = p
        g.lchild = p
        p.parent = g

        # 更新bf
        if g.bf > 0:
            p.bf = -1
            c.bf = 0
        elif g.bf < 0:
            p.bf = 0
            c.bf = 1
        else: # 插入的是g
            p.bf = 0
            c.bf = 0
        return g

    def rotate_left_right(self, p, c):
        g = c.rchild

        s2 = g.lchild
        c.rchild = s2
        if s2:
            s2.parent = c
        g.lchild = c
        c.parent = g

        s3 = g.rchild
        p.lchild = s3
        if s3:
            s3.parent = p
        g.rchild = p
        p.parent = g

        # 更新bf
        if g.bf < 0:
            p.bf = 1
            c.bf = 0
        elif g.bf > 0:
            p.bf = 0
            c.bf = -1
        else:
            p.bf = 0
            c.bf = 0
        return g



    def insert_no_rec(self, val):
        # 1. 和BST一樣，插入
        p = self.root
        if not p:  # 空樹
            self.root = AVLNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:  # 左孩子不存在
                    p.lchild = AVLNode(val)
                    p.lchild.parent = p
                    node = p.lchild # node 儲存的就是插入的節點
                    break
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = AVLNode(val)
                    p.rchild.parent = p
                    node = p.rchild
                    break
            else:   # val == p.data
                return

        # 2. 更新balance factor
        while node.parent:  # node.parent不空
            if node.parent.lchild == node: # 傳遞是從左子樹來的，左子樹更沉了
                #更新node.parent的bf -= 1
                if node.parent.bf < 0: # 原來node.parent.bf == -1, 更新後變成-2
                    # 做旋轉
                    # 看node哪邊沉
                    g = node.parent.parent # 為了連線旋轉之後的子樹
                    x = node.parent  # 旋轉前的子樹的根
                    if node.bf > 0:
                        n = self.rotate_left_right(node.parent, node)
                    else:
                        n = self.rotate_right(node.parent, node)
                    # 記得：把n和g連起來
                elif node.parent.bf > 0: # 原來node.parent.bf = 1，更新之後變成0
                    node.parent.bf = 0
                    break
                else: # 原來node.parent.bf = 0，更新之後變成-1
                    node.parent.bf = -1
                    node = node.parent
                    continue
            else: # 傳遞是從右子樹來的，右子樹更沉了
                #更新node.parent.bf += 1
                if node.parent.bf > 0:  # 原來node.parent.bf == 1, 更新後變成2
                    # 做旋轉
                    # 看node哪邊沉
                    g = node.parent.parent # 為了連線旋轉之後的子樹
                    x = node.parent  # 旋轉前的子樹的根
                    if node.bf < 0: # node.bf = 1
                        n = self.rotate_right_left(node.parent, node)
                    else:   # node.bf = -1
                        n = self.rotate_left(node.parent, node)
                    # 記得連起來
                elif node.parent.bf < 0: # 原來node.parent.bf = -1，更新之後變成0
                    node.parent.bf = 0
                    break
                else: # 原來node.parent.bf = 0，更新之後變成1
                    node.parent.bf = 1
                    node = node.parent
                    continue

            # 連結旋轉後的子樹
            n.parent = g
            if g: # g不是空
                if x == g.lchild:
                    g.lchild = n
                else:
                    g.rchild = n
                break
            else:
                self.root = n
                break


tree = AVLTree([9,8,7,6,5,4,3,2,1])

tree.pre_order(tree.root)
print("")
tree.in_order(tree.root)