golang基礎-結構體、結構體連結串列前後插入、節點新增刪除
結構體定義
struct
用來自定義複雜資料結構
struct裡面可以包含多個欄位（屬性）
struct型別可以定義方法，注意和函式的區分
struct型別是值型別
struct型別可以巢狀
Go語言沒有class型別，只有struct型別
package main
import (
"fmt"
)
type Student struct{
Name string
Age int
score float32
}
func main() {
var stu Student
stu.Age 輸出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
{aaa 18 100}
18
0xc042002750
&{aaa 18 100}
---------------
&{hh 20 0}
20
{hh 20 0}
0xc042002850
0xc042004030
-----------
{iii 18 0}
&{iii 18 0}
18
0xc042002950
PS E:\golang\go_pro\src\safly>結構體連結串列定義
連結串列定義
type Student struct {
Name string
Next* Student
}每個節點包含下一個節點的地址，這樣把所有的節點串起來了，通常把
連結串列中的第一個節點叫做連結串列頭
我們來看一個例子，就是在結構體，末尾插入一個節點
尾部插入
package main
import (
"fmt"
)
type Student struct{
Name string
Age int
score float32
next *Student
}
func main() {
//建立一個頭結點
var head Student
head.Name = "safly"
head.Age = 1
head.score = 100
//建立一個節點
var stu1 Student
stu1.Name = "safly1"
stu1.Age = 2
stu1.score = 101
head.next = &stu1
//建立一個臨時遍歷
var temp *Student = &head
for temp!= nil{
fmt.Println(temp)
temp = temp.next
}
}
輸出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
&{safly 1 100 0xc04203df80}
&{safly1 2 101 <nil>}
PS E:\golang\go_pro\src\safly>以上是在末尾插入 ，我們接下來看在頭部插入節點的程式碼
頭部插入
頭部插入的第一種方法：
package main
import (
"fmt"
"math/rand"
)
type Student struct{
Name string
Age int
Score float32
next *Student
}
func main() {
//建立一個頭
var head *Student = &Student{}
//或者如下的方式
// var head1 *Student = new(Student)
head.Name = "safly"
head.Age = 1
head.Score = 100
for i:=0;i<5;i++{
stu:= Student{
Name:fmt.Sprint(rand.Intn(100)),
Age:rand.Intn(100),
Score:rand.Float32()*100,
}
stu.next = head
head = &stu
}
//迴圈輸出
for head!=nil{
fmt.Println(*head)
head = head.next
}
}
輸出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
{62 89 31.805817 0xc042062060}
{0 94 81.36399 0xc042062030}
{25 40 9.696952 0xc042062000}
{59 81 68.682304 0xc04203dfb0}
{81 87 66.45601 0xc04203df80}
{safly 1 100 <nil>}
PS E:\golang\go_pro\src\safly>我們將上面的程式碼進行優化：
package main
import (
"fmt"
"math/rand"
)
type Student struct{
Name string
Age int
Score float32
next *Student
}
func main() {
//建立一個頭結點
var head *Student = new(Student)
//或者如下的方式
// var head1 *Student = new(Student)
head.Name = "safly"
head.Age = 1
head.Score = 100
inserHead(&head)
trans(head)
}
/**/
func inserHead(p **Student){
// var tail = p
for i:=0;i<5;i++{
stu:= Student{
Name:fmt.Sprint(rand.Intn(100)),
Age:rand.Intn(100),
Score:rand.Float32()*100,
}
stu.next = *p
*p = &stu
}
}
func trans(p *Student) {
for p != nil {
fmt.Println(*p)
p = p.next
}
fmt.Println()
}
輸出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
{62 89 31.805817 0xc04204a2d0}
{0 94 81.36399 0xc04204a2a0}
{25 40 9.696952 0xc04204a270}
{59 81 68.682304 0xc04204a240}
{81 87 66.45601 0xc04204a210}
{safly 1 100 <nil>}
PS E:\golang\go_pro\src\safly>或者如下的方法也可以
package main
import (
"fmt"
"math/rand"
)
type Student struct{
Name string
Age int
Score float32
next *Student
}
func main() {
//建立一個頭結點
var head *Student = new(Student)
//或者如下的方式
// var head1 *Student = new(Student)
head.Name = "safly"
head.Age = 1
head.Score = 100
for i:=0;i<5;i++{
stu:= Student{
Name:fmt.Sprint(rand.Intn(100)),
Age:rand.Intn(100),
Score:rand.Float32()*100,
}
stu.next = *(&head)
*(&head) = &stu
}
trans(head)
}
func trans(p *Student) {
for p != nil {
fmt.Println(*p)
p = p.next
}
fmt.Println()
}
輸出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
{62 89 31.805817 0xc042062060}
{0 94 81.36399 0xc042062030}
{25 40 9.696952 0xc042062000}
{59 81 68.682304 0xc04203dfb0}
{81 87 66.45601 0xc04203df80}
{safly 1 100 <nil>}
PS E:\golang\go_pro\src\safly>刪除節點
package main
import (
"fmt"
"math/rand"
)
type Student struct{
Name string
Age int
Score float32
next *Student
}
func main() {
//建立一個頭結點
var head *Student = new(Student)
//或者如下的方式
// var head1 *Student = new(Student)
head.Name = "safly"
head.Age = 1
head.Score = 100
//新增節點
for i:=0;i<5;i++{
stu:= Student{
Name:fmt.Sprintf("stu%d",i),
Age:rand.Intn(100),
Score:rand.Float32()*100,
}
stu.next = *(&head)
*(&head) = &stu
}
trans(head)
//刪除節點
delNode(head)
trans(head)
}
/*
刪除節點
*/
func delNode(p *Student) {
var prev *Student = p
for p != nil {
if (*p).Name == "stu3" {
prev.next = p.next
break
}
//如果沒有遍歷到，往下延遲一個
prev = p
p = p.next
}
}
func trans(p *Student) {
for p != nil {
fmt.Println(*p)
p = p.next
}
fmt.Println()
}
輸出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
{stu4 56 30.091187 0xc042062060}
{stu3 25 15.651925 0xc042062030}
{stu2 81 68.682304 0xc042062000}
{stu1 47 43.77142 0xc04203dfb0}
{stu0 81 94.05091 0xc04203df80}
{safly 1 100 <nil>}
{stu4 56 30.091187 0xc042062030}
{stu2 81 68.682304 0xc042062000}
{stu1 47 43.77142 0xc04203dfb0}
{stu0 81 94.05091 0xc04203df80}
{safly 1 100 <nil>}
PS E:\golang\go_pro\src\safly>新增節點
package main
import (
"fmt"
"math/rand"
)
type Student struct{
Name string
Age int
Score float32
next *Student
}
func main() {
//建立一個頭結點
var head *Student = new(Student)
//或者如下的方式
// var head1 *Student = new(Student)
head.Name = "safly"
head.Age = 1
head.Score = 100
//新增節點
for i:=0;i<5;i++{
stu:= Student{
Name:fmt.Sprintf("stu%d",i),
Age:rand.Intn(100),
Score:rand.Float32()*100,
}
stu.next = *(&head)
*(&head) = &stu
}
trans(head)
var newNode *Student = new(Student)
newNode.Name = "stu1000"
newNode.Age = 18
newNode.Score = 100
addNode(head, newNode)
trans(head)
}
func addNode(p *Student, newNode *Student) {
for p != nil {
if p.Name == "stu2" {
newNode.next = p.next
p.next = newNode
break
}
p = p.next
}
}
func trans(p *Student) {
for p != nil {
fmt.Println(*p)
p = p.next
}
fmt.Println()
}
輸出如下：
PS E:\golang\go_pro\src\safly> go run demo.go
{stu4 56 30.091187 0xc04204a2d0}
{stu3 25 15.651925 0xc04204a2a0}
{stu2 81 68.682304 0xc04204a270}
{stu1 47 43.77142 0xc04204a240}
{stu0 81 94.05091 0xc04204a210}
{safly 1 100 <nil>}
{stu4 56 30.091187 0xc04204a2d0}
{stu3 25 15.651925 0xc04204a2a0}
{stu2 81 68.682304 0xc04204a480}
{stu1000 18 100 0xc04204a270}
{stu1 47 43.77142 0xc04204a240}
{stu0 81 94.05091 0xc04204a210}
{safly 1 100 <nil>}
PS E:\golang\go_pro\src\safly>相關推薦
golang基礎-結構體、結構體連結串列前後插入、節點新增刪除
結構體定義 刪除節點 新增節點 結構體定義 struct 用來自定義複雜資料結構 struct裡面可以包含多個欄位（屬性） struct型別可以定義方法，注意和函式的區分 struct型別是值型別 struct型別可以
Java 連結串列-最基礎的動態資料機構：連結串列的建立、頭部新增元素、尾部新增元素（一）筆記
Java 連結串列-最基礎的動態資料機構 優點:真正的動態,不需要處理固定容量的問題 缺點：喪失了隨機訪問的能力 陣列最好用於索引的情況（最大的優點：支援快速查詢） 連結串列不適合用於索引的情況（最大的優點：動態） 新增元素 如果是在頭部新增 那麼直接把元素指向原來頭部，然後
【小白學演算法】5.連結串列(linked list)，連結串列的插入、讀取
連結串列其實也就是 線性表的鏈式儲存結構，與之前講到的順序儲存結構不同。 我們知道順序儲存結構中的元素地址都是連續的，那麼這就有一個最大的缺點：當做插入跟刪除操作的時候，大量的元素需要移動。 如圖所示，元素在記憶體中的位置是挨著的，當中有元素被刪除，就產生空隙，於是乎後面的元素需要向前挪動去彌補。 ，和說話過程中的指標指向。這是兩碼事，容易搞混。箭頭符號實際上是用指標方式來訪問結構體
【一次過】Lintcode 219. 在排序連結串列中插入一個節點
在連結串列中插入一個節點。 樣例 給出一個連結串列 1->4->6->8 和 val = 5.。 插入後的結果為 1->4->5->6->8。 解題思路： 簡單。考慮到可能插入到表頭，所以需
用結構體實現連結串列的建立、遍歷、結點插入、結點刪除、連結串列刪除-----帶選單選項
#include <iostream> using namespace std; enum operation{create_List=1,print_List,insert_Node,delete_Node,delete_List,quit};//列舉型別，
golang基礎--gopkg.in/olivere/elastic.v5學習一(環境配置、連結)
環境配置 環境依賴： 作業系統：Mac go：go1.11 ElasticSearch：5.6.9 Java：1.8 elasticdump elasticsearch-analysis-ik 6.3.2 安裝elasticsearch
golang學習筆記（一）——golang基礎和相關資料結構
小白前端一枚，最近在研究golang，記錄自己學習過程中的一些筆記，以及自己的理解。 go中包的依賴管理 go中的切片 byte 和 string go中的Map go中的struct結構體 go中的方法 go中的interface介面 inter
【python資料結構與演算法】連結串列——連結串列中環的入口節點、兩個連結串列的第一個公共節點（相交連結串列）
如題，這類問題在LeetCode上和劍指offer上總共有這些涉及： LeetCode：141，142，160 劍指offer：兩個連結串列的第一個公共節點（預設是無環單鏈表）、連結串列中環的入口節點 補充：兩個未知是否有環的單鏈表第一個公共節點 我直接敘述第三個問題，
【資料結構】順序表、單鏈表、迴圈連結串列的插入與刪除
寫在前面的 順序表 插入 刪除 定位 單鏈表 插入 刪除 總結 寫在前面的 在複習資料結構的過程中對於連結串列的操作總是容易忘記，時不時的就不知道具體的該怎麼
資料結構JavaScript——雙向連結串列、雙向迴圈連結串列
關於連結串列簡介、單鏈表、單向迴圈連結串列、JS中的使用以及擴充方法： 單鏈表、迴圈連結串列的JS實現 雙向連結串列：單向連結串列只能向著一個方向遍歷連結串列節點，而在節點指標域中增加了前向指標的雙向連結串列，則可以向著兩個方向遍歷節點。這使得雙向連結串列也可以在任何
資料結構（java）——單鏈表、雙端連結串列和雙向連結串列
單鏈表 連結串列大家都很熟悉，連結串列是由若干個節點串起來的一個結構。類似於火車一樣，擁有一個頭結點（火車頭）之後掛著一個個的節點，每個節點後面跟上另一個節點。每個節點分為兩個域，一個數據域，用來存放這個節點的資料，一個是節點域，用來存放下一個節點。 所以對於單鏈
資料結構Java實現04----迴圈連結串列、模擬連結串列
單向迴圈連結串列雙向迴圈連結串列模擬連結串列 一、單向迴圈連結串列： 1、概念： 單向迴圈連結串列是單鏈表的另一種形式，其結構特點是連結串列中最後一個結點的指標不再是結束標記，而是指向整個連結串列的第一個結點，從而使單鏈表形成一個環。 和單鏈表相比，迴圈單鏈表的長
JavaScript 資料結構（一）： 連結串列
前言 從實用性角度來說，連結串列對Javascript 來說沒有任何價值，為什麼呢？ 我們先了解連結串列的特性，這個特性我們放在c++前提下來說，因為 這個特性是 根據 記憶體特性 來闡述的，Javascript 不存在記憶體操作，所有資料型別，本質性繼承Object 物件，而Ob
資料結構之快慢指標查詢連結串列中間結點
單鏈表是一種十分常見和應用廣泛的資料結構，也是面試題經常會問到的一個。近期複習單鏈表，就將這個單鏈表常見的考點順便複習了一遍。 面試題：如何最快的獲取單鏈表的中間節點的位置？ &nb
玩轉資料結構——第四章：連結串列和遞迴
內容概要： Leetcode中和連結串列相關的問題 測試自己的Leetcode連結串列程式碼 遞迴繼承與遞迴的巨集觀語意 連結串列的天然遞迴結構性質 遞迴執行機制：遞迴的微觀解讀 遞迴演算法的除錯 更多和連結串列相關的問題 1-Leetcode中
python 資料結構與演算法 day02 雙向連結串列
1.實現雙向連結串列 #_+_coding:utf-8_*_ #author: xuanxuan #Time : 2018/11/7 8:48 class Node(): def __init__(self,item): self.item=item
《資料結構與演算法》之連結串列—有序連結串列
2、有序連結串列 有序連結串列是在單鏈表的基礎上對單鏈表的表頭節點插入進行修改，從表頭開始根據插入值與連結串列中原先存在的資料節點進行比較判斷，若大於（或小於）該節點就向後移一個節點進行比較，直至不大於（或小於）該節點，最終實現按照從小到大（或從大到小）的順序排列連結串列。 // 插入節點，
《資料結構與演算法》之連結串列—雙端連結串列
2、雙端連結串列 雙端連結串列就是在單鏈表的基礎上增加一個尾節點，使連結串列既有頭節點又有尾節點，這樣方便進行連結串列尾的訪問和刪除。其計算複雜度如下：1、在表頭插入一個新的節點，時間複雜度O(1) ；2、在表尾插入一個新的節點，時間複雜度O(1) ；3、刪除表頭的節點，時間複雜度O(1) ；4
《資料結構與演算法》之連結串列—單向連結串列
連結串列（LinkedList） 連結串列是一種物理儲存單元上非連續、非順序的儲存結構，資料元素的邏輯順序是通過連結串列中的指標連結次序實現的。連結串列由一系列節點（連結串列中每一個元素稱為節點）組成，節點可以在執行時動態生成。每個節點包括兩個部分：一個是儲存資料元素的資料域，另一個是儲存下一個