Go语言实现单链表

已于 2023-12-29 14:41:37 修改
阅读量212 收藏
点赞数 1
文章标签： golang 后端 数据结构
于 2022-10-12 20:53:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54650406/article/details/127290506
版权
  • 初始化单链表：通过NewList函数初始化单链表，并指定头结点和大小。
  • 打印单链表：通过display方法打印出单链表中所有节点的值。
  • 判断单链表中是否存在环：使用快慢指针的方式判断单链表中是否存在环。
  • 就地翻转单链表：使用迭代的方式实现单链表的就地翻转。
  • 清除单链表中所有节点：通过clear方法清除单链表中的所有节点，并返回节点值的列表。
  • 判断单链表是否为空：通过isEmpty方法判断单链表是否为空。
  • 返回单链表的长度大小：通过length方法返回单链表的长度。
  • 返回单链表的首节点：通过getHead方法返回单链表的首节点。
  • 设置单链表的首节点：通过setHead方法设置单链表的首节点。
  • 手动计算单链表的长度大小：通过count方法手动计算单链表的长度。
  • 判断给定的值是否在单链表中：通过search方法判断给定的值是否在单链表中。
  • 根据给定的索引返回单链表中相应的元素值：通过getNth方法根据给定的索引返回单链表中相应的元素值。
  • 在头结点前插入元素：通过insertHead方法在头结点前插入元素。
  • 在尾结点后插入元素：通过insertTail方法在尾结点后插入元素。
  • 在指定位置上插入元素：通过insertNth方法在指定位置上插入元素。
  • 删除头结点：通过deleteHead方法删除头结点，并返回删除的元素值。
  • 删除尾结点：通过deleteTail方法删除尾结点，并返回删除的元素值。
  • 删除指定位置的元素：通过deleteNth方法删除指定位置的元素，并返回删除的元素值。
  • 检查给定位置是否超出单链表范围：通过checkBounds方法检查给定位置是否超出单链表范围。
package singlylinkedlist

import (
	"fmt"
)

type Node struct {
	value int
	next  *Node
}

func NewNode(value int, next *Node) *Node {
	return &Node{value, next}
}

type singlylinkedlist struct {
	head *Node
	size int
}

//
// NewList
//  @Description: 初始化单链表,指定头结点和大小
//  @param head
//  @param size
//  @return *singlylinkedlist
//
func NewList(head *Node, size int) *singlylinkedlist {
	return &singlylinkedlist{head, size}
}

//
// display
//  @Description: 打印出单链表中所有结点的值
//  @receiver l
//
func (l *singlylinkedlist) display() {
	if l.isEmpty() {
		fmt.Println("The list to display is empty")
	}
	cur := l.head
	for cur != nil {
		if cur.next == nil {
			fmt.Println(cur.value)
			break
		}
		fmt.Print(cur.value, "->")
		cur = cur.next
	}
}

//
// detectLoop
//  @Description: 判断单链表中是否存在环(使用快慢指针的方式)
//  @return bool
//
func (l *singlylinkedlist) detectLoop() bool {
	slow := l.head
	fast := l.head
	for (fast != nil) && (fast.next != nil) {
		slow = slow.next
		fast = fast.next.next
		if fast == slow {
			return true
		}
	}
	return false
}

//
// reverseList
//  @Description: 就地翻转单链表
//  @receiver l
//
func (l *singlylinkedlist) reverseList() {

	var pre *Node
	cur := l.head
	nxt := l.head

	for cur != nil {
		nxt = cur.next
		cur.next = pre
		pre = cur
		cur = nxt
	}
	l.head = pre
}


//
// clear
//  @Description: 清除单链表中所有结点
//  @receiver l
//  @return res
//
func (l *singlylinkedlist) clear() (res []int) {

	cur := l.head
	for cur != nil {
		prev := cur
		res = append(res, prev.value)
		cur = cur.next
		prev = nil
	}
	l.head = nil
	l.size = 0
	return res
}

//
// isEmpty
//  @Description: 判断单链表是否为空
//  @receiver l
//  @return bool
//
func (l *singlylinkedlist) isEmpty() bool{
	return l.size == 0
}

