GoLang 数据结构-单向链表,双向链表,单向环形链表

• 单向链表

• 

package main

import (
    "fmt"
    "os"
)

//HeroNode 英雄结构体
type HeroNode struct {
    Nom      int
    Name     string
    NickName string
    Next     *HeroNode
}

//InsertHeroNode 插入英雄结点 方法1 简单,但是不好用
func InsertHeroNode(head *HeroNode, NewHeroNode *HeroNode) {

    /*创建临时变量t = 头部结点*/
    t := head
    for {
        /* 如果 临时变量t的下一个是nil,就表示到达的末尾,跳过 */
        if t.Next == nil {
            break
        }
        /* 将t的下一个结点给t,那么t会一直判断是否为nil,这样就更加确定,t就代表最后一个结点 */
        t = t.Next
    }
    /* 添加下一个结点 */
    t.Next = NewHeroNode

}

//InsertHeroNode2 插入英雄结点方法2 (根据编号大小排序插入数据)
func InsertHeroNode2(head *HeroNode, NewHeroNode *HeroNode) {

    /*创建临时变量t = 头部结点*/
    t := head
    flag := true
    for {
        if t.Next == nil {
            break
        } else if t.Next.Nom > NewHeroNode.Nom {
            /* > 表示按照从小到大 < 表示 从大到小  >= <= 可根据需求更改*/
            break
        } else if t.Next.Nom == NewHeroNode.Nom {
            flag = false
            break
        }
        t = t.Next
    }

    /* 如果flag == true 表示可以存放 */
    if flag {

        /*
            顺序一定先将 新节点的下一个节点指向 → 头部的下一个节点,
            然后,再将头部的下一个节点指向 → 新节点,
            不然链表数据就断掉了
        */

        /*  ,将新节点的下一个结点指向 头部的下一个结点*/
        NewHeroNode.Next = t.Next

        /* 将新节点 指向 头部下一个结点 */
        t.Next = NewHeroNode

        fmt.Printf("添加节点 %v %v %v 成功
", NewHeroNode.Nom, NewHeroNode.Name, NewHeroNode.NickName)

        /* 如果 flag == false 不能存放*/
    } else {
        fmt.Printf("添加失败,结点编号 %v 已存在!
", NewHeroNode.Nom)
    }

}

//DelHeroNodeByID 根据ID删除节点
func DelHeroNodeByID(head *HeroNode, id int) {
    t := head
    state := false
    for {
        if t.Next == nil {
            break
        } else if t.Next.Nom == id {
            /* 找到了ID */
            state = true
            break
        }

        /* 一直往后找 */
        t = t.Next
    }

    if state {
        /*
            找到了 删除,
            将头部的下一个节点 指向 头部的下一个的下一个节点,
            这样 头部的下一个节点就成垃圾了

        */
        t.Next = t.Next.Next
        fmt.Printf("节点 %v 已删除!
", id)
    } else {
        /* 未找到 */
        fmt.Printf("您输入的ID号 %v 未找到!
", id)
    }
}

//UpdateToNode 修改节点信息
func UpdateToNode(head *HeroNode, id int, NewHeroNode *HeroNode) {

    /*创建临时变量t = 头部结点*/
    t := head
    flag := false

    for {
        if t.Next == nil {
            break
        } else if t.Next.Nom == id {
            flag = true
            break
        }
        t = t.Next
    }
    fmt.Println("修改节点前", t.Next)
    /* 如果flag == true 表示可以 修改 */
    if flag {
        t.Next.Nom = NewHeroNode.Nom
        t.Next.Name = NewHeroNode.Name
        t.Next.NickName = NewHeroNode.NickName
        fmt.Println("修改节点成功")
        fmt.Println("修改节点后", NewHeroNode)
        /* 如果 flag == false 不能存放*/
    } else {
        fmt.Printf("添加失败,结点编号 %v 已存在!
", NewHeroNode.Nom)
    }

}

//PrintListHeroInfo 输出链表hero信息
func PrintListHeroInfo(head *HeroNode) {

    /*创建临时变量t = 头部结点*/
    t := head

    /* 判断是否为空 */
    if t.Next == nil {
        fmt.Println("链表为空...")
        return
    }

    /* 不为空时执行 */
    fmt.Println("链表数据:↓")
    for {

        fmt.Printf("%v %v %v	
", t.Next.Nom, t.Next.Name, t.Next.NickName)

        t = t.Next

        if t.Next == nil {
            break
        }

    }
    fmt.Println()
}

//CRUDToList 增删改查列表
func CRUDToList(head *HeroNode) {

    for {
        var key int
        var id int
        var name string
        var nickeame string
        var NewNode *HeroNode
        fmt.Println("				用户信息链表操作系统")
        fmt.Println(
            `
                1.        添加节点
                2.        删除节点
                3.        修改节点
                4.        查看链表
                5.        退出系统
                请输入(1-5)进行操作
        `)
        fmt.Scanln(&key)
        switch key {
        case 1:

            fmt.Println("请输入新节点的 [ ID 英雄名称 英雄昵称 ], 以空格分隔输入!")
            fmt.Scanf("%v %v %v
", &id, &name, &nickeame)
            NewNode = &HeroNode{
                Nom:      id,
                Name:     name,
                NickName: nickeame,
            }

            InsertHeroNode2(head, NewNode)

        case 2:
            fmt.Println("请输入删除节点ID")
            fmt.Scanln(&id)
            DelHeroNodeByID(head, id)
        case 3:
            fmt.Println(
                `
                请输入修改内容 [ id name nickname ] 以空格分隔输入
                `)
            fmt.Scanf("%v %v %v
", &id, &name, &nickeame)
            NewNode = &HeroNode{
                Nom:      id,
                Name:     name,
                NickName: nickeame,
            }
            UpdateToNode(head, id, NewNode)
        case 4:
            PrintListHeroInfo(head)
        case 5:
            fmt.Println("已退出系统...")
            os.Exit(0)
        default:
            fmt.Println("操作有误,请输入(1-4)数字!")
        }
    }
}

func main() {

    //Hero 链表 头结点HeroListLinkHead
    head := &HeroNode{}

    CRUDToList(head)
}

• 双向链表

package main

import (
    "fmt"
    "os"
)

/*
HeroNode 英雄结构体

Nom 编号

Name  名称

NickName 昵称

Next 指向下一个节点

Last 指向上一个节点

*/
type HeroNode struct {
    Nom      int
    Name     string
    NickName string
    Next     *HeroNode
    Last     *HeroNode
}

//InsertHeroNode 双向链表插入新节点 (根据编号大小排序插入数据)
func InsertHeroNode(head *HeroNode, NewHeroNode *HeroNode) {

    /*创建临时变量t = 头部结点*/
    t := head
    flag := true
    for {
        if t.Next == nil {
            break
        } else if t.Next.Nom > NewHeroNode.Nom {
            /* > 表示按照从小到大 < 表示 从大到小  >= <= 可根据需求更改*/
            break
        } else if t.Next.Nom == NewHeroNode.Nom {
            flag = false
            break
        }
        t = t.Next
    }

    /* 如果flag == true 表示可以存放 */
    if flag {

        /* 将 新节点的下一个节点指向 头部节点原先指向的 下一个结点*/
        NewHeroNode.Next = t.Next

        /* 将 新节点的上一个节点 指向 t头部节点 */
        NewHeroNode.Last = t

        /* 将 头节点的下一个节点的上一个节点不为空时才指向新节点,不然会发生空指针引用 */
        if t.Next.Last != nil {
            /* 将头节点原先指向的下一个节点的上一个节点 指向 新节点 */
            t.Next.Last = NewHeroNode
        }

        /* 将 头部节点的下一个节点 指向 新节点 */
        t.Next = NewHeroNode

        fmt.Printf("添加节点 %v %v %v 成功
", NewHeroNode.Nom, NewHeroNode.Name, NewHeroNode.NickName)

        /* 如果 flag == false 不能存放*/
    } else {
        fmt.Printf("添加失败,结点编号 %v 已存在!
", NewHeroNode.Nom)
    }

}

//DelHeroNodeByID 根据ID删除节点
func DelHeroNodeByID(head *HeroNode, id int) {
    t := head
    state := false
    for {
        if t.Next == nil {
            break
        } else if t.Next.Nom == id {
            /* 找到了ID */
            state = true
            break
        }

        /* 一直往后找 */
        t = t.Next
    }

    if state {
        /*
            找到了 删除,
            将头部的下一个节点 指向 头部的下一个的下一个节点,
            这样 头部的下一个节点就成垃圾了

        */
        t.Next = t.Next.Next
        if t.Next != nil {
            t.Next.Last = t
            fmt.Printf("节点 %v 已删除!
", id)
        }

    } else {
        /* 未找到 */
        fmt.Printf("您输入的ID号 %v 未找到!
", id)
    }
}

//UpdateToNode 修改节点信息
func UpdateToNode(head *HeroNode, id int, NewHeroNode *HeroNode) {

    /*创建临时变量t = 头部结点*/
    t := head
    flag := false

    for {
        if t.Next == nil {
            break
        } else if t.Next.Nom == id {
            flag = true
            break
        }
        t = t.Next
    }
    fmt.Println("修改节点前", t.Next)
    /* 如果flag == true 表示可以 修改 */
    if flag {
        t.Next.Nom = NewHeroNode.Nom
        t.Next.Name = NewHeroNode.Name
        t.Next.NickName = NewHeroNode.NickName

        fmt.Println("修改节点成功")
        fmt.Println("修改节点后", NewHeroNode)

        /* 如果 flag == false 不能存放*/
    } else {
        fmt.Printf("添加失败,结点编号 %v 已存在!
", NewHeroNode.Nom)
    }

}

//PrintListHeroInfo 正向输出链表hero信息
func PrintListHeroInfo(head *HeroNode) {

    /*创建临时变量t = 头部结点*/
    t := head

    /* 判断是否为空 */
    if t.Next == nil {
        fmt.Println("链表为空...")
        return
    }

    /* 不为空时执行 */
    fmt.Println("链表数据:↓")
    for {

        fmt.Printf("%v %v %v	
", t.Next.Nom, t.Next.Name, t.Next.NickName)

        t = t.Next

        if t.Next == nil {
            break
        }

    }
    fmt.Println()
}

//PrintListHeroInfoByReverse 你想输出链表信息
func PrintListHeroInfoByReverse(head *HeroNode) {
    t := head
    if t.Next == nil {
        fmt.Println("空链表...")
        return
    }
    /* 让t 定位到链表末尾 */
    for {
        if t.Next == nil {
            break
        }
        t = t.Next
    }

    /* 反向遍历 */
    for {
        fmt.Printf("%v %v %v	
", t.Nom, t.Name, t.NickName)
        t = t.Last
        if t.Last == nil {
            break
        }
    }
}

//CRUDToList 增删改查列表
func CRUDToList(head *HeroNode) {

    for {
        var key int
        var id int
        var name string
        var nickeame string
        var NewNode *HeroNode
        fmt.Println("				用户信息链表操作系统")
        fmt.Println(
            `
                1.        添加节点
                2.        删除节点
                3.        修改节点
                4.        查看链表
                5.        退出系统
                请输入(1-5)进行操作
        `)
        fmt.Scanln(&key)
        switch key {
        case 1:

            fmt.Println("请输入新节点的 [ ID 英雄名称 英雄昵称 ], 以空格分隔输入!")
            fmt.Scanf("%v %v %v
", &id, &name, &nickeame)
            /* 限制输入 id不能为0  名称不能为空 昵称不能为空,否则不添加 */

            if name != " " && nickeame != " " {
                if id == 0 {
                    break
                }
                NewNode = &HeroNode{
                    Nom:      id,
                    Name:     name,
                    NickName: nickeame,
                }

                InsertHeroNode(head, NewNode)
                fmt.Println("节点添加成功")
            } else {
                fmt.Println("节点添加失败...")
            }

        case 2:
            fmt.Println("请输入删除节点ID")
            fmt.Scanln(&id)
            DelHeroNodeByID(head, id)
        case 3:
            fmt.Println(
                `
                请输入修改内容 [ id name nickname ] 以空格分隔输入
                `)
            fmt.Scanf("%v %v %v
", &id, &name, &nickeame)
            NewNode = &HeroNode{
                Nom:      id,
                Name:     name,
                NickName: nickeame,
            }
            UpdateToNode(head, id, NewNode)
        case 4:
            fmt.Println(
                `
            请问要看 哪个方向的输出格式的链表?
            1.        正向输出 
            2.        逆向输出`)
            fmt.Scanln(&key)
            switch key {
            case 1:
                PrintListHeroInfo(head)
            case 2:
                PrintListHeroInfoByReverse(head)
            default:
                fmt.Println("输入查看链表的方式有误!")
            }
        case 5:
            fmt.Println("已退出系统...")
            os.Exit(0)
        default:
            fmt.Println("操作有误,请输入(1-4)数字!")
        }
    }
}

func main() {

    //Hero 链表 头结点HeroListLinkHead
    head := &HeroNode{}

    CRUDToList(head)
}

• 单向环形链表(约瑟夫问题(丢手绢))

• 

• package main
  
  import "fmt"
  
  //Child 孩子结构体
  type Child struct {
      no   int
      next *Child
  }
  
  //AddChild 添加孩子
  func AddChild(num int) *Child {
      first := &Child{}
      currentChild := &Child{}
      if num < 1 {
          fmt.Println("num值太少了,不够玩的")
          return first
      }
      for i := 1; i <= num; i++ {
          child := &Child{
              no: i,
          }
          if i == 1 {
              first = child
              currentChild = child
              currentChild.next = first
          } else {
              currentChild.next = child
              currentChild = child
              currentChild.next = first
          }
      }
      return first
  }
  
  //PrintChild 输出孩子链表
  func PrintChild(first *Child) {
      if first.next == nil {
          fmt.Println("链表为空,没有孩子")
          return
      }
  
      currentChild := first
      for {
          fmt.Printf("孩子编号:%v 
  ", currentChild.no)
          if currentChild.next == first {
              break
          }
          currentChild = currentChild.next
      }
  }
  
  /*
  ThrowTheHandkerchief 丢手绢
  
  first *Child    第一个孩子的节点
  
  startNum int    开始从第几个孩子数
  
  countNum int    数几下
  */
  func ThrowTheHandkerchief(first *Child, startNum int, countNum int) {
      if first.next == nil {
          fmt.Println("空链表,请添加孩子")
          return
      }
  
      tail := first
      for {
          if tail.next == first {
              break
          }
          tail = tail.next
      }
  
      for i := 1; i <= startNum-1; i++ {
          first = first.next
          tail = tail.next
      }
  
      for {
          for i := 1; i <= countNum-1; i++ {
              first = first.next
              tail = tail.next
          }
          fmt.Printf("编号为 %v 的孩子出圈了
  ", first.no)
          first = first.next
          tail.next = first
          if tail == first {
              break
          }
      }
      fmt.Printf("编号为 %v 的孩子最后出圈...
  ", first.no)
  
  }
  func main() {
      firstChild := AddChild(100)
      PrintChild(firstChild)
      ThrowTheHandkerchief(firstChild, 99, 25)
  }