亚洲激情专区-91九色丨porny丨老师-久久久久久久女国产乱让韩-国产精品午夜小视频观看

溫馨提示×

溫馨提示×

您好，登錄后才能下訂單哦！

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

Go語言中的鏈表怎么使用

發布時間：2022-04-19 15:19:34 來源：億速云 閱讀：101 作者：iii 欄目：開發技術

本篇內容主要講解“Go語言中的鏈表怎么使用”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Go語言中的鏈表怎么使用”吧!

1. 什么是鏈表

鏈表是一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是通過鏈表中的指針鏈接次序實現的。

鏈表由一系列結點（鏈表中每一個元素稱為結點）組成，結點可以在運行時動態生成。每個結點包括兩個部分：一個是存儲數據元素的數據域，另一個是存儲下一個結點地址的指針域。

使用鏈表結構可以避免在使用數組時需要預先知道數據大小的缺點，鏈表結構可以充分利用計算機內存空間，實現靈活的內存動態管理。但是鏈表失去了數組隨機讀取的優點，同時鏈表由于增加了結點的指針域，空間開銷比較大。

鏈表允許插入和移除表上任意位置上的結點，但是不允許隨機存取。

鏈表有三種類型：單向鏈表、雙向鏈表、循環鏈表。

2. 單項鏈表的基本操作

單向鏈表中每個結點包含兩部分，分別是數據域和指針域，上一個結點的指針指向下一結點，依次相連，形成鏈表。

鏈表通過指針將一組零散的內存塊串聯在一起，這里的內存塊稱為鏈表的結點。為了將這些節點給串起來，每個鏈表的結點除了存儲數據之外，還會記錄下一個結點的指針（即下一個結點的地址），這個指針稱為：后繼指針

Go語言中的鏈表怎么使用

3. 使用 struct 定義單鏈表

利用 Struct 可以包容多種數據類型的特性

一個結構體內可以包含若干成員，這些成員可以是基本類型、自定義類型、數組類型，也可以是指針類型。

struct 定義的三種形式，其中2和3都是返回結構體的指針

//定義
var stu Student

var stu *Student = new(Student)

var stu *Student = &Student {}

//調用
stu.Name   stu.Age    stu.Score
或
(*stu).Name	   (*stu).Age   (*stu).Score

定義一個單項鏈表

next 是指針類型的屬性，指向 Student struct 類型數據，也就是下一個節點的數據類型

type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student
}

為鏈表賦值，并遍歷鏈表中的每個節點

package main

import "fmt"

type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student		//存放下一個結構體的地址，用*直接指向下一個結構體
}

func main() {
	//頭部結構體
	var head Student
	head.Name = "張三"
	head.Age = 28
	head.Score = 88

	//第二個結構體節點
	var stu1 Student
	stu1.Name = "李四"
	stu1.Age = 25
	stu1.Score = 100

	head.next = &stu1

	//第三個結構體節點
	var stu2 Student
	stu2.Name = "王五"
	stu2.Age = 18
	stu2.Score = 60

	stu1.next = &stu2

	Req(&head)
}

func Req(tmp *Student) {		//tmp指針是指向下一個結構體的地址，加*就是下一個結構體
	for tmp != nil {			//遍歷輸出鏈表中每個結構體，判斷是否為空
		fmt.Println(*tmp)
		tmp = tmp.next			//tmp變更為下一個結構體地址
	}
}


//輸出結果如下
{張三 28 88 0xc000114480}
{李四 25 100 0xc0001144b0}
{王五 18 60 <nil>}

4. 尾部添加節點

方法一

package main

import (
	"fmt"
	"math/rand"
)

type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student
}

func main() {
	//頭部結構體
	var head Student
	head.Name = "head"
	head.Age = 28
	head.Score = 88

	//第二個結構體節點
	var stu1 Student
	stu1.Name = "stu1"
	stu1.Age = 25
	stu1.Score = 100

	head.next = &stu1 //頭部指向第一個結構體

	//第三個結構體節點
	var stu2 Student
	stu2.Name = "stu2"
	stu2.Age = 18
	stu2.Score = 60

	stu1.next = &stu2 //第一個結構體指向第二個結構體

	//第四個結構體節點
	var stu3 Student
	stu3.Name = "stu3"
	stu3.Age = 18
	stu3.Score = 80

	stu2.next = &stu3 //第二個結構體指向第三個結構體

	//聲明變量
	var tail = &stu3
	for i := 4; i < 10; i++ {
		//定義節點
		var stu Student = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 100,
		}
		//生產結構體串聯
		tail.next = &stu
		tail = &stu
	}

	Req(&head)
}

func Req(tmp *Student) {
	for tmp != nil {
		fmt.Println(*tmp)
		tmp = tmp.next
	}
}

