数据结构之链表

---

阅读目录

一、链表介绍

二、单链表

三、双链表

四、环形链表

一、链表介绍

链表是有序的列表，在内存中存储如下：

二、单链表

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