golang数据结构 - 链表

已于 2023-04-18 15:29:09 修改
阅读量376 收藏 3
点赞数
分类专栏： goland go 文章标签： 链表 数据结构 golang
于 2022-09-04 00:19:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41395435/article/details/126681969
版权
go 同时被 2 个专栏收录
13 篇文章 0 订阅
订阅专栏
goland
6 篇文章 0 订阅
订阅专栏

文章目录

单链表

在这里插入图片描述

  • 拥有头节点
  • 每个节点有两个字段
      data : 存储数据
      next : 指向下一个节点的指针

上代码 :

package link

import (
	"fmt"
)

// 单向链表

type IOneWayLinkList interface {
	InsertOnHead(value int)                  //从链表头部插入
	InsertOnEnd(value int)                   //从尾部添加元素
	InsertOnIndex(value int, index int)      //在指定位置添加元素  index是下标，从0开始,
	DelDataOnIndex(index int)                //删除链表指定位置的节点, index是下标，从0开始
	DelData(value int)                       //删除链表指定值的节点
	PrintLink()                              //打印链表所有节点
	FindValue(value int) bool                //查询链表中是否包含某个值
	UpdateValueByIndex(index int, value int) //根据index修改值为value, index是下标，从0开始
}

// Node 节点
type Node struct {
	data int // 节点数据
	next *Node
}

// List 链表
type List struct {
	head   *Node  // 头节点
	length uint64 // 链表长度
}

func InitOneWayLinkList() IOneWayLinkList {
	return &List{
		head:   nil,
		length: 0,
	}
}

func (l *List) InsertOnHead(value int) {
	n := &Node{
		data: value,
		next: nil,
	}

	if l.head == nil {
		l.head = n
		l.length++
		fmt.Println("InsertOnHead success, this head")
		return
	}
	n.next = l.head
	l.head = n
	l.length++
	fmt.Println("InsertOnHead success")
}

func (l *List) InsertOnEnd(value int) {
	n := &Node{
		data: value,
		next: nil,
	}

	if l.head == nil {
		l.head = n
		l.length++
		fmt.Println("InsertOnEnd success, this head")
		return
	}
	cur := l.head
	for cur.next != nil {
		cur = cur.next
	}
	// 找到链表尾部了
	cur.next = n
	l.length++
	fmt.Println("InsertOnEnd success")
}

func (l *List) InsertOnIndex(value int, index int) {
	if index < 0 {
		fmt.Println("InsertOnIndex error, index error")
		return
	}

	n := &Node{
		data: value,
		next: nil,
	}

	if l.head == nil {
		l.head = n
		l.length++
		fmt.Println("InsertOnIndex success")
		return
	}

	if index == 0 {
		l.InsertOnHead(value)
	}

	i := 1
	cur := l.head
	for cur.next.next != nil {
		if i == index {
			n.next = cur.next
			cur.next = n
			l.length++
			fmt.Println("InsertOnIndex success")
			return
		}
		i++
		cur = cur.next
	}
	// 走到这里 cur.next.next 为nil, 说明可能要插在链表尾部的前一个, cur.next是最后一个元素
	if i == index {
		n.next = cur.next
		cur.next = n
		l.length++
		fmt.Println("InsertOnIndex success")
	} else {
		fmt.Println("InsertOnIndex error, index error")
	}
}

func (l *List) DelDataOnIndex(index int) {
	if index < 0 {
		fmt.Println("DelDataOnIndex error, index < 0, error")
		return
	}

	// 删除头节点
	if index == 0 {
		l.head = l.head.next
		l.length--
		fmt.Println("DelDataOnIndex success, is head")
		return
	}

	i := 1
	cur := l.head
	for cur.next.next != nil {
		if i == index {
			cur.next = cur.next.next
			l.length--
			fmt.Println("DelDataOnIndex success, index:", index)
			return
		}
		i++
		cur = cur.next
	}
	// 到了这里，说明 cur.next.next == nil, 可能要删除最后一个, cur.next是最后一个元素
	if i == index {
		cur.next = cur.next.next
		l.length--
		fmt.Println("DelDataOnIndex success, index:", index)
	} else {
		fmt.Println("DelDataOnIndex error, index not found")
	}
}

