二叉树线索化 Python实现

二叉树线索化 Python实现

二叉树线索化

二叉树线索化对二叉树进行线性化操作，使其每一个结点在线性化序列中有且只有一个直接前驱和直接后继，其中第一个结点直接前驱和最后一个结点直接后继置空，建立规则如下

• 若当前结点有左子树，则left域为左孩子，leftTag域为False；否则指向其直接前驱结点，leftTag域为True
• 若当前结点有右子树，则right域为右孩子，rightTag域为False；否则指向其直接后继结点,rightTag域为True

下述实现以二叉搜索树为例

线索化

记录之前访问的结点引用，从根结点开始，先线索化左子树，递归直到最左的结点，其左子树依然为None，回溯到上一层，previous更新为当前结点，递归到右子树，线索化右子树过程类似，回溯直到根结点，递归进入根结点右子树，线索化结束后即完成整棵BST的线索化

def threading(self, node):

    if node != None:
        # threading the left subtree
        self.threading(node.left)
        if node.left == None:
            # if left field is None
            # left field point to previous node
            node.left = self.previous
            node.leftTag = True

        if self.previous != None and self.previous.right == None:
            # if right field of previous node is None
            # which point to current node
            self.previous.right = node
            self.previous.rightTag = True

        # update previous node to current node
        self.previous = node
        # threading the right subtree
        self.threading(node.right)

实现代码

class Node():
    '''
        Description:
            Node of tree
        Attributes:
            data:
                the data of node
            left:
                reference of left subtree or previous node
            right:
                reference of right subtree or successive node
            leftTag:
                True, if left field is the reference of previous node
                False, if left field is the reference of left subtree
            rightTag:
                True, if right field is the reference of successive node
                False, if right field is the reference of right subtree
    '''
    def __init__(self, data, left, right):
        self.data = data
        self.left = left
        self.right = right

        self.leftTag = False
        self.rightTag = False

class BinarySearchTree():

    '''
        Description:
            binary search tree
        Attributes:
            root:
                the reference of binary-search-tree root node
            previous:
                the reference of current node's previous node
    '''
    def __init__(self):
        self.root = None
        self.previous = None


    '''
        Description:
            insert new node into BST according BST rules
        Args:
            data:
                the data of new node
            node:
                current node reference
        Returns:
            reference of current node or new node
    '''
    def insertIntoTree(self, data, node):
        if node == None:
            return Node(data, None, None)
        elif data > node.data:
            node.right = self.insertIntoTree(data, node.right)
        elif data < node.data:
            node.left = self.insertIntoTree(data, node.left)

        return node

    '''
        Description:
            insert into BST, recursively
        Args:
             data:
                the data of new node
        Returns:
            None
    '''

    def insert(self, data):
        self.root = self.insertIntoTree(data, self.root)


    '''
        Description:
            Inoder Traverse
        Args:
            node:
                current node reference
        Returns:
            None
    '''

    def inorderTraverse(self, node):
        if node.left != None:
            self.inorderTraverse(node.left)
        print(node.data, end = " ")
        if node.right != None:
            self.inorderTraverse(node.right)

    '''
        Description:
            output the ascending sequence of BST
        Args:
            None
        Returns:
            None
    '''

    def ascendingSequence(self):
        self.inorderTraverse(self.root)

    '''
        Description:
            BST threading
        Args:
            node:
                current node reference
        Returns:
            None
    '''

    def threading(self, node):

        if node != None:
            # threading the left subtree
            self.threading(node.left)
            if node.left == None:
                # if left field is None
                # left field point to previous node
                node.left = self.previous
                node.leftTag = True

            if self.previous != None and self.previous.right == None:
                # if right field of previous node is None
                # which point to current node
                self.previous.right = node
                self.previous.rightTag = True

            # update previous node to current node
            self.previous = node
            # threading the right subtree
            self.threading(node.right)
            
    '''
        Description:
            traverse after BST has been threaded only by the right field
        Args:
            None
        Returns:
            None
    '''
    def threadingTraverse(self):
        node = self.root
        while node.left != None:
            node = node.left

        while node != None:
            print(node.data, end = " ")
            node = node.right


if __name__ == "__main__":
    binarySearchTree = BinarySearchTree()
    values = [2, 0, 8, 24]
    for value in values:
        binarySearchTree.insert(value)
    binarySearchTree.ascendingSequence()
    binarySearchTree.threading(binarySearchTree.root)
    print()
    binarySearchTree.threadingTraverse()

测试结果

0 2 8 24
0
2
8
24

鸣谢

数据结构（C语言版）

最后

• 由于博主水平有限，不免有疏漏之处，欢迎读者随时批评指正，以免造成不必要的误解！