//
// count
//  @Description: 返回单链表的长度大小
//  @receiver l
//  @return int the count of the list
//
func (l *singlylinkedlist) length() int {
	return l.size
}


//
// getHead
//  @Description: 返回单链表的首结点
//  @receiver l
//  @return *Node the head of the list
//
func (l *singlylinkedlist) getHead() *Node {
	return l.head
}


//
// setHead
//  @Description: 设置单链表的首结点
//  @receiver l
//  @param node
//
func (l *singlylinkedlist) setHead(node *Node) {
	l.head = node
}

//
// count
//  @Description: 手动计算单链表的长度大小
//  @receiver l
//  @return int the count of the list
//
func (l *singlylinkedlist) count() int {
	count := 0
	cur := l.head
	for cur != nil {
		count++
		cur = cur.next
	}
	return count

}

//
// search
//  @Description: 判断所给的key值是否在单链表中
//  @receiver l
//  @param key the value to be searched
//  @return bool {@code true} if key is present in the list, otherwise {@code false}
//
func (l *singlylinkedlist) search(key int) bool {
	cur := l.head
	for cur != nil {
		if cur.value == key {
			return true
		}
		cur = cur.next
	}
	return false
}

//
// getNth
//  @Description: 根据所给的index返回单链表中相应的元素值
//  @receiver l
//  @param index
//  @return int
//
func (l *singlylinkedlist) getNth(index int) int {
	l.checkBounds(index, 0, l.size - 1)
	cur := l.head
	for i := 0; i < index; i++ {
		cur = cur.next
	}
	return cur.value
}


//
// insertHead
//  @Description: 在头结点前插入元素
//  @receiver l
//  @param x
//
func (l *singlylinkedlist) insertHead(x int) {
	l.insertNth(x, 0)
}


//
// insertTail
//  @Description: 在尾结点之后插入元素
//  @receiver l
//  @param data
//
func (l *singlylinkedlist) insertTail(data int) {
	l.insertNth(data, l.size)
}



//
// insertNth
//  @Description: 在指定的位置上插入元素
//  @receiver l
//  @param data
//  @param position
//
func (l *singlylinkedlist) insertNth(data int, position int) {
	l.checkBounds(position, 0, l.size)
	newNode := NewNode(data, nil)
	if l.head == nil {
		l.head = newNode
		l.size++
		return
	}
	if position == 0 {
		newNode.next = l.head
		l.head = newNode
		l.size++
		return
	}

	cur := l.head
	for i := 0; i < position - 1; i++ {
		cur = cur.next
	}
	newNode.next = cur.next
	cur.next = newNode
	l.size++
}

//
// deleteHead
//  @Description: 删除头结点
//  @receiver l
//  @return int
//
func (l *singlylinkedlist) deleteHead() int {
	return l.deleteNth(0)
}


//
// deleteTail
//  @Description: 删除尾结点
//  @receiver l
//  @return int
//
func (l *singlylinkedlist) deleteTail() int {
	return l.deleteNth(l.size - 1)
}


//
// deleteNth
//  @Description: 删除指定位置的元素并返回其响应的元素值
//  @receiver l
//  @param position
//  @return int
//
func (l *singlylinkedlist) deleteNth(position int) int {
	l.checkBounds(position, 0, l.size - 1)
	if position == 0 {
		destroy := l.head
		deleteValue := destroy.value
		l.head = l.head.next
		destroy = nil
		l.size--
		return deleteValue
	}

	cur := l.head
	// 找到需要删除的元素的前一个位置
	for i := 0; i < position - 1; i++ {
		cur = cur.next
	}

	destroy := cur.next
	deleteValue := destroy.value
	cur.next = cur.next.next
	destroy = nil
	l.size--
	return deleteValue
}




//
// checkBounds
//  @Description: 判断所给的position是否超过了单链表的范围
//  @receiver l
//  @param position
//  @param low
//  @param high
//
func (l *singlylinkedlist) checkBounds(position int, low int, high int) {
	if position > high || position < low {
		panic("IndexOutOfBound")
	}
}


package singlylinkedlist

import (
	"fmt"
)

type Node struct {
	value int
	next  *Node
}

func NewNode(value int, next *Node) *Node {
	return &Node{value, next}
}