func (l *List) DelData(value int) {
	// 先看是不是要删除头节点
	cur := l.head
	if cur.data == value {
		l.head = l.head.next
		l.length--
		fmt.Println("DelData success, value:", value)
		return
	}
	// 找下一个
	for cur.next.next != nil {
		if cur.next.data == value {
			cur.next = cur.next.next
			l.length--
			fmt.Println("DelData success, value:", value)
			return
		}
		cur = cur.next
	}
	// 到了这里，说明 cur.next.next == nil, 可能要删除最后一个, cur.next是最后一个元素
	if cur.next.data == value {
		cur.next = cur.next.next
		l.length--
		fmt.Println("DelData success, value:", value)
	} else {
		fmt.Println("DelData fail, value not found")
	}

}

func (l *List) PrintLink() {
	if l.head == nil {
		fmt.Println("list is nil")
		return
	}
	cur := l.head
	count := 0
	for cur != nil {
		fmt.Println("node data:", cur.data, ", index:", count)
		cur = cur.next
		count++
	}
	fmt.Println("link length:", l.length)
}

func (l *List) FindValue(value int) bool {
	cur := l.head
	for cur != nil {
		if cur.data == value {
			return true
		}
		cur = cur.next
	}
	return false
}

func (l *List) UpdateValueByIndex(index int, value int) {
	if index < 0 {
		fmt.Println("UpdateValueByIndex fail, index < 0")
		return
	}
	i := 0
	cur := l.head
	for cur != nil {
		if i == index {
			old := cur.data
			cur.data = value
			fmt.Println("UpdateValueByIndex success,", old, "->", value)
			return
		}
		i++
		cur = cur.next
	}
	fmt.Println("UpdateValueByIndex fail, index not found")
}

测试代码：

// TestOneWayLinkList 测试单向链表
func TestOneWayLinkList() {
	list := link.InitOneWayLinkList()

	list.InsertOnHead(1)
	list.InsertOnHead(2)
	list.InsertOnHead(3)
	list.InsertOnHead(4)
	list.PrintLink()

	list.InsertOnEnd(5)
	list.InsertOnEnd(6)
	list.InsertOnEnd(12)
	list.PrintLink()

	list.InsertOnIndex(33, 4)
	list.PrintLink()

	list.DelDataOnIndex(5)
	list.PrintLink()
	list.DelDataOnIndex(45)
	list.PrintLink()

	list.DelData(1)
	list.PrintLink()

	value := 33
	res := list.FindValue(value)
	if res {
		fmt.Println("list found value:", value)
	} else {
		fmt.Println("list not found value:", value)
	}

	value2 := 46
	list.UpdateValueByIndex(5, value2)
	list.PrintLink()
	list.UpdateValueByIndex(12, value2)
	list.PrintLink()
}

单向循环链表

在这里插入图片描述

  • 拥有头节点
  • 拥有尾节点, 尾节点的下一个指向头节点
  • 每个节点有两个字段
      data : 存储数据
      next : 指向下一个节点的指针

上代码

package link

import "fmt"

// 单向循环链表

type OneLoopNode struct {
	data int
	next *OneLoopNode
}

type OneLoopLink struct {
	head   *OneLoopNode
	tail   *OneLoopNode
	length int
}

type OneLoopLinkInterface interface {
	InsertToHead(value int)                    // 添加元素到链表头部
	InsertToTail(value int)                    // 添加元素到链表尾部
	InsertByIndex(index, value int) bool       // 添加元素在指定位置  index是下标，从0开始,
	DeleteByIndex(index int) bool              // 删除链表指定位置的节点, index是下标，从0开始
	DeleteByValue(value int) bool              // 删除链表指定值的节点
	ModifyByIndex(index, value int) bool       // 修改 index 下标的值为value, 下标从0开始
	ModifyByValue(oldValue, newValue int) bool // 修改 oldValue值为 newValue
	SearchByIndex(index int) (int, bool)       // 查询 index 下标对应节点value值, index是下标，从0开始
	SearchByValue(value int) (int, bool)       // 查询 value 值对应节点的 index 下标,从0开始
	PrintfLink()                               // 打印链表所有数据
}

