单链表(golang版本)

最新推荐文章于 2024-05-20 23:29:47 发布
最新推荐文章于 2024-05-20 23:29:47 发布
阅读量104 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myz_lemon/article/details/109132026
版权

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

package main

import(
	"fmt"
	"errors"
)


type Node struct{
	 Value interface{}
	 Next *Node
}

type LinkList struct{
	 head *Node
	 size int //统计链表中元素的个数
	 num int  //限制链表的最大长度
}

func NewLinkList(num int) *LinkList{
	if num <=0{
		num = 100
	}
	return &LinkList{
		num:num,
	}
}

//在头部插入,暂时不限制链表的长度
func (link *LinkList)Head(val interface{})(bool,error) {

	if link.size >= link.num{
		return false,errors.New("链表容量达到上限,请进行扩容")
	}

	if link.head == nil {
		node := &Node{
			Value: val,
			Next: nil,
		}
		link.head = node
		link.size++
	}else{
		node := &Node{
			Value: val,
			Next: link.head,
		}
		link.head = node
		link.size++
	}
	return true,nil
}

//在尾部添加元素
func (link *LinkList) After(val interface{}) (bool,error){
	if link.size >= link.num{
		return false,errors.New("链表容量达到上限,请进行扩容")
	}
	node := link.head
	if node == nil{
		newNode := &Node{
			Value:val,
		}
		link.head = newNode
		link.size++
		return false,nil
	}

	for{
		if node.Next != nil {
		   node = node.Next
		}else{
			break
		}
	}
	newNode := &Node{
		Value:val,
	}
	node.Next = newNode 
	link.size++
	return true,nil
}


//遍历输出链表
func (link *LinkList) Range()(slice []interface{}){
	node := link.head
	if node == nil {
		return
	}

	for{
		slice = append(slice,(*node).Value)
		node = node.Next
		if node == nil {
			break
		}
	}
	return
}

func (link *LinkList) Size() int{
	return link.size
}

//在指定索引位置插入元素
func (link *LinkList) Insert(index int,val interface{})(bool,error){

	if index <0 || index >= link.size{
		return false,errors.New("index out of bounds")
	}

	var count int = 1
	node := link.head
	if node == nil {
		newNode := &Node{
			Value: val,
		}
		link.head = newNode
		link.size++
		return true,nil
	}

	if index == 0{
		newNode := &Node{
			Value:val,
			Next:link.head,
		}
		link.head = newNode
		link.size++
		return true,nil
	}
	for{
		node = node.Next
		if count == index{
			break
		}
		count++
	}
	newNode := &Node{
		Value:node.Value,
		Next:node.Next,
	}
	node.Value = val
	node.Next = newNode
	link.size++
	return true,nil
}

//根据索引来删除
func (link *LinkList) DeleteByIndex(index int)(bool,error){

	if index < 0 || index >= link.size{
		return false,errors.New("index out of bounds")
	}

	var count int = 0
	node := link.head
	if node == nil {
		return true,nil
	}

	if index == 0{
		link.head = link.head.Next
		link.size--
		return true,nil
	}
	count = 1

	for{
		node = node.Next
		if count == index-1{
			break
		}
		count++
	}
	if node == nil {
		return true,errors.New("link list is emtpy")
	}
	node.Next = node.Next.Next
	link.size--
	return true,nil
}


//根据值来删除node
func (link *LinkList) DeleteByValue(value interface{})(bool,error){

	node := link.head
	if node == nil {
		return false,errors.New("link list is empty")
	}

	if node.Value == value{
		link.head = node.Next
		link.size--
		return true,nil
	}

	var last [2]*Node
	for{
		last[0] = node
		if node.Next == nil {
			break
		}
		node = node.Next
		if node.Value == value{
			last[1] = node
			break
		}
	}

	if node == nil {
		return false,errors.New("link list is emtpy")
	}

	fmt.Printf("last[0]:%#v, last[1]:%#v\n",last[0],last[1])

	if last[1] == nil{
		return false,errors.New("%v not foud in link list")
	}

	if last[1].Next == nil{
	  last[0].Next = nil
	  last[1] = nil
	}else{
		last[0].Next = last[1].Next
	}
	link.size--
	return true,nil
}


