python实现二叉查找树

http://lanqiu17.iteye.com/blog/2018525

 

这次用完成的是二叉树，是一种简单的树型结构。同样使用python实现 多的不说了，上代码吧。

Python代码

1. # -*- coding: cp936 -*-
2. #---------------------------------------------
3. #
4. # author chile
5. # version 1.0
6. # date 2014-02-17
7. # desc 二叉树
8. #
9. #
10. #
11. #---------------------------------------------
13. class bintree:
14. def __init__(self):
15. self.root = None
17. # 前驱节点
18. def treePredecessor(self,entry):
19. if entry.left != None:
20. return self.maxTree(entry.left)
21. preNode = entry.parent
22. tempNode = entry
23. while preNode != None and preNode.right.value != entry.value:
24. tempNode = preNode
25. preNode = preNode.parent
26. return preNode
29. #后继节点
30. def treeSuccessor(self,entry):
31. if entry.right != None:
32. return self.minTree(entry.right)
33. preNode = entry.parent
34. tempNode = entry
35. while preNode != None and preNode.left.value != entry.value:
36. tempNode = preNode
37. preNode = preNode.parent
38. return preNode
40. def add(self,value):
41. tempNode = self.root
42. parentNode = None
43. entry = bintree.entry(value = value)
44. while tempNode != None:
45. parentNode = tempNode
46. if cmp(value,parentNode.value) < 0:
47. tempNode = tempNode.left
48. else:
49. tempNode = tempNode.right
50. if parentNode == None:
51. self.root = entry
52. elif cmp(value,parentNode.value) < 0:
53. parentNode.left = entry
54. entry.parent = parentNode
55. else:
56. parentNode.right = entry
57. entry.parent = parentNode
59. #这里删除是全部删除节点（包括所有子节点）
60. def remove(self,value):
61. root = self.root
62. parentNode = None
63. if value == root.value:
64. root.left = None
65. root.right = None
66. while root != None:
67. parentNode = root.parent
68. if value == root.value:
69. root.left = None
70. root.right = None
71. if parentNode.left != None and parentNode.left.value == value:
72. parentNode.left = None
73. break
74. else:
75. parentNode.right = None
76. break
77. elif cmp(value,root.value) < 0:
78. root = root.left
79. else:
80. root = root.right
82. #查找节点
83. def search(self,value):
84. root = self.root
85. while root != None and root.value != value:
86. if cmp(value,root.value) < 0:
87. root = root.left
88. else:
89. root = root.right
90. return root
92. #最小值的节点，其实就是找左边的叶子节点
93. def minTree(self,root):
94. entry = root
95. while entry.left != None:
96. entry = entry.left
97. return entry
99. #最大值的节点
100. def maxTree(self,root):
101. entry = root
102. while entry.right != None:
103. entry = entry.right
104. return entry
107. #中序遍历
108. def iterator(self,root):
109. if root != None:
110. self.iterator(root.left)
111. print root.value
112. self.iterator(root.right)
115. class entry:
116. def __init__(self, value=None):
117. self.left = None
118. self.right = None
119. self.parent = None
120. self.value = value
122. arr = [15,5,3,12,10,13,6,7,16,20,18,23]
123. tree = bintree()
124. for val in arr:
125. tree.add(val)
127. tree.iterator(tree.root)
128. node = tree.search(16)
129. print node.left , node.right , node.parent.value
130. print tree.maxTree(node).value
131. print tree.treePredecessor(node).value
132. print tree.treeSuccessor(node).value
133. #print tree.maxTree() , tree.minTree()

# -*- coding: cp936 -*-
#---------------------------------------------
#                                             
# author  chile                                   
# version  1.0                                
# date  2014-02-17                                       
# desc 二叉树                      
#                                             
#                                            
#                                            
#---------------------------------------------

class bintree:
    def __init__(self):
        self.root = None
        
    # 前驱节点
    def treePredecessor(self,entry):
        if entry.left != None:
            return self.maxTree(entry.left)
        preNode = entry.parent
        tempNode = entry
        while preNode != None and preNode.right.value != entry.value:
            tempNode = preNode
            preNode = preNode.parent
        return preNode
        
    
    #后继节点      
    def treeSuccessor(self,entry):
        if entry.right != None:
            return self.minTree(entry.right)
        preNode = entry.parent
        tempNode = entry
        while preNode != None and preNode.left.value != entry.value:
            tempNode = preNode
            preNode = preNode.parent
        return preNode
    
    def add(self,value):
        tempNode = self.root
        parentNode = None
        entry = bintree.entry(value = value)
        while tempNode != None:
            parentNode = tempNode
            if cmp(value,parentNode.value) < 0:
                tempNode = tempNode.left
            else:
                tempNode = tempNode.right
        if parentNode == None:
            self.root = entry
        elif cmp(value,parentNode.value) < 0:
            parentNode.left = entry
            entry.parent = parentNode
        else:
            parentNode.right = entry
            entry.parent = parentNode
    
    #这里删除是全部删除节点（包括所有子节点）
    def remove(self,value):
        root = self.root
        parentNode = None
        if value == root.value:
            root.left = None
            root.right = None
        while root != None:
            parentNode = root.parent
            if value == root.value:
                root.left = None
                root.right = None
                if parentNode.left != None and parentNode.left.value == value:
                    parentNode.left = None
                    break
                else:
                    parentNode.right = None
                    break
            elif cmp(value,root.value) < 0:
                root = root.left
            else:
                root = root.right
    
    #查找节点
    def search(self,value):
        root = self.root
        while root != None and root.value != value:
            if cmp(value,root.value) < 0:
                root = root.left
            else:
                root = root.right
        return root
    
    #最小值的节点，其实就是找左边的叶子节点
    def minTree(self,root):
        entry = root
        while entry.left != None:
            entry = entry.left
        return entry
    
    #最大值的节点
    def maxTree(self,root):
        entry = root
        while entry.right != None:
            entry = entry.right
        return entry
                
    
    #中序遍历
    def iterator(self,root):
        if root != None:
            self.iterator(root.left)
            print root.value
            self.iterator(root.right)
        
    
    class entry:
        def __init__(self, value=None):
            self.left = None
            self.right = None
            self.parent = None
            self.value = value
            
arr = [15,5,3,12,10,13,6,7,16,20,18,23]
tree = bintree()
for val in arr:
    tree.add(val)
 
tree.iterator(tree.root)
node = tree.search(16)
print node.left , node.right , node.parent.value
print tree.maxTree(node).value
print tree.treePredecessor(node).value
print tree.treeSuccessor(node).value
#print tree.maxTree() , tree.minTree()