func NewOneLoopLink() OneLoopLinkInterface {
	return &OneLoopLink{
		head:   nil,
		tail:   nil,
		length: 0,
	}
}

func (o *OneLoopLink) InsertToHead(value int) {
	newNode := &OneLoopNode{}
	newNode.data = value
	newNode.next = nil

	if o.head == nil {
		o.head = newNode
		o.tail = newNode
		o.tail.next = o.head
		o.length++
		return
	}

	newNode.next = o.head
	o.tail.next = newNode
	o.head = newNode
	o.length++

	fmt.Println("InsertToHead success")
}

func (o *OneLoopLink) InsertToTail(value int) {
	newNode := &OneLoopNode{}
	newNode.data = value
	newNode.next = nil

	if o.head == nil {
		o.head = newNode
		o.tail = newNode
		o.tail.next = o.head
		o.length++
		return
	}

	o.tail.next = newNode
	o.tail = newNode
	newNode.next = o.head
	o.length++

	fmt.Println("InsertToTail success")
}

func (o *OneLoopLink) InsertByIndex(index, value int) bool {
	if index == 0 || o.head == nil {
		o.InsertToHead(value)
		return true
	}
	if index == o.length-1 {
		o.InsertToTail(value)
		return true
	}
	if index >= o.length {
		fmt.Println("InsertByIndex fail")
		return false
	}

	newNode := &OneLoopNode{}
	newNode.data = value
	newNode.next = nil
	cur := o.head.next
	pre := o.head
	count := 1
	// 先干活再判断
	for {
		if count == index {
			newNode.next = cur
			pre.next = newNode
			o.length++
			fmt.Println("InsertByIndex success")
			return true
		}
		if cur.next == o.head {
			break
		}
		cur = cur.next
		pre = pre.next
		count++
	}
	return false
}

func (o *OneLoopLink) DeleteByIndex(index int) bool {
	if index >= o.length {
		fmt.Println("DeleteByIndex fail")
		return false
	}
	if o.head == o.tail {
		// 只有一个节点
		o.head = nil
		o.tail = nil
		o.length = 0
		fmt.Println("DeleteByIndex success")
		return true
	}
	if index == 0 {
		// 删除头节点
		o.tail.next = o.head.next
		o.head = o.head.next
		o.length--
		fmt.Println("Delete head success, ")
		return true
	}
	cur := o.head.next
	pre := o.head
	count := 1
	for {
		if count == index {
			if index == o.length-1 {
				// 删除尾节点
				pre.next = cur.next
				o.tail = pre
				o.length--
				fmt.Println("Delete tail success")
				return true
			}
			pre.next = cur.next
			o.length--
			fmt.Println("DeleteByIndex success,index=", index)
			return true
		}
		if cur == o.tail {
			break
		}
		cur = cur.next
		pre = pre.next
		count++
	}

	fmt.Println("DeleteByIndex fail")
	return false
}

func (o *OneLoopLink) DeleteByValue(value int) bool {
	if o.head == o.tail {
		// 只有一个节点
		o.head = nil
		o.tail = nil
		o.length = 0
		fmt.Println("DeleteByValue success, value=", value)
		return true
	}

	if o.head.data == value {
		o.tail.next = o.head.next
		o.head = o.head.next
		o.length--
		fmt.Println("DeleteByValue success, value=", value)
		return true
	}

	cur := o.head.next
	pre := o.head
	for {
		if cur.data == value {
			pre.next = cur.next
			o.length--
			fmt.Println("DeleteByValue success, value=", value)
			return true
		}
		if cur == o.tail {
			// 绕到尾巴了还没找到,退出
			break
		}
		cur = cur.next
		pre = pre.next
	}

	return false
}

