1
1
#!/usr/bin/env python
2
2
from collections import deque
3
3
4
+
4
5
class Tree (object ):
5
6
class Node (object ):
6
7
def __init__ (self , v , l = None , r = None ):
7
8
self .value = v
8
9
self .lChild = l
9
- self .rChild = r
10
-
10
+ self .rChild = r
11
+
11
12
def __init__ (self ):
12
13
self .root = None
13
14
@@ -24,7 +25,7 @@ def levelOrderBinaryTreeUtil(self, arr, start):
24
25
if right < size :
25
26
curr .rChild = self .levelOrderBinaryTreeUtil (arr , right )
26
27
return curr
27
-
28
+
28
29
def InsertNode (self , value ):
29
30
self .root = self .InsertNodeUtil (self .root , value )
30
31
@@ -38,75 +39,66 @@ def InsertNodeUtil(self, node, value):
38
39
node .rChild = self .InsertNodeUtil (node .rChild , value )
39
40
return node
40
41
41
-
42
42
def PrintPreOrder (self ):
43
43
self .PrintPreOrderUtil (self .root )
44
44
45
-
46
45
def PrintPreOrderUtil (self , node ):
47
- # pre order
46
+ # pre order
48
47
if node != None :
49
48
print (node .value ),
50
49
self .PrintPreOrderUtil (node .lChild )
51
50
self .PrintPreOrderUtil (node .rChild )
52
51
53
-
54
52
def NthPreOrder (self , index ):
55
- count = [0 ]
53
+ count = [0 ]
56
54
self .NthPreOrderUtil (self .root , index , count )
57
55
58
56
def NthPreOrderUtil (self , node , index , count ):
59
- # pre order
57
+ # pre order
60
58
if node != None :
61
59
count [0 ] += 1
62
60
if count [0 ] == index :
63
61
print (node .value ),
64
62
self .NthPreOrderUtil (node .lChild , index , count )
65
63
self .NthPreOrderUtil (node .rChild , index , count )
66
64
67
-
68
65
def PrintPostOrder (self ):
69
66
self .PrintPostOrderUtil (self .root )
70
67
71
68
def PrintPostOrderUtil (self , node ):
72
- # post order
69
+ # post order
73
70
if node != None :
74
71
self .PrintPostOrderUtil (node .lChild )
75
72
self .PrintPostOrderUtil (node .rChild )
76
73
print (node .value ),
77
74
78
-
79
75
def NthPostOrder (self , index ):
80
76
count = [0 ]
81
77
self .NthPostOrderUtil (self .root , index , count )
82
78
83
79
def NthPostOrderUtil (self , node , index , count ):
84
- # post order
80
+ # post order
85
81
if node != None :
86
82
self .NthPostOrderUtil (node .lChild , index , count )
87
83
self .NthPostOrderUtil (node .rChild , index , count )
88
84
count [0 ] += 1
89
85
if count [0 ] == index :
90
86
print (node .value ),
91
87
92
-
93
88
def PrintInOrder (self ):
94
89
self .PrintInOrderUtil (self .root )
95
90
96
-
97
91
def PrintInOrderUtil (self , node ):
98
- # In order
92
+ # In order
99
93
if node != None :
100
94
self .PrintInOrderUtil (node .lChild )
101
95
print (node .value ),
102
96
self .PrintInOrderUtil (node .rChild )
103
97
104
-
105
98
def NthInOrder (self , index ):
106
99
count = [0 ]
107
100
self .NthInOrderUtil (self .root , index , count )
108
101
109
-
110
102
def NthInOrderUtil (self , node , index , count ):
111
103
if node != None :
112
104
self .NthInOrderUtil (node .lChild , index , count )
@@ -135,10 +127,11 @@ def PrintDepthFirst(self):
135
127
while stk .isEmpty () == False :
136
128
temp = stk .pop ()
137
129
print (temp .value ),
138
- if temp .lChild != None :
139
- stk .append (temp .lChild )
140
130
if temp .rChild != None :
141
131
stk .append (temp .rChild )
132
+ if temp .lChild != None :
133
+ stk .append (temp .lChild )
134
+
142
135
143
136
def Find (self , value ):
144
137
curr = self .root
@@ -638,12 +631,12 @@ def treeToListRec(self, curr):
638
631
return Head
639
632
640
633
641
- #=======================================================================
634
+ # =======================================================================
642
635
# arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
643
636
# t2 = Tree()
644
637
# t2.levelOrderBinaryTree(arr)
645
- #=======================================================================
646
- #=======================================================================
638
+ # =======================================================================
639
+ # =======================================================================
647
640
# t = Tree()
648
641
# arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
649
642
# # t.levelOrderBinaryTree(arr)
@@ -674,11 +667,11 @@ def treeToListRec(self, curr):
674
667
# t.PrintBredthFirst()
675
668
# # t.treeToList();
676
669
# print ( t.LCA(10, 3) )
677
- #=======================================================================
670
+ # =======================================================================
678
671
arr = [1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]
679
672
t2 = Tree ()
680
673
# t2.levelOrderBinaryTree(arr)
681
- #=======================================================================
674
+ # =======================================================================
682
675
# t2.InsertNode(5)
683
676
# t2.InsertNode(3)
684
677
# t2.InsertNode(4)
@@ -687,10 +680,10 @@ def treeToListRec(self, curr):
687
680
# t2.InsertNode(8)
688
681
# t2.InsertNode(7)
689
682
# t2.InsertNode(9)
690
- #=======================================================================
691
- #print t2.Ancestor(1, 10)
692
- #print t2.CeilBST(7)
693
- #print t2.FloorBST(12)
683
+ # =======================================================================
684
+ # print t2.Ancestor(1, 10)
685
+ # print t2.CeilBST(7)
686
+ # print t2.FloorBST(12)
694
687
t2 .CreateBinaryTree (arr )
695
688
t2 .PrintInOrder ()
696
689
print ""
@@ -703,8 +696,8 @@ def treeToListRec(self, curr):
703
696
t2 .PrintPreOrder ()
704
697
print ""
705
698
t2 .iterativePreOrder ()
706
- #t2.DeleteNode(8)
707
- #=======================================================================
699
+ # t2.DeleteNode(8)
700
+ # =======================================================================
708
701
# t3 = t2.CopyMirrorTree()
709
702
# t2.PrintInOrder()
710
703
# print ""
@@ -737,5 +730,5 @@ def treeToListRec(self, curr):
737
730
# print t2.printInRange(4, 7)
738
731
# print t2.trimOutsideRange(3, 8)
739
732
# print t2.PrintInOrder()
740
- #=======================================================================
733
+ # =======================================================================
741
734
0 commit comments