type singlylinkedlist struct {
	head *Node
	size int
}

//
// NewList
//  @Description: Init singly lined list with specified head and size
//  @param head
//  @param size
//  @return *singlylinkedlist
//
func NewList(head *Node, size int) *singlylinkedlist {
	return &singlylinkedlist{head, size}
}

//
// display
//  @Description: Display the value of each node in singly linked list
//  @receiver l
//
func (l *singlylinkedlist) display() {
	if l.isEmpty() {
		fmt.Println("The list to display is empty")
	}
	cur := l.head
	for cur != nil {
		if cur.next == nil {
			fmt.Println(cur.value)
			break
		}
		fmt.Print(cur.value, "->")
		cur = cur.next
	}
}

//
// detectLoop
//  @Description: Detect there is a loop in singly linked list (using slow&fast pointer)
//  @return bool
//
func (l *singlylinkedlist) detectLoop() bool {
	slow := l.head
	fast := l.head
	for (fast != nil) && (fast.next != nil) {
		slow = slow.next
		fast = fast.next.next
		if fast == slow {
			return true
		}
	}
	return false
}

//
// reverseList
//  @Description: Reverse a singly linked list
//  @receiver l
//
func (l *singlylinkedlist) reverseList() {

	var pre *Node
	cur := l.head
	nxt := l.head

	for cur != nil {
		nxt = cur.next
		cur.next = pre
		pre = cur
		cur = nxt
	}
	l.head = pre
}


//
// clear
//  @Description: Clear all nodes in singly linked list
//  @receiver l
//  @return res
//
func (l *singlylinkedlist) clear() (res []int) {

	cur := l.head
	for cur != nil {
		prev := cur
		res = append(res, prev.value)
		cur = cur.next
		prev = nil
	}
	l.head = nil
	l.size = 0
	return res
}

//
// isEmpty
//  @Description: Check if the list is empty
//  @receiver l
//  @return bool
//
func (l *singlylinkedlist) isEmpty() bool{
	return l.size == 0
}

//
// count
//  @Description: Return the size of list
//  @receiver l
//  @return int the count of the list
//
func (l *singlylinkedlist) length() int {
	return l.size
}


//
// getHead
//  @Description: Return head of the list
//  @receiver l
//  @return *Node the head of the list
//
func (l *singlylinkedlist) getHead() *Node {
	return l.head
}


//
// setHead
//  @Description: Set head of the list
//  @receiver l
//  @param node
//
func (l *singlylinkedlist) setHead(node *Node) {
	l.head = node
}

//
// count
//  @Description: Calculate count of the list manually
//  @receiver l
//  @return int the count of the list
//
func (l *singlylinkedlist) count() int {
	count := 0
	cur := l.head
	for cur != nil {
		count++
		cur = cur.next
	}
	return count

}

//
// search
//  @Description: Test if the value key is present in the list
//  @receiver l
//  @param key the value to be searched
//  @return bool {@code true} if key is present in the list, otherwise {@code false}
//
func (l *singlylinkedlist) search(key int) bool {
	cur := l.head
	for cur != nil {
		if cur.value == key {
			return true
		}
		cur = cur.next
	}
	return false
}

//
// getNth
//  @Description: Return element at special index
//  @receiver l
//  @param index
//  @return int
//
func (l *singlylinkedlist) getNth(index int) int {
	l.checkBounds(index, 0, l.size - 1)
	cur := l.head
	for i := 0; i < index; i++ {
		cur = cur.next
	}
	return cur.value
}


//
// insertHead
//  @Description: Insert an element at the head of the list
//  @receiver l
//  @param x
//
func (l *singlylinkedlist) insertHead(x int) {
	l.insertNth(x, 0)
}


//
// insertTail
//  @Description: Insert an element at the tail of the list
//  @receiver l
//  @param data
//
func (l *singlylinkedlist) insertTail(data int) {
	l.insertNth(data, l.size)
}