func (o *OneLoopLink) ModifyByIndex(index, value int) bool {
	if index >= o.length {
		fmt.Println("index too long...")
		return false
	}

	// 先把头节点的情况处理了
	if index == 0 {
		fmt.Println("ModifyByIndex success, index:", index, " value:", o.head.data, " change to:", value)
		o.head.data = value
		return true
	}

	cur := o.head.next
	pre := o.head
	num := 1
	for {
		if num == index {
			fmt.Println("ModifyByIndex success, index:", num, " value:", cur.data, " change to:", value)
			cur.data = value
			return true
		}
		if num >= o.length {
			// 没找到
			break
		}
		cur = cur.next
		pre = pre.next
		num++
	}
	return false
}

func (o *OneLoopLink) ModifyByValue(oldValue, newValue int) bool {
	if o.head.data == oldValue {
		fmt.Println("ModifyByValue success, oldValue:", o.head.data, " change to:", newValue)
		o.head.data = newValue
		return true
	}
	cur := o.head.next
	pre := o.head
	for {
		if cur.data == oldValue {
			cur.data = newValue
			fmt.Println("ModifyByValue success, oldValue:", cur.data, " change to:", newValue)
			return true
		}
		if cur == o.tail {
			break
		}
		cur = cur.next
		pre = pre.next
	}
	return false
}

func (o *OneLoopLink) SearchByIndex(index int) (int, bool) {
	if index < 0 || index > o.length {
		fmt.Println("index error")
		return 0, false
	}
	if index == 0 {
		fmt.Println("SearchByIndex success, index:", index, " value is:", o.head.data)
		return o.head.data, true
	}
	if index == o.length-1 {
		fmt.Println("SearchByIndex success, index:", index, " value is:", o.tail.data)
		return o.tail.data, true
	}
	p := 1
	cur := o.head.next
	for cur != o.tail {
		if p == index {
			fmt.Println("SearchByIndex success, index:", index, " value is:", cur.data)
			return cur.data, true
		}
		cur = cur.next
		p++
	}

	fmt.Println("SearchByIndex failed, index:", index)
	return 0, false
}

func (o *OneLoopLink) SearchByValue(value int) (int, bool) {
	if o.head.data == value {
		fmt.Println("SearchByValue success, value:", value, " index is: 0", o.head.data)
		return o.head.data, true
	}
	if o.tail.data == value {
		fmt.Println("SearchByValue success, value:", value, " index is: ", o.length-1)
		return o.tail.data, true
	}
	cur := o.head.next
	index := 1
	for cur != o.tail {
		if cur.data == value {
			fmt.Println("SearchByValue success, value:", value, " index is:", index)
			return cur.data, true
		}
		cur = cur.next
		index++
	}

	fmt.Println("SearchByValue failed, value:", value)
	return 0, false
}

func (o *OneLoopLink) PrintfLink() {
	if o.head == nil {
		fmt.Println("link is nil")
		return
	}

	cur := o.head
	count := 0
	//先打印再判断
	for {
		fmt.Println("index=", count, ", value=", cur.data, ", next=", cur.next.data)
		if cur.next == o.head {
			break
		}
		cur = cur.next
		count++
	}
	fmt.Println("link length=", o.length)
}

测试用例:

// TestOneWayLoopLink 测试单向循环链表
func TestOneWayLoopLink(t *testing.T) {
	oneLoopLink := link.NewOneLoopLink()
	oneLoopLink.InsertToHead(4)
	oneLoopLink.InsertToHead(3)
	oneLoopLink.InsertToHead(2)
	oneLoopLink.InsertToHead(1)
	oneLoopLink.PrintfLink()

	oneLoopLink.InsertToTail(5)
	oneLoopLink.InsertToTail(6)
	oneLoopLink.InsertToTail(7)
	oneLoopLink.InsertToTail(8)
	oneLoopLink.InsertToTail(9)
	oneLoopLink.PrintfLink()

	ok := oneLoopLink.InsertByIndex(3, 18)
	if ok {
		oneLoopLink.PrintfLink()
	}

	ok = oneLoopLink.DeleteByIndex(5)
	if ok {
		oneLoopLink.PrintfLink()
	}

	ok = oneLoopLink.DeleteByValue(7)
	if ok {
		oneLoopLink.PrintfLink()
	}

	ok = oneLoopLink.ModifyByIndex(2, 9981)
	if ok {
		oneLoopLink.PrintfLink()
	}

	ok = oneLoopLink.ModifyByValue(18, 81)
	if ok {
		oneLoopLink.PrintfLink()
	}

	oneLoopLink.SearchByIndex(6)
	oneLoopLink.SearchByValue(8)
}

双向循环链表

  • pre：上一个节点，next：下一个节点
  • 头节点的 pre 指向尾节点
  • 尾节点的 next 指向头节点

在这里插入图片描述

上代码：

import "fmt"

// 双向循环链表
// 代码的index是从1开始算

type DoubleNode struct {
	data int
	next *DoubleNode
	pre  *DoubleNode
}

type DoubleListInterface interface {
	InsertHead(value int)                     // 头部插入
	InsertTail(value int)                     // 尾部插入
	InsertByIndex(value int, index int)       // 根据位置插入 index是从1开始算
	DeleteByIndex(index int)                  // 根据位置删除 index是从1开始算
	DeleteByValue(value int)                  // 根据值删除
	UpdateByIndex(index int, newValue int)    // 根据位置修改 index是从1开始算
	UpdateByValue(oldValue int, newValue int) // 根据值删除
	GetIndexByValue(value int) (int, bool)    // 根据值获取位置 只有一种错误可能，就返回bool
	GetValueByIndex(index int) (int, bool)    // 根据位置获取值
	PrintList()
}

type DoubleList struct {
	head   *DoubleNode
	tail   *DoubleNode
	length int
}

func NewDoubleList() *DoubleList {
	return &DoubleList{
		head:   nil,
		tail:   nil,
		length: 0,
	}
}

func (d *DoubleList) InsertHead(value int) {
	newData := &DoubleNode{
		data: value,
		next: nil,
		pre:  nil,
	}
	if d.head == nil {
		// 链表没有数据
		d.head = newData
		d.tail = newData
		newData.next = newData
		newData.pre = newData
	} else {
		// 链表有数据
		newData.next = d.head
		newData.pre = d.tail
		d.tail.next = newData
		d.head.pre = newData
		d.head = newData
	}

	d.length++
}

func (d *DoubleList) InsertTail(value int) {
	newNode := &DoubleNode{
		data: value,
		next: nil,
		pre:  nil,
	}
	if d.head == nil {
		// 链表没有数据
		d.head = newNode
		d.tail = newNode
		newNode.next = newNode
		newNode.pre = newNode
	} else {
		// 链表有数据
		newNode.pre = d.tail
		newNode.next = d.head
		d.tail.next = newNode
		d.head.pre = newNode
		d.tail = newNode
	}

	d.length++
}

func (d *DoubleList) InsertByIndex(value int, index int) {
	if index > d.length || index <= 0 {
		fmt.Println("index error")
		return
	}
	newNode := &DoubleNode{
		data: value,
		next: nil,
		pre:  nil,
	}
	if d.head == nil {
		d.InsertHead(value)
		return
	}
	if index == d.length {
		d.InsertTail(value)
	}

	cur := d.head
	// cur指向头节点的时候, count=1
	count := 1
	for cur != d.tail {
		if count == index {
			newNode.next = cur
			newNode.pre = cur.pre
			cur.pre.next = newNode
			cur.pre = newNode
			d.length++
		}
		cur = cur.next
		count++
	}

}