//輸出結果如下
{head 28 88 0xc0001144b0}
{stu1 25 100 0xc0001144e0}
{stu2 18 60 0xc000114510}
{stu3 18 80 0xc000114540}
{stu4 81 94.05091 0xc000114570}
{stu5 47 43.77142 0xc0001145a0}
{stu6 81 68.682304 0xc0001145d0}
{stu7 25 15.651925 0xc000114600}
{stu8 56 30.091187 0xc000114630}
{stu9 94 81.36399 <nil>}

方法二，使用函數進行優化

package main

import (
	"fmt"
	"math/rand"
)

type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student
}

func main() {
	//頭部結構體
	var head Student
	head.Name = "head"
	head.Age = 28
	head.Score = 88

	TailInsert(&head)
	Req(&head)
}

//循環遍歷
func Req(tmp *Student) {
	for tmp != nil {
		fmt.Println(*tmp)
		tmp = tmp.next
	}
}

//添加結構體節點
func TailInsert(tail *Student) {
	for i := 0; i < 10; i++ {
		//定義節點
		var stu Student = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 100,
		}
		//生產結構體串聯
		tail.next = &stu	//指向下一個結構體
		tail = &stu			//把當前的結構體給tail，讓其繼續循環
	}
}


//輸出結果如下
{head 28 88 0xc0001144b0}
{stu0 81 94.05091 0xc0001144e0}
{stu1 47 43.77142 0xc000114510}
{stu2 81 68.682304 0xc000114540}
{stu3 25 15.651925 0xc000114570}
{stu4 56 30.091187 0xc0001145a0}
{stu5 94 81.36399 0xc0001145d0}
{stu6 62 38.06572 0xc000114600}
{stu7 28 46.888985 0xc000114630}
{stu8 11 29.310184 0xc000114660}
{stu9 37 21.855305 <nil>}

5. 頭部插入節點

方法一

package main

import (
	"fmt"
	"math/rand"
)

type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student
}

func main() {
	//頭部結構體
	var head Student
	head.Name = "head"
	head.Age = 28
	head.Score = 88

	//調用頭部插入函數
	HeadInsert(&head)

	Req(HeadInsert(&head))
}

func Req(tmp *Student) {
	for tmp != nil {
		fmt.Println(*tmp)
		tmp = tmp.next
	}
}

func HeadInsert(p *Student) *Student {
	for i := 0; i < 10; i++ {
		var stu = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 100,
		}
		//當前新節點指向head，因為head是下一個節點
		stu.next = p //指向下一個節點
		p = &stu     //把當前的結構體給tail，讓其繼續循環
	}
	return p
}

//輸出結果如下
{stu9 85 30.152267 0xc000094840}
{stu8 37 5.912065 0xc000094810}
{stu7 29 7.9453626 0xc0000947e0}
{stu6 87 60.72534 0xc0000947b0}
{stu5 41 2.8303082 0xc000094780}
{stu4 90 69.67192 0xc000094750}
{stu3 87 20.658266 0xc000094720}
{stu2 47 29.708258 0xc0000946f0}
{stu1 28 86.249146 0xc0000946c0}
{stu0 95 36.08714 0xc0000944b0}
{head 28 88 <nil>}

Go語言中的鏈表怎么使用

方法二

使用指針的指針

package main

import (
	"fmt"
	"math/rand"
)

type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student
}

func main() {
	//頭部結構體
	var head *Student = &Student{}
	head.Name = "head"
	head.Age = 28
	head.Score = 88

	//調用頭部插入函數
	HeadInsert(&head)

	Req(head)
}

func Req(tmp *Student) {
	for tmp != nil {
		fmt.Println(*tmp)
		tmp = tmp.next
	}
}

func HeadInsert(p **Student) {
	for i := 0; i < 10; i++ {
		var stu = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 100,
		}
		//當前新節點指向head，因為head是下一個節點
		stu.next = *p //指向下一個節點
		*p = &stu     //把當前的結構體給tail，讓其繼續循環
	}
}


//輸出結果如下
{stu9 37 21.855305 0xc000114660}
{stu8 11 29.310184 0xc000114630}
{stu7 28 46.888985 0xc000114600}
{stu6 62 38.06572 0xc0001145d0}
{stu5 94 81.36399 0xc0001145a0}
{stu4 56 30.091187 0xc000114570}
{stu3 25 15.651925 0xc000114540}
{stu2 81 68.682304 0xc000114510}
{stu1 47 43.77142 0xc0001144e0}
{stu0 81 94.05091 0xc0001144b0}
{head 28 88 <nil>}

總結

如果想要外部的數據和函數處理結果進行同步，兩種方法：

① 傳參，傳遞指針

② return 進行值的返回

6. 指定節點后添加新節點

package main

import (
	"fmt"
	"math/rand"
)

type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student
}

func main() {
	//頭部結構體
	var head *Student = &Student{} //定義指針類型
	head.Name = "head"
	head.Age = 28
	head.Score = 88

	//定義新的節點
	var newNode *Student = &Student{} //定義指針類型
	newNode.Name = "newNode"
	newNode.Age = 19
	newNode.Score = 78
	HeadInsert(&head)

	//指定位置插入函數
	Add(head, newNode)

	Req(head)
}

