GO开发：链表

链表

type Student struct {
Name string
Next* Student
}

每个节点包含下一个节点的地址，这样把所有的节点串起来了，通常把链表中的第一个节点叫做链表头

package main

import (
"fmt"
)

type Student struct {
Id int
Name string
Age int
next *Student
}

func trans(p Student){
for p != nil {
fmt.Println(p)
p = p.next
}
fmt.Println()
}

func main() {
var head Student
head.Id = 0
head.Name = "head"
head.Age = 18

var s1 Student
s1.Id = 1
s1.Name = "stu1"
s1.Age = 20
head.next=&s1

var s2 Student
s2.Id = 2
s2.Name = "stu2"
s2.Age = 20
s1.next=&s2
trans(&head)

var s3 Student
s3.Id = 3
s3.Name = "stu3"
s3.Age = 20
s2.next=&s3
trans(&head)
}

插入节点：尾部插入

package main

import (
"fmt"
"math/rand"
)

type Student struct {
Id int
Name string
Age int
next *Student
}

func trans(p Student){
for p != nil {
fmt.Println(p)
p = p.next
}
fmt.Println()
}

func insertTail(p *Student) {
var tail = p
for i := 0; i < 10; i++ {
stu := Student{
Id: rand.Intn(10),
Name: fmt.Sprintf("stu%d", i),
Age: rand.Intn(100),
}
tail.next = &stu
tail = &stu
}
}

func main() {
var head Student
head.Id = 0
head.Name = "head"
head.Age = 18
insertTail(&head)
trans(&head)
}

插入节点：头部插入

package main

import (
"fmt"
"math/rand"
)

type Student struct {
Id int
Name string
Age int
next *Student
}

func trans(p Student){
for p != nil {
fmt.Println(p)
p = p.next
}
fmt.Println()
}

func insertTail(p *Student) {
var tail = p
for i := 0; i < 10; i++ {
stu := Student{
Id: rand.Intn(10),
Name: fmt.Sprintf("stu%d", i),
Age: rand.Intn(100),
}
tail.next = &stu
tail = &stu
}
}

func insertHead(p **Student) {
//var tail = p
for i := 0; i < 10; i++ {
stu := Student{
Id: rand.Intn(10),
Name: fmt.Sprintf("stu%d", i),
Age: rand.Intn(100),
}
stu.next = *p
*p = &stu
}
}

func main() {
//var head *Student = &Student{}
var head *Student = new(Student)
head.Id = 0
head.Name = "head"
head.Age = 18
insertTail(head)
insertHead(&head)
trans(head)
}

添加和删除

package main

import (
"fmt"
)

type Student struct {
Id int
Name string
Age int
next *Student
}

func trans(p Student) {
for p != nil {
fmt.Println(p)
p = p.next
}
fmt.Println()
}

func delNode(p *Student) {
var prev *Student = p
for p != nil {
if p.Id == 100 {
prev.next = p.next
break
}
prev = p
p = p.next
}
}

func addNode(p *Student, newNode *Student) {
for p != nil {
if p.Name == "head" {
newNode.next = p.next
p.next = newNode
break
}
p = p.next
}
}

func main() {
var head *Student = new(Student)
head.Id = 0
head.Name = "head"
head.Age = 18

var s1 Student
s1.Id = 1
s1.Name = "stu1"
s1.Age = 20
head.next=&s1

var s2 Student
s2.Id = 2
s2.Name = "stu2"
s2.Age = 20
s1.next=&s2

var newNode *Student = new(Student)
newNode.Name = "greg"
newNode.Age = 18
newNode.Id = 100

addNode(head, newNode)
trans(head)

delNode(head)
trans(head)
}

双链表定义

type Student struct {
Name string
Next* Student
Prev* Student
}

如果有两个指针分别指向前一个节点和后一个节点，我们叫做双链表

二叉树

type Student struct {
Id int
Name string
left* Student
right* Student
}

如果每个节点有两个指针分别用来指向左子树和右子树，我们把这样的结构叫做二叉树

package main

import "fmt"

type Student struct {
Id int
Name string
Age int
left *Student
right *Student
}

func trans(root *Student) {
if root == nil {
return
}

//前序遍历
fmt.Println(root)
trans(root.left)
trans(root.right)

//中序遍历
//trans(root.left)
//fmt.Println(root)
//trans(root.right)

//后续遍历
//trans(root.left)
//trans(root.right)
//fmt.Println(root)
}

func main() {
var root *Student = new(Student)
root.Id = 1
root.Name = "s1"
root.Age = 18

var left1 *Student = new(Student)
left1.Id = 2
left1.Name = "s2"
left1.Age = 18
root.left = left1

var right1 *Student = new(Student)
right1.Id = 4
right1.Name = "s4"
right1.Age = 18
root.right = right1

var left2 *Student = new(Student)
left2.Id = 3
left2.Name = "s3"
left2.Age = 18
left1.left = left2

trans(root)
}

用接口实现一个通用链表

package main

import "fmt"

type LinkNode struct {
data interface{}
next *LinkNode
}

type Link struct {
head *LinkNode
tail *LinkNode
}

func (p *Link) InsertHead(data interface{}) {
node := &LinkNode{
data: data,
next: nil,
}

if p.tail == nil && p.head == nil {
p.tail = node
p.head = node
return
}

node.next = p.head
p.head = node
}

func (p *Link) InsertTail(data interface{}) {
node := &LinkNode{
data: data,
next: nil,
}

if p.tail == nil && p.head == nil {
p.tail = node
p.head = node
return
}

p.tail.next = node
p.tail = node
}

func (p *Link) Trans() {
q := p.head
for q != nil {
fmt.Println(q.data)
q = q.next
}
}

func main() {
var link Link
for i := 0; i < 10; i++ {
//intLink.InsertHead(i)
link.InsertTail(fmt.Sprintf("str %d", i))
}
link.Trans()
}