func (d *DoubleList) DeleteByIndex(index int) {
	if d.head == nil {
		fmt.Println("link nil")
		return
	}
	if index > d.length || index <= 0 {
		fmt.Println("index error")
		return
	}

	if d.head == d.tail {
		// 只有一个节点
		d.head = nil
		d.tail = nil
		d.length = 0
		return
	}

	cur := d.head
	// cur指向头节点的时候, count=1
	count := 1
	fmt.Println("DeleteByIndex:", index)
	// 当cur转了一圈回到头节点时候，count肯定不等于1，退出循环
	for cur != d.head || count == 1 {
		if count == index {
			cur.pre.next = cur.next
			cur.next.pre = cur.pre
			if index == d.length {
				// 重新指定尾节点
				d.tail = cur.pre
			}
			if index == 1 {
				// 重新指定头节点
				d.head = cur.next
			}
			// 删除当前节点的前后指向关系，让它与链表失去关联，则会被GC回收
			cur.next = nil
			cur.pre = nil
			d.length--
			return
		}
		cur = cur.next
		count++
		if count > d.length {
			// 说明已经遍历完链表了
			break
		}
	}
	fmt.Println("DeleteByIndex error")
}

func (d *DoubleList) DeleteByValue(value int) {
	if d.head == nil {
		fmt.Println("link is nil")
		return
	}

	cur := d.head
	count := 1
	fmt.Println("DeleteByValue:", value)
	// 当cur转了一圈回到头节点时候，count肯定不等于1，退出循环
	for cur != d.head || count == 1 {
		if value == cur.data {
			cur.pre.next = cur.next
			cur.next.pre = cur.pre
			if count == d.length {
				// 重新指定尾节点
				d.tail = cur.pre
			}
			if count == 1 {
				// 重新指定头节点
				d.head = cur.next
			}
			// 删除当前节点的前后指向关系，让它与链表失去关联，则会被GC回收
			cur.next = nil
			cur.pre = nil
			d.length--
			return
		}
		cur = cur.next
		count++
		if count > d.length {
			// 说明已经遍历完链表了
			break
		}
	}
	fmt.Println("DeleteByValue error")
}

func (d *DoubleList) UpdateByIndex(index int, newValue int) {
	if index > d.length || index <= 0 {
		fmt.Println("index error")
		return
	}

	cur := d.head
	count := 1
	fmt.Println("UpdateByIndex:", index, ", change to:", newValue)
	// 当cur转了一圈回到头节点时候，count肯定不等于1，退出循环
	for cur != d.head || count == 1 {
		if count == index {
			cur.data = newValue
			return
		}
		cur = cur.next
		count++
		if count > d.length {
			// 说明已经遍历完链表了
			break
		}
	}
	fmt.Println("UpdateByIndex error")
}

func (d *DoubleList) UpdateByValue(oldValue int, newValue int) {
	cur := d.head
	count := 1
	fmt.Println("UpdateByValue oldValue:", oldValue, ", change to:", newValue)
	// 当cur转了一圈回到头节点时候，count肯定不等于1，退出循环
	for cur != d.head || count == 1 {
		if oldValue == cur.data {
			cur.data = newValue
			return
		}
		cur = cur.next
		count++
		if count > d.length {
			// 说明已经遍历完链表了
			break
		}
	}
	fmt.Println("UpdateByValue error")
}

func (d *DoubleList) GetIndexByValue(value int) (int, bool) {
	cur := d.head
	count := 1
	// 当cur转了一圈回到头节点时候，count肯定不等于1，退出循环
	for cur != d.head || count == 1 {
		if value == cur.data {
			// 找到了
			return count, true
		}
		cur = cur.next
		count++
		if count > d.length {
			// 说明已经遍历完链表了
			break
		}
	}
	return 0, false
}

func (d *DoubleList) GetValueByIndex(index int) (int, bool) {
	if index > d.length || index <= 0 {
		return 0, false
	}

	cur := d.head
	count := 1
	// 当cur转了一圈回到头节点时候，count肯定不等于1，退出循环
	for cur != d.head || count == 1 {
		if index == count {
			return cur.data, true
		}
		cur = cur.next
		count++
		if count > d.length {
			// 说明已经遍历完链表了
			break
		}
	}
	return 0, false
}

