Go语言链表，增加了一个地址指向
image.png

基础功能

  1. // 单链表 - 增删改查
  2. package main
  4. import "fmt"
  6. // 定义节点
  7. type HeroNode struct {
  8.     no       int
  9.     name     string
  10.     nickname string
  11.     next     *HeroNode // 表示指向下一个节点
  12. }
  14. // 添加节点
  15. func insertNode(head *HeroNode, newNode *HeroNode) {
  16.     // 1. 找到链表最后的节点
  17.     // 2. 创建辅助节点， 跑龙套的
  18.     temp := head
  19.     for {
  20.         if temp.next == nil {
  21.             // 最后的节点
  22.             break
  23.         }
  24.         temp = temp.next // temp 一直后移, 直到指向链表最后的节点
  25.     }
  26.     // 3. 修改最后一个节点的 next 指向 newNode
  27.     temp.next = newNode
  28. }
  30. // 显示链表所有节点信息
  31. func showNode(head *HeroNode) {
  32.     // 1. 创建辅助节点， 跑龙套的
  33.     temp := head
  34.     // 2. 判断该链表是不是空的
  35.     if temp.next == nil {
  36.         fmt.Println("空链表")
  37.         return
  38.     }
  39.     // 2. 遍历链表
  40.     for {
  41.         fmt.Printf("[%d , %s , %s] => ", temp.next.no, temp.next.name, temp.next.nickname)
  42.         temp = temp.next
  43.         if temp.next == nil {
  44.             break
  45.         }
  46.     }
  48. }
  50. func main() {
  51.     // 1. 创建头节点
  52.     head := &HeroNode{}
  54.     // 2. 创建 HeroNode
  55.     hero1 := &HeroNode{
  56.         no:       1,
  57.         name:     "luffy",
  58.         nickname: "海贼王",
  59.     }
  60.     hero2 := &HeroNode{
  61.         no:       1,
  62.         name:     "索隆",
  63.         nickname: "大剑豪",
  64.     }
  66.     fmt.Println("插入节点")
  67.     insertNode(head, hero1)
  68.     insertNode(head, hero2)
  69.     fmt.Println("显示节点")
  70.     showNode(head)
  71. }
  73. /*
  74. [1 , luffy , 海贼王] => [2 , 索隆 , 大剑豪] =>
  75. */
  1. [1 , luffy , 海贼王] => [3 , 山治 , allblue] => [2 , 索隆 , 大剑豪] =>
  3. // 按顺序插入
  4. [1 , luffy , 海贼王] => [2 , 索隆 , 大剑豪] => [3 , 山治 , allblue] =>

按顺序插入

  1. // 单链表 - 增删改查
  2. package main
  4. import "fmt"
  6. // 定义节点
  7. type HeroNode struct {
  8.     no       int
  9.     name     string
  10.     nickname string
  11.     next     *HeroNode // 表示指向下一个节点
  12. }
  14. // 添加节点
  15. func insertNode(head *HeroNode, newNode *HeroNode) {
  16.     // 1. 找到链表最后的节点
  17.     // 2. 创建辅助节点， 跑龙套的
  18.     temp := head
  19.     for {
  20.         if temp.next == nil {
  21.             // 最后的节点
  22.             break
  23.         }
  24.         temp = temp.next // temp 一直后移, 直到指向链表最后的节点
  25.     }
  26.     // 3. 修改最后一个节点的 next 指向 newNode
  27.     temp.next = newNode
  28. }
  30. // 根据 编号 no 插入到指定位置（从小到大）
  31. func insertNode02(head *HeroNode, newNode *HeroNode) {
  32.     // 1. 找到链表适当的节点
  33.     // 2. 创建辅助节点， 跑龙套的
  34.     temp := head
  35.     flag := true
  36.     for {
  37.         if temp.next == nil {
  38.             // 最后的节点
  39.             break
  40.         } else if temp.next.no > newNode.no {
  41.             // 升序
  42.             // 降序: temp.next.no < newNode.no
  43.             break
  44.         } else if temp.next.no == newNode.no {
  45.             fmt.Println("已经存在，不允许加入")
  46.             flag = false
  47.             break
  48.         }
  49.         temp = temp.next // temp 一直后移,
  50.     }
  51.     if !flag {
  52.         fmt.Println("不能插入节点")
  53.         return
  54.     } else {
  55.         // newNode 应该插入 temp.next 前面， temp后面
  56.         newNode.next = temp.next
  57.         temp.next = newNode
  58.     }
  59. }
  61. // 显示链表所有节点信息
  62. func showNode(head *HeroNode) {
  63.     // 1. 创建辅助节点， 跑龙套的
  64.     temp := head
  65.     // 2. 判断该链表是不是空的
  66.     if temp.next == nil {
  67.         fmt.Println("空链表")
  68.         return
  69.     }
  70.     // 2. 遍历链表
  71.     for {
  72.         fmt.Printf("[%d , %s , %s] => ", temp.next.no, temp.next.name, temp.next.nickname)
  73.         temp = temp.next
  74.         if temp.next == nil {
  75.             break
  76.         }
  77.     }
  79. }
  81. func main() {
  82.     // 1. 创建头节点
  83.     head := &HeroNode{}
  85.     // 2. 创建 HeroNode
  86.     hero1 := &HeroNode{
  87.         no:       1,
  88.         name:     "luffy",
  89.         nickname: "海贼王",
  90.     }
  91.     hero2 := &HeroNode{
  92.         no:       2,
  93.         name:     "索隆",
  94.         nickname: "大剑豪",
  95.     }
  96.     hero3 := &HeroNode{
  97.         no:       3,
  98.         name:     "山治",
  99.         nickname: "allblue",
  100.     }
  102.     fmt.Println("插入节点")
  103.     insertNode02(head, hero1)
  104.     insertNode02(head, hero3)
  105.     insertNode02(head, hero2)
  106.     fmt.Println("显示节点")
  107.     showNode(head)
  108. }
  110. /*
  111. [1 , luffy , 海贼王] => [2 , 索隆 , 大剑豪] => [3 , 山治 , allblue] => 
  113. [3 , 山治 , allblue] => [2 , 索隆 , 大剑豪] => [1 , luffy , 海贼王] =>
  114. */

