阅读目录
一、链表介绍
二、单链表
三、双链表
四、环形链表
一、链表介绍
链表是有序的列表,在内存中存储如下:
二、单链表
func main() {
SingleLinkList()
}
// 链表 起名Node结尾
type HeroNode struct {
no int
name string
nickname string
next *HeroNode // 指向下一个节点
}
// 单链表的第一种方式
func SingleLinkList() {
// 1.先创建头节点
head := &HeroNode{}
// 2. 创建一个新的HeroNode
hero1 := &HeroNode{
no: 1,
name: "宋江",
nickname: "及时雨",
next: nil,
}
hero2 := &HeroNode{
no: 2,
name: "武松",
nickname: "不知道",
next: nil,
}
hero3 := &HeroNode{
no: 3,
name: "卢俊义",
nickname: "玉麒麟",
next: nil,
}
// 3.加入
//InsertHeroNode(head, hero1)
//InsertHeroNode(head, hero2)
//InsertHeroNode(head, hero3)
InsertHeroNode2(head, hero1)
InsertHeroNode2(head, hero2)
InsertHeroNode2(head, hero3)
//4.显示
ListHeroNode(head)
// 删除
fmt.Println()
DelHeroNode(head, 1)
DelHeroNode(head, 2)
DelHeroNode(head, 3)
DelHeroNode(head, 4)
fmt.Println()
ListHeroNode(head)
}
// 给列表增加or插入节点
// 第一种插入方式,在单链表最后插入
func InsertHeroNode(headNode *HeroNode, newNode *HeroNode) {
// 1.先找到该链表最后节点
// 2. 创建辅助节点[跑龙套]
tmp := headNode
for {
if tmp.next == nil {
//表示找到最后节点了
break
}
// tmp向下走
tmp = tmp.next
}
//3.加入newNode
tmp.next = newNode
}
// 给列表增加or插入节点
// 第二种插入方式,找到适当节点,插入,比如根据编号排序
func InsertHeroNode2(headNode *HeroNode, newNode *HeroNode) {
// 1.先找到该链表最后节点
// 2. 创建辅助节点[跑龙套]
tmp := headNode
for {
if tmp.next == nil {
//表示找到最后节点了
break
} else if tmp.next.no > newNode.no {
// newNode就应该插入tmp后面
break
} else if tmp.next.no == newNode.no {
fmt.Println("已存在no,插入错误!")
return
}
// tmp向下
tmp = tmp.next
}
//3.加入newNode
newNode.next = tmp.next // 先将加入节点的下一个节点指向tmp下一个节点
tmp.next = newNode // 在将tmp下一个节点指向newNode
}
// 显示链表的所有节点信息
func ListHeroNode(head *HeroNode) {
//1.创建辅助节点
tmp := head
//2.判断列表是否为空
if tmp.next == nil {
fmt.Println("空链表...")
return
}
//3.遍历列表
for {
fmt.Printf("节点信息:[%d, %s, %s, ] ->", tmp.next.no, tmp.next.name, tmp.next.nickname)
// 判断是否到了链表尾部
tmp = tmp.next
if tmp.next == nil {
break
}
}
}
// 删除节点
func DelHeroNode(head *HeroNode, id int) {
tmp := head
flag := false
for {
if tmp.next == nil {
break
} else if tmp.next.no == id {
// 找到了
flag = true
break
}
tmp = tmp.next
}
if flag {
// 改变连接,垃圾回收会处理单连
tmp.next = tmp.next.next
} else {
fmt.Println("删除的元素不存在...")
}
}
三、双链表
// 双向链表
func main() {
DoubleLinkList()
}
// 链表 起名Node结尾
type HeroNode1 struct {
no int
name string
nickname string
pre *HeroNode1 // 指向前一个节点
next *HeroNode1 // 指向下一个节点
}
// 单链表的第一种方式
func DoubleLinkList() {
// 1.先创建头节点
head := &HeroNode1{}
// 2. 创建一个新的HeroNode
hero1 := &HeroNode1{
no: 1,
name: "宋江",
nickname: "及时雨",
next: nil,
pre: nil,
}
hero2 := &HeroNode1{
no: 2,
name: "武松",
nickname: "不知道",
next: nil,
pre: nil,
}
hero3 := &HeroNode1{
no: 3,
name: "卢俊义",
nickname: "玉麒麟",
next: nil,
pre: nil,
}
// 3.加入
InsertHeroNode1(head, hero1)
InsertHeroNode1(head, hero2)
InsertHeroNode1(head, hero3)
//4.显示
ListHeroNode1(head)
// 删除
fmt.Println()
ListHeroNode2(head)
//DelHeroNode(head, 1)
//DelHeroNode(head, 2)
//DelHeroNode(head, 3)
//DelHeroNode(head, 4)
//fmt.Println()
//ListHeroNode(head)
}
// 给列表增加or插入节点
// 第一种插入方式,在单链表最后插入
func InsertHeroNode1(headNode *HeroNode1, newNode *HeroNode1) {
// 1.先找到该链表最后节点
// 2.创建辅助节点[跑龙套]
tmp := headNode
for {
if tmp.next == nil {
//表示找到最后节点了
break
}
// tmp向下走
tmp = tmp.next
}
//3.加入newNode
tmp.next = newNode
newNode.pre = tmp
}
// 给列表增加or插入节点
// 第二种插入方式,找到适当节点,插入,比如根据编号排序
func InsertHeroNode3(headNode *HeroNode1, newNode *HeroNode1) {
// 1.先找到该链表最后节点
// 2. 创建辅助节点[跑龙套]
tmp := headNode
for {
if tmp.next == nil {
//表示找到最后节点了
break
} else if tmp.next.no > newNode.no {
// newNode就应该插入tmp后面
break
} else if tmp.next.no == newNode.no {
fmt.Println("已存在no,插入错误!")
return
}
// tmp向下
tmp = tmp.next
}
//3.加入newNode
newNode.next = tmp.next // 先将加入节点的下一个节点指向tmp下一个节点
newNode.pre = tmp
if tmp.next != nil {
tmp.next.pre = newNode
}
tmp.next = newNode // 在将tmp下一个节点指向newNode
}
// 显示链表的所有节点信息
func ListHeroNode1(head *HeroNode1) {
//1.创建辅助节点
tmp := head
//2.判断列表是否为空
if tmp.next == nil {
fmt.Println("空链表...")
return
}
//3.遍历列表
for {
fmt.Printf("节点信息:[%d, %s, %s, ] ->", tmp.next.no, tmp.next.name, tmp.next.nickname)
// 判断是否到了链表尾部
tmp = tmp.next
if tmp.next == nil {
break
}
}
}
// 删除节点
func DelHeroNode1(head *HeroNode1, id int) {
tmp := head
flag := false
for {
if tmp.next == nil {
break
} else if tmp.next.no == id {
// 找到了
flag = true
break
}
tmp = tmp.next
}
if flag {
// 改变连接,垃圾回收会处理单连
tmp.next = tmp.next.next
if tmp.next != nil {
tmp.next.pre = tmp
}
} else {
fmt.Println("删除的元素不存在...")
}
}
// 倒序打印
// 显示链表的所有节点信息
func ListHeroNode2(head *HeroNode1) {
//1.创建辅助节点
tmp := head
//2.判断列表是否为空
if tmp.next == nil {
fmt.Println("空链表...")
return
}
for {
if tmp.next == nil {
break
}
// 走到最后
tmp = tmp.next
}
//3.遍历列表
for {
fmt.Printf("节点信息:[%d, %s, %s, ] ->", tmp.no, tmp.name, tmp.nickname)
// 判断是否到了链表尾部
tmp = tmp.pre
if tmp.pre == nil {
break
}
}
}
四、环形链表
单向环形链表
type CatNode struct {
no int
name string
next *CatNode
}
//插入环形链表
func InsertCatNode(head *CatNode, newNode *CatNode) {
if head.next == nil {
head.no = newNode.no
head.name = newNode.name
head.next = head // 构成环形
return
}
tmp := head
for {
if tmp.next == head {
break
}
tmp = tmp.next
}
tmp.next = newNode
newNode.next = head
}
func ListCircleLink(head *CatNode) {
tmp := head
if tmp.next == nil {
fmt.Println("空的环形链表...")
return
}
for {
fmt.Println("cat info:", tmp.name, "->")
if tmp.next == head {
break
}
tmp = tmp.next
}
}
func main() {
head := &CatNode{}
cat1 := &CatNode{
no: 1,
name: "tom1",
next: nil,
}
cat2 := &CatNode{
no: 2,
name: "tom2",
next: nil,
}
cat3 := &CatNode{
no: 3,
name: "tom3",
next: nil,
}
InsertCatNode(head, cat1)
InsertCatNode(head, cat2)
InsertCatNode(head, cat3)
ListCircleLink(head)
head = DelCatNode(head, 1)
fmt.Println()
ListCircleLink(head)
head = DelCatNode(head, 30)
fmt.Println()
ListCircleLink(head)
head = DelCatNode(head, 3)
fmt.Println()
ListCircleLink(head)
}
func DelCatNode(head *CatNode, no int) *CatNode {
tmp := head //辅助查找 no
helper := head // 标志最后位置
if tmp.next == nil {
fmt.Println("空链表...")
return head
}
// 如果只有一个节点
if tmp.next == head {
tmp.next = nil
return head
}
// 将helper指向最后
for {
if helper.next == head {
break
}
helper = helper.next
}
flag := true
//如果有两个及以上
for {
if tmp.next == head {
// 已经到最后一个 还没有比较/还没找到
break
}
if tmp.no == no {
if tmp == head {
// 删除头节点
head = head.next
}
// 正好匹配到
helper.next = tmp.next
flag = false
break
}
tmp = tmp.next //比较
helper = helper.next //一旦找到,helper辅助删除
}
if flag {
//整个循环中没有删除过,比较最后一次
if tmp.no == no {
// 比较最后一个
helper.next = tmp.next
} else {
fmt.Println("没有此节点...")
}
}
return head
}
单向环形链表应用 - josephu(丢手帕)
func main() {
first := AddBoy(500)
//显示
ShowBoy(first)
fmt.Println()
PlayGame(first, 3, 20)
}
type Boy struct {
no int //编号
next *Boy //指向下一个小孩指针
}
func AddBoy(num int) *Boy {
// 传入创建小孩的个数 返回第一个小孩的指针
first := &Boy{} //空节点 头
curBoy := &Boy{} //辅助节点
if num < 1 {
fmt.Println("不支持构建数据")
return first // 返回空指针
}
for i := 1; i <= num; i++ {
boy := &Boy{
no: i,
}
//1.因为第一个小孩比较特殊
if i == 1 {
first = boy
curBoy = boy
curBoy.next = first // 构成循环
} else {
curBoy.next = boy // 指针移位
curBoy = boy
curBoy.next = first //构成环形
}
}
return first
}
// 显示单向环形链表
func ShowBoy(head *Boy) {
//如果环形列表为空
if head.next == nil {
fmt.Println("空链表...")
}
// 辅助指针
curBoy := head
for {
fmt.Printf("小孩编号【%d】->", curBoy.no)
if curBoy.next == head {
break // 遍历完了
}
curBoy = curBoy.next // 下移
}
}
func PlayGame(first *Boy, startNo int, countNum int) {
//1.空的链表单独处理
if first.next == nil {
fmt.Println("空链表...")
return
}
// 2.start不能大于小孩总数
if startNo > 500 {
fmt.Println("不支持的开始节点")
return
}
// 3.需要定义赋值指针
tail := first //帮助删除
for {
if tail.next == first {
break // 指向最后一个节点
}
tail = tail.next
}
// 4.先让first移动到startNo
for i := 1; i <= startNo-1; i++ {
first = first.next
tail = tail.next //一起移动
}
// 5.开始数countNum,删除first指向的小孩
for {
if first == tail {
//判断退出条件
fmt.Println("最后出圈小孩:", first.no)
break
}
//数countNum-1
for i := 1; i <= countNum-1; i++ {
first = first.next
tail = tail.next //一起移动
}
fmt.Printf("第【%d】小孩出圈
", first.no)
// 删除first
first = first.next //走到下一步
tail.next = first //断开连接原始first
}
}