go 实现双向链表

一 说明

使用带 head 头的双向链表实现——水浒英雄排行榜管理。

单向链表的缺点分析。

1 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。

2 单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，单链表删除时，总要找到 temp 的下一个节点来删除。

二 图解

三 代码

package main

import (
   "fmt"
)

// HeroNode
type HeroNode struct {
   no       int
   name     string
   nickname string
   pre      *HeroNode // 指向前一个结点
   next     *HeroNode // 指向下一个结点
}

// 给双向链表插入一个结点，在单链表的最后加入
func InsertHeroNode(head *HeroNode, newHeroNode *HeroNode) {
   // 1 先找到该链表的最后这个结点
   // 2 创建一个辅助结点
   temp := head
   for {
      if temp.next == nil { // 表示找到最后
         break
      }
      temp = temp.next // 让 temp 不断的指向下一个结点
   }
   // 3 将 newHeroNode 加入到链表的最后
   temp.next = newHeroNode
   newHeroNode.pre = temp
}

// 给双向链表插入一个结点，根据 no 的编号从小到大插入
func InsertHeroNode2(head *HeroNode, newHeroNode *HeroNode) {
   // 1 找到适当的结点
   // 2 创建一个辅助结点
   temp := head
   flag := true
   // 让插入的结点的 no，和 temp 的下一个结点的 no 比较
   for {
      if temp.next == nil { // 说明到链表的最后
         break
      } else if temp.next.no >= newHeroNode.no {
         // newHeroNode 插入到 temp 后面
         break
      } else if temp.next.no == newHeroNode.no {
         // 链表中已经有这个 no,不插入
         flag = false
         break
      }
      temp = temp.next
   }
   if !flag {
      fmt.Println("对不起，已经存在no=", newHeroNode.no)
      return
   } else {
      newHeroNode.next = temp.next
      newHeroNode.pre = temp
      if temp.next != nil {
         temp.next.pre = newHeroNode
      }
      temp.next = newHeroNode
   }
}

// 双向链表删除一个结点
func DelHerNode(head *HeroNode, id int) {
   temp := head
   flag := false
   // 找到要删除结点的 no，和 temp 的下一个结点的 no 比较
   for {
      if temp.next == nil { // 到链表的最后
         break
      } else if temp.next.no == id {
         // 找到了
         flag = true
         break
      }
      temp = temp.next
   }
   if flag { // 找到并删除
      temp.next = temp.next.next
      if temp.next != nil {
         temp.next.pre = temp
      }
   } else {
      fmt.Println("sorry, 要删除的id不存在")
   }
}

// 显示链表的所有结点信息，仍然使用单向的链表显示方式
func ListHeroNode(head *HeroNode) {
   // 1 创建一个辅助结点
   temp := head
   // 判断该链表是不是一个空的链表
   if temp.next == nil {
      fmt.Println("空空如也。。。。")
      return
   }
   // 2 遍历这个链表
   for {
      fmt.Printf("[%d , %s , %s]==>", temp.next.no,
         temp.next.name, temp.next.nickname)
      temp = temp.next
      if temp.next == nil {
         break
      }
   }
}

// 逆序显示链表的所有结点信息
func ListHeroNode2(head *HeroNode) {
   // 1 创建一个辅助结点
   temp := head
   // 先判断该链表是不是一个空的链表
   if temp.next == nil {
      fmt.Println("空空如也。。。。")
      return
   }

   // 2 让 temp 定位到双向链表的最后结点
   for {
      if temp.next == nil {
         break
      }
      temp = temp.next
   }

   // 3 遍历这个链表
   for {
      fmt.Printf("[%d , %s , %s]==>", temp.no,
         temp.name, temp.nickname)
      // 判断是否是链表头
      temp = temp.pre
      if temp.pre == nil {
         break
      }
   }
}

func main() {
   // 1 先创建一个头结点
   head := &HeroNode{}
   // 2 创建一个新的 HeroNode
   hero1 := &HeroNode{
      no:       1,
      name:     "宋江",
      nickname: "及时雨",
   }
   hero2 := &HeroNode{
      no:       2,
      name:     "卢俊义",
      nickname: "玉麒麟",
   }
   hero3 := &HeroNode{
      no:       3,
      name:     "林冲",
      nickname: "豹子头",
   }
   InsertHeroNode(head, hero1)
   InsertHeroNode(head, hero2)
   InsertHeroNode(head, hero3)
   ListHeroNode(head)
   fmt.Println("逆序打印")
   ListHeroNode2(head)
}

四 测试

[1 , 宋江 , 及时雨]==>[2 , 卢俊义 , 玉麒麟]==>[3 , 林冲 , 豹子头]==>逆序打印
[3 , 林冲 , 豹子头]==>[2 , 卢俊义 , 玉麒麟]==>[1 , 宋江 , 及时雨]==>