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()
}