Go实现一个简单的单向链表

单向链表的遍历、新增、删除操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
type linkedlist struct {
value string
next *linkedlist
}

// 遍历链表
func traversing(link *linkedlist) {
fmt.Printf("%s\n", (*link).value)
if link.next != nil {
traversing(link.next)
}
}

// 在链表最后插入一个元素
func insertLink(root, target *linkedlist) *linkedlist {
if root.next != nil {
insertLink(root.next, target)
}

if root.next == nil {
root.next = target
}

return root
}

// 删除指定value节点
func delLink(root *linkedlist, name string) {
var prev *linkedlist = root
for root != nil {
if root.value == name {
prev.next = root.next
break
}
prev = root
root = root.next
}
}

func test1() {
link := &linkedlist{
value: "1",
}

s := &linkedlist{
value: "2",
}

s1 := &linkedlist{
value: "3",
}

link.next = s
s.next = s1
traversing(link)
}

func test2() {
var root *linkedlist = &linkedlist{
value: "root1",
}

var p *linkedlist = root

for i := 1; i < 10; i++ {
var s *linkedlist = &linkedlist{
value: fmt.Sprintf("s%d", i),
}
fmt.Printf("%v\n", s)
p.next = s
p = s
}
traversing(root)
delLink(root, "s3")
}

func test3() {
var root *linkedlist = &linkedlist{
value: "root1",
}

for i := 1; i < 10; i++ {
var s *linkedlist = &linkedlist{
value: fmt.Sprintf("s%d", i),
}
insertLink(root, s)
}
traversing(root)
fmt.Printf("delete\n")
delLink(root, "s3")
traversing(root)
}

func main() {
test3()
}