func (d *DoubleList) PrintList() {
	if d.head == nil {
		fmt.Println("list is null")
		return
	}

	cur := d.head
	count := 1
	for {
		//先打印再判断
		fmt.Println("node data:", cur.data, ",index:", count,
			",next data:", cur.next.data,
			",pre data:", cur.pre.data)
		if cur.next == d.head {
			break
		}
		cur = cur.next
		count++
	}
	fmt.Println("list length =", d.length)
}

测试代码：

// TestDoubleLinkList 测试双向循环链表
func TestDoubleLinkList() {
	list := link.NewDoubleList()

	list.InsertHead(4)
	list.InsertHead(3)
	list.InsertHead(2)
	list.InsertHead(1)
	list.PrintList()

	list.InsertTail(5)
	list.InsertTail(6)
	list.InsertTail(7)
	list.PrintList()

	list.InsertByIndex(16, 5)
	list.PrintList()

	list.DeleteByIndex(3)
	list.PrintList()

	list.DeleteByValue(6)
	list.PrintList()

	list.UpdateByIndex(1, 11)
	list.UpdateByIndex(6, 66)
	list.PrintList()

	list.UpdateByValue(11, 111)
	list.UpdateByValue(66, 666)
	list.UpdateByValue(2, 22)
	list.UpdateByValue(232, 444)
	list.PrintList()

	v1 := 666
	index, ok := list.GetIndexByValue(v1)
	if !ok {
		fmt.Println("GetIndexByValue error, value:", v1, "not exist")
	} else {
		fmt.Println("GetIndexByValue value:", v1, ",index:", index)
	}

	v2 := 4343
	index, ok = list.GetIndexByValue(v2)
	if !ok {
		fmt.Println("GetIndexByValue error, value:", v2, "not exist")
	} else {
		fmt.Println("GetIndexByValue value:", v2, ",index:", index)
	}

	v3 := 6
	value, ok := list.GetValueByIndex(v3)
	if !ok {
		fmt.Println("GetValueByIndex error, index:", v3, "invalid")
	} else {
		fmt.Println("GetValueByIndex index:", v3, ",value:", value)
	}

	v4 := 8
	value, ok = list.GetValueByIndex(v4)
	if !ok {
		fmt.Println("GetValueByIndex error, index:", v4, "invalid")
	} else {
		fmt.Println("GetValueByIndex index:", v4, ",value:", value)
	}

}
隔壁有动静
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang数据结构-单链表
qq_43498850的博客
03-31 450
文章目录一、Golang数据结构-单链表1.基本介绍2.处理方法二、使用步骤1.使用一个结构体管理单链表2.添加链表数据(方法一)2.添加链表数据(方法二)3.显示链表的所有结点信息4.修改链表数据5.删除链表数据6.编写一个主函数测试三、运行结果1.链表插入结点第一种方法演示2.链表插入结点第二种方法演示总结 一、Golang数据结构-单链表 1.基本介绍 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的..
Golang 简单链表
zuoye1010的博客
10-29 171
Golang 简单链表 针对golang出学者，写一个简单的单向链表来进行练手，目前只有在链表添加功能 直接贴代码 package main import( "fmt" ) type node struct{ name string next *node } func addNode(name string,rootNode *node){ var curNode node curNode.name = name curNode.n
Golang——实现单链表
最新发布
qq_61453210的博客
05-20 294
单链表（Single Linked List）是链表数据结构的一种实现方式，它包含一系列节点（Node），每个节点都包含一个数据域和一个指向下一个节点的指针。定义了一个根节点head，定义了5个要添加的节点，并将他们按照顺序添加，之后打印显示出整个链表，然后删除掉节点id为"1"的数据，并再次打印显示链表。通过定义辅助节点，找到链表的最后一个节点，并将要添加的节点添加到找到的节点的下一个节点。通过定义结构体实现单链表的操作，no为链表中节点的id，name为节点id对应的内容，next为下一个节点的信息。
Golang链表
qq_53267860的博客
02-11 1490
单链表，双链表，环形链表
golang数据结构——链表
lp15929801907的博客
03-10 1471
golang链表详解
Golang-链表
samson
01-07 647
一.链表的实现 1.1 代码 package Algorithm import ( _ "container/list" "errors" "fmt" ) type Node struct { data interface{} pre *Node next *Node } type List struct { head *Node tail *Node len...
Go-Golang算法和数据结构
08-14
在编程领域，算法和数据结构是核心技术之一，对于任何编程语言来说都至关重要，Go语言（Golang）也不例外。Go语言以其简洁的语法、高效的性能以及内置的并发支持，成为了很多开发者首选的系统级编程语言。本资料包...
golang-algs-and-data-struts：在Golang中实现的算法和数据结构
02-26
在Golang中，常见的数据结构包括数组、链表、栈、队列、哈希表、树（如二叉树、红黑树）和图等。例如： 1. **数组**：固定大小的元素集合，所有元素类型相同。在Golang中，数组是一种值类型，修改数组的一个元素会...
数据结构与算法 by golang.zip
01-01
不过，考虑到标题是“数据结构与算法 by golang.zip”，我们可以假设这是一个关于使用Golang语言讲解数据结构和算法的资源包。下面我将基于这个主题，详细介绍数据结构和算法以及它们在Golang中的应用。 数据结构是...
golang-advance：转到数据结构与算法设计模式
02-05
在Golang中，标准库已经为一些常用的数据结构提供了支持，例如`container/heap`实现了堆数据结构，`container/list`提供了链表功能，`sort`包提供了多种排序算法。然而，对于更复杂的结构，如平衡二叉树或自定义哈希...
Golang 链表实现
weixin_44558408的博客
07-04 1079
Golang本身自带实现list的基本库：container/list；具体使用方法，可以查看Go基础库文档：https://studygolang.com/pkgdoc下面是不适用基础库的实现方法，优化方式有很多，实现思路仅供参考：下文实现了单向链表、循环链表、双向链表，单链表是基础，其他的链表基本都是根据单链表演化的。先把代码贴上，后续分解代码： 3.2 增删改查图示： 链表操作主要分为：增、删、改、查； 根据实现过程，增删操作类似、改查操作类似增加和删除增加节点： 步骤：① 创建插入的节点，找到
golang-链表
01-08
一.链表的实现 1.1 代码 package Algorithm import ( _ container/list errors fmt ) type Node struct { data interface{} pre *Node next *Node } type List struct { head *Node tail *Node length uint64 } func GetList() *List{ list := &List{ head: nil, tail:nil, length:0, } return list
简单用golang实现链表
kiripeng的博客
07-16 502
package main import "fmt" type Node struct{ key interface{} next *Node } type Link struct { root *Node } type linkMethod interface { addValue(value interface{}) findValue(value interface{})*N...
Golang 结构体链表
不要因为走的太远而忘了为什么出发
04-09 2262
文章目录1. 什么是链表2. 单项链表3. 使用 struct 定义单链表4. 尾部添加节点5. 头部插入节点6. 指定节点后添加新节点7. 删除节点 1. 什么是链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 使用链表结构可以避免在使用数组时需要预先知道数据大小的缺点，
golang实现链表
李三思的博客
07-16 467
golang实现链表
Golang 链表详解
wgchen
10-11 435
Golang 链表详解
golang数据结构-链表
weixin_53909942的博客
08-12 427
此文章用于数据结构学习记录
golang 数据结构
07-29
4. 链表（Linked List）：是一种基本的数据结构，它由节点组成，每个节点包含数据和一个指向下一个节点的指针。 5. 栈（Stack）：是一种后进先出（LIFO）的数据结构，只有栈顶元素可以访问和操作。 6. 队列（Queue...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值