func Req(tmp *Student) {
	for tmp != nil {
		fmt.Println(*tmp)
		tmp = tmp.next
	}
}

func HeadInsert(p **Student) { //傳入指針的指針
	for i := 0; i < 10; i++ {
		var stu = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 100,
		}
		//當前新節點指向head，因為head是下一個節點
		stu.next = *p //指向下一個節點
		*p = &stu     //把當前的結構體給tail，讓其繼續循環
	}
}

//p為當前節點，newnode為插入的節點
func Add(p *Student, newNode *Student) {
	for p != nil {
		if p.Name == "stu6" {
			//對接下一個節點
			newNode.next = p.next
			p.next = newNode
		}
		//插入節點指向下一個節點
		p = p.next //p.next賦予給p，繼續進行循環遍歷
	}
}


//輸出結果如下
{stu9 37 21.855305 0xc0000c0660}
{stu8 11 29.310184 0xc0000c0630}
{stu7 28 46.888985 0xc0000c0600}
{stu6 62 38.06572 0xc0000c04b0}
{newNode 19 78 0xc0000c05d0}
{stu5 94 81.36399 0xc0000c05a0}
{stu4 56 30.091187 0xc0000c0570}
{stu3 25 15.651925 0xc0000c0540}
{stu2 81 68.682304 0xc0000c0510}
{stu1 47 43.77142 0xc0000c04e0}
{stu0 81 94.05091 0xc0000c0480}
{head 28 88 <nil>}

7. 刪除節點

package main

import (
	"fmt"
	"math/rand"
)

type Student struct {
	Name  string
	Age   int
	Score float32
	next  *Student
}

func main() {
	//頭部結構體
	var head *Student = &Student{} //定義指針類型
	head.Name = "head"
	head.Age = 28
	head.Score = 88

	//定義新的節點
	var newNode *Student = &Student{} //定義指針類型
	newNode.Name = "newNode"
	newNode.Age = 19
	newNode.Score = 78
	HeadInsert(&head)

	//指定位置插入函數
	Add(head, newNode)

	//刪除節點
	del(head)

	Req(head)
}

func Req(tmp *Student) {
	for tmp != nil {
		fmt.Println(*tmp)
		tmp = tmp.next
	}
}

func HeadInsert(p **Student) { //傳入指針的指針
	for i := 0; i < 10; i++ {
		var stu = Student{
			Name:  fmt.Sprintf("stu%d", i),
			Age:   rand.Intn(100),
			Score: rand.Float32() * 100,
		}
		//當前新節點指向head，因為head是下一個節點
		stu.next = *p //指向下一個節點
		*p = &stu     //把當前的結構體給tail，讓其繼續循環
	}
}

//p為當前節點，newnode為插入的節點
func Add(p *Student, newNode *Student) {
	for p != nil {
		if p.Name == "stu6" {
			//對接下一個節點
			newNode.next = p.next
			p.next = newNode
		}
		//插入節點指向下一個節點
		p = p.next //p.next賦予給p，繼續進行循環遍歷
	}
}

//刪除節點
func del(p *Student) {
	var prev *Student = p			//p=head   prev=head  ——》prev=p
	for p != nil {
		if p.Name == "newNode" {
			prev.next = p.next
			break
		}
		prev = p			//進行平移，前節點賦值
		p = p.next			//后節點賦值
	}
}
 
 //輸出結果如下
 {stu9 37 21.855305 0xc0000c0660}
{stu8 11 29.310184 0xc0000c0630}
{stu7 28 46.888985 0xc0000c0600}
{stu6 62 38.06572 0xc0000c05d0}
{stu5 94 81.36399 0xc0000c05a0}
{stu4 56 30.091187 0xc0000c0570}
{stu3 25 15.651925 0xc0000c0540}
{stu2 81 68.682304 0xc0000c0510}
{stu1 47 43.77142 0xc0000c04e0}
{stu0 81 94.05091 0xc0000c0480}
{head 28 88 <nil>}

到此，相信大家對“Go語言中的鏈表怎么使用”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！

向AI問一下細節

免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。

AI
助
手
衡南县| 灵台县| 中牟县| 马公市| 合江县| 于都县| 青海省| 图木舒克市| 安庆市| 当涂县| 垣曲县| 茂名市| 鹤壁市| 沙坪坝区| 通州市| 康乐县| 贺州市| 大同市| 广昌县| 谢通门县| 博客| 鸡东县| 南华县| 和平区| 梧州市| 乐安县| 义马市| 黄骅市| 离岛区| 凭祥市| 安阳市| 揭西县| 渝北区| 石楼县| 于田县| 绥宁县| 阿尔山市| 普定县| 洞头县| 昌都县| 福鼎市|