二叉查找树(binary search tree)

顾名思义二叉查找树中每个节点至多有两个子节点，并且还对存储于每个节点中的关键字值有个小小的要求，

即只要这个节点有左节点或右节点，那么其关键字值总的

大于其左节点的关键字值，

小于其右节点的关键字值，如下图：

因为树的结构特性，很适合使用递归的方式去操作，下面的实现中均是以递归的方式实现：

下面仅给出了python的实现，一是因为代码太长，二是python的实现是我对着C语言实现改过来的，基本没什么差别； 主要实现的方法有：

遍历：

前序：preorder()——理根节点→处理左子树→处理右子树

中序：inorder()——处理左子树→处理根节点→处理右子树

后序：postorder()——处理左子树→处理右子树→处理根节点

插入：

insert(key)——将关键字值为key的节点插入到适当的位置(注释里面的是非递归实现)

删除：

delete(key)——将关键字值为key的节点从树中删掉(注释中给了说明)

获取高度：

height()

获取树中的节点数：

count()

查找：

find(key)——查找关键字值为key的节点(二叉查找树的一个重要应用就是在查找中)

获取树中最大key值节点和最key值小节点：

find_max()

find_min()

；；；

class tree_node:

def __init__(self, key = None, left = None, right = None):

self.key = key

self.left = left

self.right = right

class binary_search_tree:

def __init__(self):

self.root = None

def preorder(self):

print 'preorder: ',

self.__preorder(self.root)

print

def __preorder(self, root):

if not root:

return

print root.key,

self.__preorder(root.left)

self.__preorder(root.right)

def inorder(self):

print 'inorder: ',

self.__inorder(self.root)

print

def __inorder(self, root):

if not root:

return

self.__inorder(root.left)

print root.key,

self.__inorder(root.right)

def postorder(self):

print 'postorder: ',

self.__postorder(self.root)

print

def __postorder(self, root):

if not root:

return

self.__postorder(root.left)

self.__postorder(root.right)

print root.key,

def insert(self, key):

'''recursion'''

self.root = self.__insert(self.root, key)

def __insert(self, root, key):

if not root:

root = tree_node(key)

else:

if key < root.key:

root.left = self.__insert(root.left, key)

elif key > root.key:

root.right = self.__insert(root.right, key)

else:

print key, 'is already in tree'

return root

##non-recursion

## def insert(self, key):

## if not self.root:

## self.root = tree_node(key)

## else:

## cur = self.root

## while True:

## if key < cur.key:

## if not cur.left:

## cur.left = tree_node(key)

## break

## cur = cur.left

## elif key > cur.key:

## if not cur.right:

## cur.right = tree_node(key)

## break

## cur = cur.right

## else:

## print key, 'in tree'

## break

def height(self):

return self.__height(self.root)

def __height(self, root):

if not root:

return -1

left_height = self.__height(root.left)

right_height = self.__height(root.right)

#return 1+(left_height if left_height>right_height else right_height)#这种方式是自己写的，后面两种高大上的是网上偷学的^_^

#return 1+[left_height,right_height][left_height

return 1+(left_height>right_height and [left_height] or [right_height])[0]

def count(self):

'''elements in tree'''

return self.__count(self.root)

def __count(self, root):

if not root:

return 0

return 1+self.__count(root.left)+self.__count(root.right)

def delete(self, key):

self.root = self.__delete(self.root, key)

##

##删除操作：

##首先找到删除的节点，

##1. 如果左右子树都不为空，则找到右子树中最小的节点min，用min.key代替删除节点的key，然后再到右子

## 树中删除min节点,因为min没有左节点，所以删除它的话只需要用它的右节点代替它(如果有右节点)；

##2. 如果左子树或者右子树不为空，则直接代替掉

##3. 如果左右均空即叶子节点，直接删掉

def __delete(self, root, key):

if not root:

print 'not find key: ', key

elif key < root.key:

root.left = self.__delete(root.left, key)

elif key > root.key:

root.right = self.__delete(root.right, key)

elif root.left and root.right: #found

right_min = self.__find_min(self.root.right)

root.key = right_min.key

root.right = self.__delete(root.right, right_min.key)

elif root.left:

root = root.left

elif root.right:

root = root.right

else:

root = None #python的GC会在没有引用指向对象的时候销毁对象

return root

def find(self, key):

node = self.__find(self.root, key)

if not node:

print 'not found'

return node

def __find(self, root, key):

if not root:

return None

if key < root.key:

return self.__find(root.left, key)

elif key > root.key:

return self.__find(root.right, key)

else:

return root

def find_min(self):

return self.__find_min(self.root)

def __find_min(self, root):

if not root.left:

return root

return self.__find_min(root.left)

def find_max(self):

return self.__find_max(self.root)

def __find_max(self, root):

if not root.right:

return root

return self.__find_max(root.right)

def main():

import random

root = binary_search_tree()

for i in random.sample([j for j in range(1, 100)], 5):

root.insert(i)

print 'insert: '

root.insert(78)

root.insert(101)

root.insert(14)

root.preorder()

root.inorder()

root.postorder()

print 'height: ', root.height()

print 'count: ', root.count()

print 'min: ', root.find_min().key

print 'max: ', root.find_max().key

print 'delete: '

root.delete(101)

root.delete(12)

root.preorder()

root.inorder()

root.postorder()

print root.find(71)

print root.find(78)

print 'height: ', root.height()

print 'count: ', root.count()

print 'min: ', root.find_min().key

print 'max: ', root.find_max().key

if __name__ == '__main__':

main()