//
// insertNth
//  @Description: Insert a new node at a specified position of the list
//  @receiver l
//  @param data
//  @param position
//
func (l *singlylinkedlist) insertNth(data int, position int) {
	l.checkBounds(position, 0, l.size)
	newNode := NewNode(data, nil)
	if l.head == nil {
		l.head = newNode
		l.size++
		return
	}
	if position == 0 {
		newNode.next = l.head
		l.head = newNode
		l.size++
		return
	}

	cur := l.head
	for i := 0; i < position - 1; i++ {
		cur = cur.next
	}
	newNode.next = cur.next
	cur.next = newNode
	l.size++
}

//
// deleteHead
//  @Description: Delete a node at the head
//  @receiver l
//  @return int
//
func (l *singlylinkedlist) deleteHead() int {
	return l.deleteNth(0)
}


//
// deleteTail
//  @Description: Delete an element at the tail
//  @receiver l
//  @return int
//
func (l *singlylinkedlist) deleteTail() int {
	return l.deleteNth(l.size - 1)
}


//
// deleteNth
//  @Description: Delete an element at Nth position and return the deleted value
//  @receiver l
//  @param position
//  @return int
//
func (l *singlylinkedlist) deleteNth(position int) int {
	l.checkBounds(position, 0, l.size - 1)
	if position == 0 {
		destroy := l.head
		deleteValue := destroy.value
		l.head = l.head.next
		destroy = nil
		l.size--
		return deleteValue
	}

	cur := l.head
	// To find the node before the specified position
	for i := 0; i < position - 1; i++ {
		cur = cur.next
	}

	destroy := cur.next
	deleteValue := destroy.value
	cur.next = cur.next.next
	destroy = nil
	l.size--
	return deleteValue
}




