Skip to content

Commit 0644631

Browse files
author
yu.zhang
committed
🌟 golang bst
1 parent 2c8dedf commit 0644631

File tree

5 files changed

+309
-3
lines changed

5 files changed

+309
-3
lines changed

‎.gitignore

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,3 @@
11
venv/
22
.idea/
3+
__pycache__/

‎go.mod

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
module algo
2+
3+
go 1.12

‎golang/bst/bst.go

Lines changed: 207 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,207 @@
1+
package main
2+
3+
import (
4+
"fmt"
5+
"log"
6+
)
7+
8+
type Node struct {
9+
E int
10+
Left *Node
11+
Right *Node
12+
}
13+
14+
func (node Node) String() string {
15+
return fmt.Sprintf("<Node> %d", node.E)
16+
}
17+
18+
type BinarySearchTree struct {
19+
Root *Node
20+
}
21+
22+
// 增加node
23+
func (binarySearchTree *BinarySearchTree) Add(e int) {
24+
node := Node{e, nil, nil}
25+
if binarySearchTree.Root == nil {
26+
binarySearchTree.Root = &node
27+
} else {
28+
add(binarySearchTree.Root, e)
29+
}
30+
31+
}
32+
33+
func add(node *Node, e int) {
34+
if node.E < e && node.Right == nil {
35+
node.Right = &Node{e, nil, nil}
36+
} else if node.E < e && node.Right != nil {
37+
add(node.Right, e)
38+
} else if node.E > e && node.Left == nil {
39+
node.Left = &Node{e, nil, nil}
40+
} else if node.E > e && node.Left != nil {
41+
add(node.Left, e)
42+
} else {
43+
// equal
44+
}
45+
}
46+
47+
// contain
48+
func (binarySearchTree BinarySearchTree) Contains(e int) bool {
49+
return contains(*binarySearchTree.Root, e)
50+
}
51+
52+
func contains(node Node, e int) bool {
53+
if node.E == e {
54+
return true
55+
} else if node.E < e && node.Right != nil {
56+
return contains(*node.Right, e)
57+
} else if node.E > e && node.Left != nil {
58+
return contains(*node.Left, e)
59+
} else if node.E < e && node.Right == nil {
60+
return false
61+
} else if node.E > e && node.Left == nil {
62+
return false
63+
} else {
64+
return false
65+
}
66+
}
67+
68+
// 使用指针的方式
69+
func (binarySearchTree *BinarySearchTree) ContainsUsePointer(e int) bool {
70+
return containsUsePointer(binarySearchTree.Root, e)
71+
}
72+
73+
func containsUsePointer(node *Node, e int) bool {
74+
if node == nil {
75+
return false
76+
}
77+
if node.E == e {
78+
return true
79+
} else if node.E > e {
80+
return containsUsePointer(node.Left, e)
81+
} else {
82+
return containsUsePointer(node.Right, e)
83+
}
84+
}
85+
86+
// 前序遍历
87+
func (binarySearchTree *BinarySearchTree) PreOrder() {
88+
preOrder(binarySearchTree.Root)
89+
}
90+
91+
// 中序遍历
92+
func (binarySearchTree *BinarySearchTree) InOrder() {
93+
inOrder(binarySearchTree.Root)
94+
}
95+
96+
func preOrder(node *Node) {
97+
if node == nil {
98+
return
99+
}
100+
log.Println(node.E)
101+
preOrder(node.Left)
102+
preOrder(node.Right)
103+
}
104+
105+
func inOrder(node *Node) {
106+
if node == nil {
107+
return
108+
}
109+
inOrder(node.Left)
110+
log.Println(node.E)
111+
inOrder(node.Right)
112+
}
113+
114+
func (binarySearchTree *BinarySearchTree) PostOrder() {
115+
postOrder(binarySearchTree.Root)
116+
}
117+
118+
func postOrder(node *Node) {
119+
if node == nil {
120+
return
121+
}
122+
postOrder(node.Left)
123+
postOrder(node.Right)
124+
log.Println(node.E)
125+
}
126+
127+
func (binarySearchTree *BinarySearchTree) LevelOrder() {
128+
firstLevel := []*Node{binarySearchTree.Root}
129+
levelOrder(firstLevel)
130+
}
131+
132+
func levelOrder(nodes []*Node) {
133+
if len(nodes) == 0 {
134+
return
135+
}
136+
// for print
137+
var level []*Node
138+
var nextLevel []*Node
139+
for _, nodeP := range nodes {
140+
level = append(level, nodeP)
141+
if nodeP.Left != nil {
142+
nextLevel = append(nextLevel, nodeP.Left)
143+
}
144+
if nodeP.Right != nil {
145+
nextLevel = append(nextLevel, nodeP.Right)
146+
}
147+
}
148+
log.Println("current level: ", level)
149+
levelOrder(nextLevel)
150+
}
151+
152+
func (binarySearchTree *BinarySearchTree) Minimum() *Node {
153+
return minimum(binarySearchTree.Root)
154+
}
155+
156+
func minimum(node *Node) *Node {
157+
if node.Left != nil {
158+
return minimum(node.Left)
159+
} else {
160+
return node
161+
}
162+
}
163+
164+
func (binarySearchTree *BinarySearchTree) Maximum() *Node {
165+
return maximum(binarySearchTree.Root)
166+
}
167+
168+
func maximum(node *Node) *Node {
169+
if node.Right != nil {
170+
return maximum(node.Right)
171+
} else {
172+
return node
173+
}
174+
}
175+
176+
func (binarySearchTree *BinarySearchTree) DelMin() {
177+
binarySearchTree.Root = delMin(binarySearchTree.Root)
178+
}
179+
180+
func delMin(node *Node) *Node {
181+
if node.Left == nil {
182+
right := node.Right
183+
node.Right = nil
184+
return right
185+
}
186+
node.Left = delMin(node.Left)
187+
return node
188+
}
189+
190+
func (binarySearchTree *BinarySearchTree) DelMax() {
191+
binarySearchTree.Root = delMax(binarySearchTree.Root)
192+
}
193+
194+
func delMax(node *Node) *Node{
195+
if node.Right == nil {
196+
left:= node.Left
197+
node.Left = nil
198+
return left
199+
}
200+
node.Right = delMax(node.Right)
201+
return node
202+
}
203+
204+
205+
func (binarySearchTree *BinarySearchTree) DelNode(node *Node) {
206+
return
207+
}

