<em>Mac</em>Book项目 2009年学校开始实施<em>Mac</em>Book项目,所有师生配备一本<em>Mac</em>Book,并同步更新了校园无线网络。学校每周进行电脑技术更新,每月发送技术支持资料,极大改变了教学及学习方式。因此2011
2021-06-01 09:32:01
Go語言學習之連結串列的使用詳解
2022-04-19 22:00:09
1. 什麼是連結串列
連結串列是一種物理儲存單元上非連續、非順序的儲存結構，資料元素的邏輯順序是通過連結串列中的指標連結次序實現的。
連結串列由一系列結點（連結串列中每一個元素稱為結點）組成，結點可以在執行時動態生成。每個結點包括兩個部分：一個是儲存資料元素的資料域，另一個是儲存下一個結點地址的指標域。
使用連結串列結構可以避免在使用陣列時需要預先知道資料大小的缺點，連結串列結構可以充分利用計算機記憶體空間，實現靈活的記憶體動態管理。但是連結串列失去了陣列隨機讀取的優點，同時連結串列由於增加了結點的指標域，空間開銷比較大。
連結串列允許插入和移除表上任意位置上的結點，但是不允許隨機存取。
連結串列有三種型別：單向連結串列、雙向連結串列、迴圈連結串列。
2. 單項連結串列的基本操作
單向連結串列中每個結點包含兩部分，分別是資料域和指標域，上一個結點的指標指向下一結點，依次相連，形成連結串列。
連結串列通過指標將一組零散的記憶體塊串聯在一起，這裡的記憶體塊稱為連結串列的結點。為了將這些節點給串起來，每個連結串列的結點除了儲存資料之外，還會記錄下一個結點的指標（即下一個結點的地址），這個指標稱為：後繼指標
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>}
方法二
使用指標的指標
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語言學習之連結串列的使用詳解的詳細內容，更多關於Go語言連結串列的資料請關注it145.com其它相關文章！
相關文章
-
黑科技的輕簡出行，告別「電量焦慮症」：Anker氮化鎵超能充系列
综合看Anker超能充系列的性价比很高，并且与不仅和iPhone12/苹果<em>Mac</em>Book很配，而且适合多设备充电需求的日常使用或差旅场景，不管是安卓还是Switch同样也能用得上它，希望这次分享能给准备购入充电器的小伙伴们有所
2021-06-01 09:31:42
-
吳亦凡廠牌首秀，L4WUDU居然忘詞了，Rapper和明星比還是有差距！
除了L4WUDU与吴亦凡已经多次共事，成为了明面上的厂牌成员，吴亦凡还曾带领20XXCLUB全队参加2020年的一场音乐节，这也是20XXCLUB首次全员合照，王嗣尧Turbo、陈彦希Regi、<em>Mac</em> Ova Seas、林渝植等人全部出场。然而让
2021-06-01 09:31:34
-
IPFS、Chia、Bzz和ICP挖礦該怎麼選？哪一個更有優勢？
目前应用IPFS的机构：1 谷歌<em>浏览器</em>支持IPFS分布式协议 2 万维网 (历史档案博物馆)数据库 3 火狐<em>浏览器</em>支持 IPFS分布式协议 4 EOS 等数字货币数据存储 5 美国国会图书馆，历史资料永久保存在 IPFS 6 加
2021-06-01 09:31:24
-
有哪些事是買了雪佛蘭後才知道的？美事偷著樂，開拓者車主隨聊
开拓者的车机是兼容苹果和<em>安卓</em>，虽然我不怎么用，但确实兼顾了我家人的很多需求：副驾的门板还配有解锁开关，有的时候老婆开车，下车的时候偶尔会忘记解锁，我在副驾驶可以自己开门：第二排设计很好，不仅配置了一个很大的
2021-06-01 09:30:48
-
iPhone12在618最新定價，跌價幅度超過1400元，還等iPhone13嗎？
不仅是<em>安卓</em>手机，苹果手机的降价力度也是前所未有了，iPhone12也“跳水价”了，发布价是6799元，如今已经跌至5308元，降价幅度超过1400元，最新定价确认了。iPhone12是苹果首款5G手机，同时也是全球首款5nm芯片的智能机，它
2021-06-01 09:30:45