Binary tree data structure and the binary tree sorting

Binary Tree

• Root
• Left leaf node
• Right leaf node
• Subtree
• height

# Binary tree
 class the Node (): 
    DEF __init __ (Self, Item): 
        self.item = Item 
        self.left = None 
        self.right = None 


class Tree (): 
    # Create an empty tree 
    DEF __init __ (Self): 
        self.root = none 

    DEF the addNode (Self, Item): 
        Node = the Node (Item) 
        # If the tree is empty 
        IF self.root == none: 
            self.root = Node
             return 
        # binary tree is not empty 
        CUR = self.root 
        Q= [CUR] 
        # queue node continually adding node out 
        the while Q: 
            n- = q.pop ( 0 )
             IF n.left == None: 
                n.left = Node
                 BREAK 
            the else : 
                q.append (n.left) 

            IF n- == .right None: 
                n.right = Node
                 BREAK 
            the else : 
                q.append (n.right) 

    # breadth traversal 
    DEF Travel (Self): 
        CUR = self.root 
        Q = [CUR]
        the while Q: 
            n- = q.pop ( 0 ) 
            Print (n.item) 
            IF n.left =! None: 
                q.append (n.left) 
            IF n.right =! None: 
                q.append (n.right) 

    # depth traversal: before after refer to the position of the root node 
    before the # sequence: about root 
    DEF frontTravel (Self, the root): 
        # empty 
        IF the root == None:
             return 
        Print (root.item) 
        self.frontTravel (root.left) 
        self.frontTravel (root.right) 
    # in order: left and right root 
    DEF midTravel (Self, the root): 
        IF the root == None:
            return
        self.midTravel(root.left)
        print(root.item)
        self.midTravel(root.right)
    # 后序：左右根
    def afterTravel(self,root):
        if root==None:
            return
        self.afterTravel(root.left)
        self.afterTravel(root.right)
        print(root.item)

 

tree=Tree()
tree.addNode(1)
tree.addNode(2)
tree.addNode(3)
tree.addNode(4)
tree.addNode(5)
tree.addNode(6)
tree.addNode(7)
# tree.travel()
tree.midTravel(tree.root)

 

 

Binary tree traversal

• Breadth traversal: layer by layer traversal
• Depth traversal: it refers to the front position of the root node
  • Preamble: about Root
  • In order: left and right root
  • After the sequence: about Root

 

Sorting binary tree

• Insert Node criteria: First, insert the root node. When you insert other nodes, the need and compare the root node, inserted into the tree on the left side of the root node is smaller than the right side, insert a large tree

 

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

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

    def midTravel(self,root):
        # print(111)
        if root==None:
            return
        # 左根右
        self.midTravel(root.left)
        print(root.item)
        self.midTravel(root.right)

    def insertNode(self,item):
        node=Node(item)
        cur=self.root
        if self.root == None:

            self.root=node
            return
        # 树非空
        while True:
            if cur.item>node.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




t = SortTree()
t.insertNode(3)
t.insertNode(8)
t.insertNode(3)
t.insertNode(1)
t.insertNode(1)

t.midTravel(t.root)