//假定任务数据是int类型的,实际应用中做类型断言
func (link *LinkList) BubbleSort(arr []interface{}){

	for i:=0; i < len(arr);i++{
		for j:=0; j <len(arr)-i-1;j++{
			if arr[j].(int) > arr[j+1].(int){
				arr[j],arr[j+1] = arr[j+1],arr[j]
			}
		}
	}
}


//假定任务数据是int类型的,实际应用中做类型断言
func (link *LinkList) BinarySearch(arr []interface{},leftIndex int,rightIndex int,val int)(i int){
	if leftIndex > rightIndex{
		return -1
	}
	middle := (leftIndex+rightIndex)/2
	if arr[middle].(int) > val{
	   return link.BinarySearch(arr,leftIndex,middle-1,val)
	} else if arr[middle].(int)< val{
	  return link.BinarySearch(arr,middle+1,rightIndex,val)
	} else{
		return middle
	}
	return middle
}

//自动扩容
func (link *LinkList) check(){

}


func main(){
	link := NewLinkList(1000)
	/*link.Head(1)
	link.Head(2)
	link.Head(3)
	link.Head(4)
	*/

	link.After(1)
	link.After(2)
	link.After(3)
	link.After(4)
	link.Head(10)
	link.Head(30)
	link.Head(40)
	link.Head(10)
	link.After(8)
	link.After(22)
	fmt.Println(link.Range())
	fmt.Println("link list size:",link.Size())
	/*link.Insert(link.Size()-1,5)
	fmt.Println(link.Range())
	link.Insert(link.Size()-1,6)
	fmt.Println(link.Range())
	*/

	arr := link.Range()
	link.BubbleSort(arr)
	fmt.Println(arr)
	index := link.BinarySearch(arr,0,len(arr)-1,40)
	fmt.Printf("40 in arr of index:%d\n",index)

	index = link.BinarySearch(arr,0,len(arr)-1,1)
	fmt.Printf("1 in arr of index:%d\n",index)

	index = link.BinarySearch(arr,0,len(arr)-1,4)
	fmt.Printf("4 in arr of index:%d\n",index)

	fmt.Println("\n\n")

	/*
	fmt.Println("link list size:",link.Size())
	fmt.Println(link.Range())
	link.DeleteByValue(2)
	fmt.Println("link list size:",link.Size())
	fmt.Println(link.Range())

	fmt.Println("\n\nlink list size:",link.Size())
	fmt.Println(link.Range())
	link.DeleteByValue(3)
	fmt.Println("link list size:",link.Size())
	fmt.Println(link.Range())

	fmt.Println("\n\nlink list size:",link.Size())
	fmt.Println(link.Range())
	link.DeleteByValue(4)
	fmt.Println("link list size:",link.Size())
	fmt.Println(link.Range())

	fmt.Println("\n\nlink list size:",link.Size())
	fmt.Println(link.Range())
	link.DeleteByValue(4)
	fmt.Println("link list size:",link.Size())
	fmt.Println(link.Range())

	fmt.Println("\n\n")
	*/


	/**fmt.Println("\n删除操作:")
	fmt.Println(link.Range())
	fmt.Println("之前link list size:",link.Size())
    link.DeleteByIndex(0)
	fmt.Println("之后link list size:",link.Size())
	fmt.Println(link.Range())
	*/

	/*
	fmt.Println("\n删除操作:")
	fmt.Println(link.Range())
	fmt.Println("之前link list size:",link.Size())
    link.DeleteByIndex(link.Size()-1)
	fmt.Println("之后link list size:",link.Size())
	fmt.Println(link.Range())


	fmt.Println("\n删除操作:")
	fmt.Println("之前link list size:",link.Size())
	fmt.Println(link.Range())
    link.DeleteByIndex(2)
	fmt.Println("之后link list size:",link.Size())
	fmt.Println(link.Range())

	fmt.Println("\n删除操作:")
	fmt.Println("之前link list size:",link.Size())
	fmt.Println(link.Range())
    link.DeleteByIndex(3)
	fmt.Println("之后link list size:",link.Size())
	fmt.Println(link.Range())

	fmt.Println("\n删除操作:")
	fmt.Println("之前link list size:",link.Size())
	fmt.Println(link.Range())
    link.DeleteByIndex(2)
	fmt.Println("之后link list size:",link.Size())
	fmt.Println(link.Range())

	fmt.Println("\n删除操作:")
	fmt.Println("之前link list size:",link.Size())
	fmt.Println(link.Range())
    link.DeleteByIndex(0)
	fmt.Println("之后link list size:",link.Size())
	fmt.Println(link.Range())

	fmt.Println("\n删除操作:")
	fmt.Println("之前link list size:",link.Size())
	fmt.Println(link.Range())
	_,err :=link.DeleteByIndex(0)
	fmt.Println("err:",err)
	fmt.Println("之后link list size:",link.Size())
	fmt.Println(link.Range())

	fmt.Println("\n删除操作:")
	fmt.Println("之前link list size:",link.Size())
	fmt.Println(link.Range())
	_,err =link.DeleteByIndex(0)
	if err != nil {
		fmt.Printf("err:%v\n",err)
		return
	}
	fmt.Println("之后link list size:",link.Size())
	fmt.Println(link.Range())
	*/


}
柠檬(lemon)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang数据结构-单链表
qq_43498850的博客
03-31 451
文章目录一、Golang数据结构-单链表1.基本介绍2.处理方法二、使用步骤1.使用一个结构体管理单链表2.添加链表数据(方法一)2.添加链表数据(方法二)3.显示链表的所有结点信息4.修改链表数据5.删除链表数据6.编写一个主函数测试三、运行结果1.链表插入结点第一种方法演示2.链表插入结点第二种方法演示总结 一、Golang数据结构-单链表 1.基本介绍 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的..
Golang-Grokking-the-Coding-Interview-Patterns-for-Coding-Questions:Golang版本的“浏览编码面试”
03-13
2. 链表：单链表、双链表以及循环链表，用于实现动态存储。 3. 栈与队列：栈遵循“后进先出”（LIFO）原则，队列遵循“先进先出”（FIFO）原则。 4. 树结构：二叉树、平衡树（如AVL树和红黑树）和图，用于组织和检索...
单链表(golang)
流年似水
11-19 134
package LinkedList //define node type Node struct { data int next *Node } //define linklist type LinkedList struct { head *Node } //Init LinkList func (list *LinkedList) InitList(params []int) {...
Golang——实现单链表
最新发布
qq_61453210的博客
05-20 296
单链表（Single Linked List）是链表数据结构的一种实现方式，它包含一系列节点（Node），每个节点都包含一个数据域和一个指向下一个节点的指针。定义了一个根节点head，定义了5个要添加的节点，并将他们按照顺序添加，之后打印显示出整个链表，然后删除掉节点id为"1"的数据，并再次打印显示链表。通过定义辅助节点，找到链表的最后一个节点，并将要添加的节点添加到找到的节点的下一个节点。通过定义结构体实现单链表的操作，no为链表中节点的id，name为节点id对应的内容，next为下一个节点的信息。
单链表（golang实现）
weixin_44079228的博客
04-08 250
个人github（包括golang学习笔记、源码）：https://github.com/fangguizhen/Notes/blob/master/Golang%E7%9F%A5%E8%AF%86%E7%82%B9.md 说明：主要演示单链表的添加、显示和删除 一、编写第1种插入方法，在单链表最后加入 package main import "fmt" //单链表的添加、显...
golang实现单链表
skh2015java的博客
01-31 1875
package main //链表实现 import ( "fmt" ) //定义元素类型 type Element interface {} //定义节点 type linkNode struct { Data Element //数据域 Nest *linkNode //指针域，指向下一个节点 } func NewLinkNode() *linkNode{ return
单链表源码，包括增删改查
03-14
单链表源码，包括增删改查
python/golang实现循环链表的示例代码
09-16
循环链表是一种特殊的链式数据结构，它与普通单链表的主要区别在于最后一个节点的`next`指针不是`None`或`nil`，而是指向链表的第一个节点，形成了一个环形结构。这种数据结构在某些算法和场景中非常有用，例如在...
awesome-go-datastruct：golang的DataStruct
02-05
单向链表（LinkedList） 1.1链表逆序1.2去除重复项1.3两链表表示的数字相加1.4链表从中间反转1.5遍历一次找到链表的倒数第k个中断1.6发现带环链表的环入口点1.7将单链表两两反转1.8单链表的前k个元素反转1.9合并两个...
4. golang数据结构之单向链表
weixin_43893483的博客
09-04 286
1. 链表的介绍 链表是有序的列表，但是它在内存中的存储如下： 2. 单链表的介绍 单链表的示意图： 说明：一般来说，为了比较好的对单链表进行增删改查的操作，我们都会给他设置一个头结点，头结点的作用主要是用来标识链表头，本身这个结点不存放数据。 3. 单链表的应用案例 案例的说明： 使用带head头的单向链表实现 — 王者荣耀排行榜管理 完成对英雄任务的增删改查操作，注：删除和修改，查找 第一种方法：在添加英雄时，直接添加到链表的尾部 代码实现： ...
单链表（golang）
YHongmu的博客
05-15 89
提示：刷左神视频有感，B站视频链接：https://www.bilibili.com/video/BV13g41157hK 文章目录前言一、判断单链表是否有环，及入环节点二、TODO 前言 针对单链表的操作，算法题主要考核重点是如何做得最优空间复杂度。 链表主要知识点： 1、遍历链表，用哈希表（或数组）记录全部值； 2、快慢指针。 一、判断单链表是否有环，及入环节点 代码如下： type Node struct { Val int32 Next *Node } // JudgeLoop 判.
Golang实现单链表
Samdom的博客
07-29 245
Github地址：https://github.com/zhoushaodong666/Go-DataStructuresAlgorithms 单链表实现 package _1_linklist import ( "fmt" "github.com/pkg/errors" ) /* Project: 单链表的基本操作 Author: zhoushaodong Email: 11388946...
【链表算法】单链表--golang
weixin_41198062的博客
04-06 331
链表 链表的用处 对比数组，在数据量不固定时，链表便于插入和删除，查询效率较低 golang声明单链表类型 // 定义单链表 type ListLinkNode struct { Val int Next *ListLinkNode } 删除单链表中的节点 // 链表的操作 // 删除节点 func DeleteFromSingleLinkV(node *ListLinkNode, val int) *ListLinkNode { // 定义虚拟头节点 root := &ListLi
golang 单链表实现
zuiyijiangnan的博客
02-03 313
//单链表实现 /************************ 1.判断是否为空的单链表 2.单链表的长度 3.从头部添加元素 4.送尾部添加元素 5.在指定位置添加元素 6.删除指定元素 7.删除指定位置元素 8.查看是否包含某个元素 9.遍历所有元素 *************************/ type Object interface{} type Node struct { Data Object //定义数据域 Nex.
golang 实现单链表
lucky404的博客
05-31 1367
package main import "fmt" /* 使用golang实现单链表 add 操作:在链表首部添加 append 操作:在链表尾部添加,从头部找到最后一个元素,把最后一个元素指针指向需要添加的元素 insert 操作:在指定位置添加,往中间插入元素,需要调整插入该位置的元素之前的指针,还有该元素的指针需要指向下一位 delete 操作:删除指定的元素,删除任意位置的...
Go语言实现单链表
m0_53318344的博客
06-21 1452
单链表的操作有创建一个链表通过数组，遍历单链表，尾部插入，指定位置插入，删除指定位置的元素，查找指定的节点等。1.Go语言的语法还是和其他语言不同的，比如函数返回值，参数的定义2.Go语言可以使用vscode，idea goland去编写代码。3.Go语言的命名规则和其他语言也不同，首字母大写表示public，小写表示private。
golang 版本升
04-19
Golang（Go语言）是一种开源的编程语言，由Google开发。升级Golang版本通常是为了获取新的功能、修复已知的问题或者提高性能。以下是升级Golang版本的一般步骤： 1. 查看当前版本：使用命令`go version`可以查看当前安装的Golang版本。 2. 检查新版本：访问Golang官方网站（https://golang.org/dl/）或者GitHub仓库（https://github.com/golang/go/releases）查看最新的Golang版本。 3. 下载新版本：根据你的操作系统选择合适的二进制包下载，并解压到指定目录。 4. 更新环境变量：将新版本的Golang路径添加到系统的环境变量中，以便在命令行中可以直接使用新版本。 5. 测试新版本：在命令行中输入`go version`确认新版本已经生效。然后，可以尝试编译和运行你的项目，确保没有出现兼容性问题。 6. 迁移项目：如果你的项目依赖了特定的Golang版本，需要进行相应的迁移工作。可以使用工具如Go Modules来管理项目依赖，并确保项目在新版本下正常工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值