‎golang/bst/bst_test.go

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
package main
2+
3+
import (
4+
"fmt"
5+
"testing"
6+
)
7+
8+
var (
9+
dataExample = []int{1, 3, 2, 4, 5}
10+
)
11+
12+
func TestBinarySearchTree_Add(t *testing.T) {
13+
var binarySearchTree BinarySearchTree
14+
for _, data := range dataExample{
15+
binarySearchTree.Add(data)
16+
}
17+
}
18+
19+
func TestBinarySearchTree_Contains(t *testing.T) {
20+
var binarySearchTree BinarySearchTree
21+
for _, data := range dataExample{
22+
binarySearchTree.Add(data)
23+
}
24+
for _, data := range dataExample{
25+
fmt.Println(binarySearchTree.Contains(data) == true)
26+
}
27+
fmt.Println(binarySearchTree.Contains(123) == false)
28+
}
29+
30+
func TestBinarySearchTree_ContainsUsePointer(t *testing.T) {
31+
var binarySearchTree BinarySearchTree
32+
for _, data := range dataExample{
33+
binarySearchTree.Add(data)
34+
}
35+
for _, data := range dataExample{
36+
fmt.Println(binarySearchTree.ContainsUsePointer(data) == true)
37+
}
38+
fmt.Println(binarySearchTree.ContainsUsePointer(123) == false)
39+
}
40+
41+
func TestBinarySearchTree_PreOrder(t *testing.T) {
42+
var binarySearchTree BinarySearchTree
43+
for _, data := range dataExample{
44+
binarySearchTree.Add(data)
45+
}
46+
fmt.Println("----------preOrder-------")
47+
binarySearchTree.PreOrder()
48+
fmt.Println("-----------------")
49+
}
50+
51+
func TestBinarySearchTree_LevelOrder(t *testing.T) {
52+
var binarySearchTree BinarySearchTree
53+
for _, data := range dataExample{
54+
binarySearchTree.Add(data)
55+
}
56+
binarySearchTree.LevelOrder()
57+
58+
}
59+
60+
func TestBinarySearchTree_Maximum(t *testing.T) {
61+
var binarySearchTree BinarySearchTree
62+
for _, data := range dataExample{
63+
binarySearchTree.Add(data)
64+
}
65+
fmt.Println("max value: ", binarySearchTree.Maximum().E == 5)
66+
fmt.Println("min value: ", binarySearchTree.Minimum().E == 1)
67+
68+
}
69+
70+
func TestBinarySearchTree_DelMin(t *testing.T) {
71+
var binarySearchTree BinarySearchTree
72+
for _, data := range dataExample{
73+
binarySearchTree.Add(data)
74+
}
75+
binarySearchTree.DelMin()
76+
binarySearchTree.LevelOrder()
77+
78+
79+
binarySearchTree.Root = nil
80+
for _, data := range []int{3, 2, 1, 4, 5}{
81+
binarySearchTree.Add(data)
82+
}
83+
binarySearchTree.DelMin()
84+
binarySearchTree.LevelOrder()
85+
}
86+
87+
88+
func TestBinarySearchTree_DelMax(t *testing.T) {
89+
var binarySearchTree BinarySearchTree
90+
for _, data := range []int{3, 2, 1, 4, 5}{
91+
binarySearchTree.Add(data)
92+
}
93+
binarySearchTree.DelMax()
94+
binarySearchTree.LevelOrder()
95+
}

‎python/bst/bst.py

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -41,11 +41,11 @@ def _add(self, node, e: int):
4141
if node.e < e and node.right_node is None:
4242
node.right_node = Node(e)
4343
elif node.e < e and node.right_node is not None:
44-
return self._add(node.right_node, e)
44+
self._add(node.right_node, e)
4545
elif node.e > e and node.left_node is None:
4646
node.left_node = Node(e)
4747
elif node.e > e and node.left_node is not None:
48-
return self._add(node.left_node, e)
48+
self._add(node.left_node, e)
4949
else:
5050
return
5151

@@ -115,7 +115,7 @@ def _level_order(self, nodes: List[Node]):
115115
def minimum(self):
116116
return self._minimum(self.root)
117117

118-
def _minimum(self, node:Node):
118+
def _minimum(self, node: Node):
119119
if not node:
120120
return
121121
if node.left_node:

0 commit comments

Comments
 (0)