删除指定节点

  1. // 单向链表 - 增删改查
  2. package main
  4. import (
  5.     "fmt"
  6. )
  8. // 定义节点
  9. type HeroNode struct {
  10.     no       int
  11.     name     string
  12.     nickname string
  13.     next     *HeroNode // 表示指向下一个节点
  14. }
  16. // 添加节点
  17. func insertNode(head *HeroNode, newNode *HeroNode) {
  18.     // 1. 找到链表最后的节点
  19.     // 2. 创建辅助节点， 跑龙套的
  20.     temp := head
  21.     for {
  22.         if temp.next == nil {
  23.             // 最后的节点
  24.             break
  25.         }
  26.         temp = temp.next // temp 一直后移, 直到指向链表最后的节点
  27.     }
  28.     // 3. 修改最后一个节点的 next 指向 newNode
  29.     temp.next = newNode
  30. }
  32. // 根据 编号 no 插入到指定位置（从小到大）
  33. func insertNode02(head *HeroNode, newNode *HeroNode) {
  34.     // 1. 找到链表适当的节点
  35.     // 2. 创建辅助节点， 跑龙套的
  36.     temp := head
  37.     flag := true
  38.     for {
  39.         if temp.next == nil {
  40.             // 最后的节点
  41.             break
  42.         } else if temp.next.no > newNode.no {
  43.             // 升降序， 只需要修改 temp.next.no < newNode.no
  44.             break
  45.         } else if temp.next.no == newNode.no {
  46.             fmt.Printf("节点： %v, 已经存在，不允许加入\n", newNode.no)
  47.             flag = false
  48.             break
  49.         }
  50.         temp = temp.next // temp 一直后移,
  51.     }
  52.     if !flag {
  53.         fmt.Println("不能插入节点")
  54.         return
  55.     } else {
  56.         // newNode 应该插入 temp.next 前面， temp后面
  57.         newNode.next = temp.next
  58.         temp.next = newNode
  59.     }
  60. }
  62. // 删除节点
  63. func delNode(head *HeroNode, id int) {
  64.     // 1. 先来一个跑龙套的
  65.     temp := head
  67.     flag := false
  69.     // 2. 找到要删除的节点
  70.     for {
  71.         if temp.next == nil {
  72.             break
  73.         } else if temp.next.no == id {
  74.             // 找到了
  75.             flag = true
  76.             break
  77.         }
  78.         temp = temp.next
  79.     }
  80.     if flag {
  81.         // 删除， 更改节点指向
  82.         temp.next = temp.next.next
  83.     } else {
  84.         fmt.Println("要删除的节点id不存在")
  85.     }
  86. }
  88. // 显示链表所有节点信息
  89. func showNode(head *HeroNode) {
  90.     // 1. 创建辅助节点， 跑龙套的
  91.     temp := head
  92.     // 2. 判断该链表是不是空的
  93.     if temp.next == nil {
  94.         fmt.Println("空链表")
  95.         return
  96.     }
  97.     // 2. 遍历链表
  98.     for {
  99.         fmt.Printf("[%d , %s , %s] => ", temp.next.no, temp.next.name, temp.next.nickname)
  100.         temp = temp.next
  101.         if temp.next == nil {
  102.             break
  103.         }
  104.     }
  105.     fmt.Println()
  106. }
  108. func main() {
  109.     // 1. 创建头节点
  110.     head := &HeroNode{}
  112.     // 2. 创建 HeroNode
  113.     hero1 := &HeroNode{
  114.         no:       1,
  115.         name:     "luffy",
  116.         nickname: "海贼王",
  117.     }
  118.     hero2 := &HeroNode{
  119.         no:       2,
  120.         name:     "索隆",
  121.         nickname: "大剑豪",
  122.     }
  123.     hero3 := &HeroNode{
  124.         no:       3,
  125.         name:     "山治",
  126.         nickname: "allblue",
  127.     }
  128.     hero4 := &HeroNode{
  129.         no:       4,
  130.         name:     "甚平",
  131.         nickname: "海侠",
  132.     }
  134.     fmt.Println("按顺序插入节点")
  135.     insertNode02(head, hero1)
  136.     insertNode02(head, hero3)
  137.     insertNode02(head, hero2)
  138.     insertNode02(head, hero4)
  139.     insertNode02(head, hero1)
  140.     showNode(head)
  141.     fmt.Println("删除指定节点")
  142.     delNode(head, 3)
  143.     showNode(head)
  144. }
  146. /*
  147. [1 , luffy , 海贼王] => [2 , 索隆 , 大剑豪] =>
  148. */
  150. /*
  151. 按顺序插入节点
  152. 节点： 1, 已经存在，不允许加入
  153. 不能插入节点
  154. [1 , luffy , 海贼王] => [2 , 索隆 , 大剑豪] => [3 , 山治 , allblue] => [4 , 甚平 , 海侠] =>
  155. 删除指定节点
  156. [1 , luffy , 海贼王] => [2 , 索隆 , 大剑豪] => [4 , 甚平 , 海侠] =>
  157. */