//
// checkBounds
//  @Description: Check if the position in the range
//  @receiver l
//  @param position
//  @param low
//  @param high
//
func (l *singlylinkedlist) checkBounds(position int, low int, high int) {
	if position > high || position < low {
		panic("IndexOutOfBound")
	}
}
xiaozhulzq
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Go语言单链表实现方法
01-20
本文实例讲述了Go语言单链表实现方法。分享给大家供大家参考。具体如下： 1. singlechain.go代码如下： 代码如下:////////// //单链表 — 线性表 package singlechain //定义节点 type Node struct {  Data int  ...
go语言实现单链表，并提供相应函数
01-07
使用go语言实现一个单链表(保存内容为int),该链表提供以下方法  1).创建链表  2).在链表头部插入一个节点  3).返回链表元素个数  4).打印链表所有的元素 type Node struct { Data int Next *Node } type List...
Go实现单链表
09-02 224
golang实现单链表,golang练手项目
第一节 如何用Go实现单链表
weixin_34187862的博客
10-27 323
一、概念介绍 下面这副图是我们单链表运煤车队。 每节运煤车就是单链表里的元素，每节车厢里的煤炭就是元素中保存的数据。前后车通过锁链相连，作为单链表运煤车，从1号车厢开始，每节车厢都知道后面拉着哪一节车厢，却不知道前面是哪节车厢拉的自己。第一节车厢没有任何车厢拉它，我们就叫它车头，第五节车厢后面拉其他车厢，我们称为车尾。 作为单链表它最大的...
Go-如何优雅的实现单链表？（含全部代码）
热门推荐
关注网络安全、云原生安全
05-03 2万+
目录 简介 思路 节点结构体 属性 方法 单链表结构体 属性 方法 Init New Clear Len Front Back insert InsertAfter PushBack PushFront remove RemoveAfter RemoveFront 测试 常见问题 怎么遍历呀？ 全部代码 简介 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成是元素加指针。 思路
GO 单链表实现
杨玉庆的专栏
10-18 187
package link //package link import ( "fmt" ) type Student struct { Id int Name string } type Node struct { Student Next *Node } func (head *Node) Creat() *Node { head = nil return head } ...
go实现单链表
空山新雨后，天气晚来秋
02-26 862
山回路转不见君 雪上空留马行处 直接上代码 import "fmt" type DanNode struct { Data int Next *DanNode } type DanList struct { First *DanNode Last *DanNode Size int } // 创建一个空的单链表 func CreateNewDanAirList()......
详解go语言单链表及其常用方法的实现
01-21
在刷算法题中经常遇到关于链表的操作，在使用go语言去操作链表时不熟悉其实现原理，目的是为了重温链表这一基础且关键的数据结构。 1、链表的特点和初始化 1.1、链表的特点 用一组任意的存储单元存储线性表的数据...
Go语言构建单链表
稻草人技术博客
03-20 2035
package main import "fmt" type ListNode struct { Val int Next *ListNode } func main() { list := []int{2,4,3} head := &ListNode{Val:list[0]} tail := head //需要头尾两个指针 for i...
go语言实现--单链表
米兰的小铁匠1943的博客
03-11 1915
复习了一下程杰老师写的《大话数据结构》，书里是代码是C语言写的，我用golang把它们重新实现一遍以及做一点变动。 顺序表与链表是非常基本的数据结构，它们可以被统称为线性表。 线性表是由 n（n≥0）个数据元素（结点）a[0]，a[1]，a[2]…，a[n-1] 组成的有限序列。顺序表和链表，是线性表的不同存储结构。它们各自有不同的特点和适用范围。 下图摘自《大话数据结构》 ...
Go语言之实现一个简单的单链表
iqifenxia的博客
10-27 316
https://www.fgba.net/sitemap.xml
go 实现单向链表
实践求真知
05-27 359
一点睛 1 链表是有序的列表，它在内存中是存储如下。 2单链表示意图 一般来说，为了比较好的对单链表进行增删改查的操作，都会给它设置一个头结点，头结点的作用主要是用来标识链表头，本身这个结点不存放数据。 二 单链表实战 1 说明 使用带 head 头的单向链表实现 –水浒英雄排行榜管理。 完成对英雄人物的增删改查操作。 2代码 package main import ( "fmt" ) // HeroNode type HeroNode struct { n...
Go：数据结构，实现一个链表
qq_30883949的博客
07-03 148
Go：数据结构，实现一个链表 方法说明： func init_() {} 初始化，创建链表 func traverse_list(node_head *Node1) {} 遍历链表，根据输入的头节点 func get_tail(node_head *Node1) {} 根据输入的头节点得到尾节点 更改全局变量（由于该函数为递归函数，经过尝试发现无法用返回值或者引用传递的方法来返回尾节点所以使用赋值全局变量来获得尾节点，如有更好的方法，欢迎来品论区指示） func reverse_list(
单链表的初始化心得
GYGoyaya
09-21 1004
问题基于 单链表的
Golang 单链表基本操作
仗剑天涯
01-13 740
package linkedlist import ( "fmt" ) type ListNode struct { Data interface{} Next *ListNode } type LinkedList struct { head *ListNode length uint } func NewListNode(v interface{}) *ListNode...
【数据结构】链表 - Go 语言实现
weixin_44211968的博客
02-24 1540
本文主要展示了循环链表的 Go 语言实现，其他链表更简单。 理解了循环链表，其他简单链表便不在话下。
数据结构之Go实现单链表
weixin_43318506的博客
05-20 289
链表原理 单向链表是一种线性表，实际上是由节点组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它能知道下一个结点的存储位置。由N各节点（Node）组成单向链表，每一个Node记录本Node的数据及下一个Node。向外暴露的只有一个头节点（Head），我们对链表的所有操作，都是直接或者间接地通过其头节点来进行的。 代码实现 定义链表结构 package main import ( "fmt" ) type HeroNode struct {
【Golang】go实现单链表
smx_dd的博客
05-27 261
go语言实现单链表，支持尾插和尾删操作 package main import ( "fmt" ) type ListNode struct { val int next *ListNode } func CreateNode(value int) *ListNode { return &ListNode{value, nil} } func (list *ListN...
Golang实现一个简单的单链表
Gerald的博客
07-13 325
Golang实现一个简单的单链表 package list type Node struct { Data interface{} Next *Node } type List struct { size uint32 head *Node tail *Node } // 构造方法，将所有变量置空 func (list *List) init() { (*list).size = 0 (*list).head = nil (*list).tail = nil } func (list
go语言实现循环单链表
最新发布
04-03
以下是使用Go语言实现循环单链表的示例代码： ```go package main import ( "fmt" ) type Node struct { data interface{} next *Node } type CircularLinkedList struct { head *Node tail *Node size ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值