1 # encoding=utf-8
  2 
  3 
  4 class BSTree:
  5     """
  6     二叉搜索树
  7     """
  8     middle_list = []
  9 
 10     class Node:
 11         def __init__(self, ele):
 12             self.data = ele
 13             self.left_child = None
 14             self.right_child = None
 15 
 16         def __str__(self):
 17             return str(self.data)
 18 
 19         def __lt__(self, other):
 20             return self.data < other.data
 21 
 22         def __gt__(self, other):
 23             return self.data > other.data
 24 
 25         def __eq__(self, other):
 26             return self.data == other.data
 27 
 28     def __init__(self, ele):
 29         self.__root = self.Node(ele)
 30 
 31     @property
 32     def root(self):
 33         """
 34         返回根节点
 35         :return: self.__root
 36         """
 37         return self.__root
 38 
 39     def insert(self, ele):
 40         """
 41         插入到排序的位置
 42         :param ele: element
 43         :return:
 44         """
 45         ele = self.Node(ele)
 46         _root = self.find_ele(ele, self.__root)
 47         if _root > ele:
 48             # insert to left
 49             _root.left_child = ele
 50         elif _root < ele:
 51             # insert to right
 52             _root.right_child = ele
 53         else:
 54             # 节点已存在
 55             pass
 56 
 57     def find_ele(self, ele, _root):
 58         """
 59         查找ele应该挂载的节点, ele将插入在节点的left/right
 60         :param ele: element     type of BSTree.Node
 61         :param _root: 当前用来排序的根节点
 62         :return: 应插入的根节点& left 1/right 0
 63         """
 64         """
 65         while _root < ele:
 66             # 走右节点, 一直到节点值大于ele，此时节点值>ele, 如无左节点 ele挂载到它的左节点， 有左节点递归左节点
 67             if _root.right_child:
 68                 _root = _root.right_child
 69             else:
 70                 break
 71         while _root > ele:
 72             # 走左节点, 一直到节点值小于ele， 此时节点值<ele, 如无右节点 ele挂载到它的右节点， 有右节点递归右节点
 73             if _root.left_child:
 74                 _root = _root.left_child
 75             else:
 76                 break
 77         """
 78 
 79         while _root < ele and _root.right_child:
 80             # 走右节点, 一直到节点值大于ele，此时节点值>ele, 如无左节点 ele挂载到它的左节点， 有左节点递归左节点
 81             _root = _root.right_child
 82         while _root > ele and _root.left_child:
 83             # 走左节点, 一直到节点值小于ele， 此时节点值<ele, 如无右节点 ele挂载到它的右节点， 有右节点递归右节点
 84             _root = _root.left_child
 85 
 86         if _root.left_child and _root > ele:
 87             # 对应 while _root < ele 如有左节点递归左节点
 88             return self.find_ele(ele, _root.left_child)
 89         if _root.right_child and _root < ele:
 90             # 对应 while _root > ele 如有右节点递归右节点
 91             return self.find_ele(ele, _root.right_child)
 92         return _root
 93 
 94     def search(self, ele):
 95         """
 96         元素是否存在于树中
 97         :param ele: type of element
 98         :return:
 99         """
100         ele = self.Node(ele)
101         node = self.find_ele(ele, self.__root)
102         return ele == node
103 
104     def middle_order_wrapper(func):
105         """
106         中序遍历装饰器
107         :return:
108         """
109         def inner(self, __root):
110             func(self, __root)
111             return self.middle_list
112         return inner
113 
114     """
115     @middle_order_wrapper
116     def middle_order(self, __root):
117         if not __root:
118             return
119         self.middle_order(__root.left_child)
120         self.middle_list.append(__root)
121         self.middle_order(__root.right_child)
122     """
123 
124     def middle_order(self, __root):
125         """中序遍历 仅打印测试"""
126         if not __root:
127             return
128         self.middle_order(__root.left_child)
129         print __root
130         self.middle_order(__root.right_child)
131 
132     def min(self, _root):
133         """
134         if _root.left_child:
135             return self.min(_root.left_child)
136         else:
137             return _root
138         """
139         while _root.left_child:
140             _root = _root.left_child
141         return _root
142 
143     def max(self, _root):
144         """
145         if _root.right_child:
146             return self.max(_root.right_child)
147         else:
148             return _root
149         """
150         while _root.right_child:
151             _root = _root.right_child
152         return _root
153 
154     def del_node(self, _root, ele):
155         """
156         删除
157         :param _root: 根节点
158         :param ele: type of Tree.Node
159         :return: node
160         """
161         if _root > ele:
162             _root.left_child = self.del_node(_root.left_child, ele)
163         if _root < ele:
164             _root.right_child = self.del_node(_root.right_child, ele)
165         else:
166             # 删除时, 分为三种情况：只有左子树或者只有右子树、有左右子树、即无左子树又无右子树
167             if _root.left_child and _root.right_child:
168                 # 既有左子树又有右子树，则需找到右子树中最小值节点 赋值给_root, 再把右子树中最小值节点删除
169                 _min = self.min(_root.right_child)
170                 _root.data = _min.data
171                 _root.right_child = self.del_node(_root.right_child, _min)
172             elif not _root.right_child and not _root.left_child:
173                 # 左右子树都为空, 直接删除
174                 _root = None
175             elif not _root.right_child:
176                 # 只有左子树
177                 _root = _root.left_child
178             elif not _root.left_child:
179                 # 只有右子树
180                 _root = _root.right_child
181         return _root

晚上刷牙的时候, 左右左右, 突然想明白的.

如果是自定义类型, 需要实现__lt__() & __gt()__ & __eq__ 等比较运算的方法