数据结构----二叉树Tree和排序二叉树

二叉树

　　节点定义

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

　　二叉树定义

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

     def add(self, item):
         node = Node(item)
         # 空树直接插入
         if self.root == None:
             self.root = node

         else:
             cur_list = [self.root]
             while True:
                 # 定义一个列表存储当前遍历节点
                 cur_node = cur_list.pop(0)

                 # 当前节点左孩子为空直接插入，否则将该左孩子追加到遍历列表，以便当前节点右孩子也为非空时继续遍历下一层
                 if cur_node.left == None:
                     cur_node.left = node
                     break
                 else:
                     cur_list.append(cur_node.left)
                 # 当前节点右孩子为空直接插入，否则将该右孩子追加到遍历列表，以便继续遍历下一层
                 if cur_node.right == None:
                     cur_node.right = node
                     break
                 else:
                     cur_list.append(cur_node.right)

     # 广度遍历
     def travel(self):
         if not self.root:
             print(None)
             return None
         q = [self.root]
         while q:
             cur_node = q.pop(0)
             print(cur_node.item)
             if cur_node.left:
                 q.append(cur_node.left)
             if cur_node.right:
                 q.append(cur_node.right)

     # 深度遍历----前序遍历DLR
     def dlr(self, node):
         if node == None:
             return
         print(node.item)
         self.dlr(node.left)
         self.dlr(node.right)

     # 深度遍历----中序遍历LDR
     def ldr(self, node):
         if node == None:
             return
         self.ldr(node.left)
         print(node.item)
         self.ldr(node.right)

     # 深度遍历----后序遍历LRD
     def lrd(self, node):
         if node == None:
             return
         self.lrd(node.left)
         self.lrd(node.right)
         print(node.item)

　　二叉树使用　　

 tree = Tree()
 tree.add(1)
 tree.add(2)
 tree.add(3)
 tree.add(4)
 tree.add(5)
 print("----广度遍历----")
 tree.travel()
 print("----深度遍历：DLR----")
 tree.dlr(tree.root)
 print("----深度遍历：LDR----")
 tree.ldr(tree.root)
 print("----深度遍历：LRD----")
 tree.lrd(tree.root)

二叉树使用

排序二叉树

　　节点定义

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

　　排序二叉树定义

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

     def insert(self, item):
         node = Node(item)
         cur_node = self.root
         if not self.root:
             self.root = node
         else:
             while True:
                 if node.item < cur_node.item:
                     if cur_node.left == None:
                         cur_node.left=node
                         break
                     else:
                         cur_node=cur_node.left
                 else:
                     if cur_node.right == None:
                         cur_node.right=node
                         break
                     else:
                         cur_node=cur_node.right

     # 广度遍历
     def travel(self):
         if not self.root:
             print(None)
             return None
         q = [self.root]
         while q:
             cur_node = q.pop(0)
             print(cur_node.item)
             if cur_node.left:
                 q.append(cur_node.left)
             if cur_node.right:
                 q.append(cur_node.right)

     # 深度遍历----前序遍历DLR
     def dlr(self, node):
         if node == None:
             return
         print(node.item)
         self.dlr(node.left)
         self.dlr(node.right)

     # 深度遍历----中序遍历LDR
     def ldr(self, node):
         if node == None:
             return
         self.ldr(node.left)
         print(node.item)
         self.ldr(node.right)

     # 深度遍历----后序遍历LRD
     def lrd(self, node):
         if node == None:
             return
         self.lrd(node.left)
         self.lrd(node.right)
         print(node.item)

　　排序二叉树使用　　

 tree=SortTree()
 tree.insert(1)
 tree.insert(30)
 tree.insert(8)
 tree.insert(20)
 tree.ldr(tree.root)

排序二叉树使用