go语言基础数据结构

我就是我 2022-05-08 02:42 302阅读 0赞

# 一.数组： #

### 1.数组的定义 ###

使用循环进行赋值；

1.  使用循环进行for循环进行遍历。
2.  使用for配合range对数组进行遍历。
3.  使用println即可格式化输出数组元素。

package main
 
 import "fmt"
 
 func main(){ 
 var a [10]int
 	fmt.Println(len(a))
 //1.
 	for i := 0; i < len(a); i++{
 		a[i] = i+1
 		fmt.Println(a[i])
 	}
 //2.
 	for _, data := range a {
 		fmt.Println(data)
 	}
 
 	for i, _ := range a {
 		fmt.Println(a[i])
 	}
 //3.
 fmt.Println(a)
 }

### 2.数组元素默认初始值 ###

int(整型)：0

float64:0

string：空字符串

bool：false

//int(整型):0
    	var arr1[10] int
    	for i, _ := range arr1 {
    		fmt.Println(arr1[i])
    	}
    
    	//string:空字符串
    	var arr2[10] string
    	for i, _ := range arr2 {
    		fmt.Println(arr2[i])
    	}
    
    	//float64:0
    	var arr3[10] float64
    	for i, _ := range arr3 {
    		fmt.Println(arr3[i])
    	}
    
    	//bool:false
    	var arr4[10] bool
    	for i, _ := range arr4 {
    		fmt.Println(arr4[i])
    	}

### 3.数组的初始化 ###

四种数组元素初始化方式：

1.  全部初始化，使用var定义的数组
2.  全部初始化，使用自动类型推导
3.  部分元素初始化
4.  指定元素初始化
5.  通过初始化来确定数组的长度

package main
    
    import "fmt"
    
    func main(){
    
    	//1.全部初始化
    	var a [5]int = [5]int{0, 1, 2, 3, 4}
    	for _, data := range a  {
    		fmt.Println(data)
    	}
    
    	fmt.Println()
    
    	//2.全部初始化：自动类型推导
    	b := [5]int{0, 1, 2, 3, 4}
    	fmt.Println(b)
    
    	//3.部分初始化
    	c := [5]int{0, 1, 2}
    	fmt.Println(c)
    
    	//4.指定元素初始化
    	d := [5]int{0:5, 1:10}
    	fmt.Println(d)
    
            //5.通过初始化来确定数组长度
    	e := [...]int{1, 2, 3}
    	fmt.Println(e)
    }

### 4.同类型数组之间的直接赋值与比较 ###

注意，赋值与比较时需要使用同类型的数组，不同类型的数组是不允许这样操作的。

package main
    
    import "fmt"
    
    func main(){
    	//同类型的数组可以使用==、!=进行比较，以及使用=进行赋值
    	arr := [3][4]int{
       {1}, {2}, {3}}
    	fmt.Println(arr)
    
    	var b [3][4]int = arr
    	fmt.Println(b)
    
    	//如果数组类型不同，那么IDE就会报错
    	c := [3][4]int{
       {1}, {2}, {3}}
    	fmt.Println(c == b)
    }

### 五.多维数组 ###

有多少个\[\]就是多少维度；

多少维的数组就用多少个for循环进行遍历。

# 二.切片： #

### 1.切片的定义 ###

1.  var
2.  自动类型推导
3.  make(类型, 长度, 容量)，容量可以省略。
4.  截取切片作为一个新的切片s\[0 : 3 : 5\]，第二个参数**可以理解为以一个参数+3**，而是结束位置，及不包含结束位置元素。此时容量同样可以省略，但是截取后得到的切片容量有第一个参数决定：原切片的容量减去以一个参数，含义即从首元素跳过了多少个个位置。

package main
 
 import "fmt"
 
 func main() {
 	//1.切片的定义
 	//1.
 	a := []int{1, 2, 3}
 	a = append(append(a, 4, 5), 6, 7)
 	fmt.Println(a)
 	fmt.Printf("%T", a)
 
 	//2.
 	var b []int = []int{1, 2, 3}
 	fmt.Println(b)
 
 	//3.切片类型 长度len() 容量cap()
 	s := make([]int, 5, 10)
 	for i := 0; i < len(s); i++ {
 		s[i] = i + 1
 		fmt.Println(s[i])
 	}
 	fmt.Println(s)
 	fmt.Println(len(s))
 	fmt.Println(cap(s))
 
 	//4.切片的截取
 	//5为切片的容量
 	slice := s[0 : 3 : 5]
 	fmt.Println(slice)
 
 }

**需要注意make的容量问题，正如上面所提到的。**

<table style="margin-left:6.75pt;width:621px;"> 
 <thead> 
 <tr> 
 <td style="background-color:#f9f9f9;border-color:#dddddd;width:85.4pt;"> 操作 </td> 
 <td style="background-color:#f9f9f9;border-color:#dddddd;width:380.3pt;"> 含义 </td> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td style="width:85.4pt;"> s[n] </td> 
 <td style="width:380.3pt;"> 切片s中索引位置为n的项 </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[:] </td> 
 <td style="width:380.3pt;"> 从切片s的索引位置0到len(s)-1处所获得的切片 </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[low:] </td> 
 <td style="width:380.3pt;"> 从切片s的索引位置low到len(s)-1处所获得的切片 </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[:high] </td> 
 <td style="width:380.3pt;"> 从切片s的索引位置0到high处所获得的切片，len=high </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[low:high] </td> 
 <td style="width:380.3pt;"> 从切片s的索引位置low到high处所获得的切片，len=high-low </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> s[low:high:max] </td> 
 <td style="width:380.3pt;"> 从切片s的索引位置low到high处所获得的切片，len=high-low，cap=max-low </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> len(s) </td> 
 <td style="width:380.3pt;"> 切片s的长度，总是&lt;=cap(s) </td> 
 </tr> 
 <tr> 
 <td style="width:85.4pt;"> cap(s) </td> 
 <td style="width:380.3pt;"> 切片s的容量，总是&gt;=len(s) </td> 
 </tr> 
 </tbody> 
</table>

### 2.切片的追加和拷贝 ###

**1.追加：append()**

**append函数在容量1024之前容量不足时扩容一倍，容量在1024(当然也包括1024)之后则不按照此规律扩容。**

package main
 
 import "fmt"
 
 func main() {
 	//1024之前扩容一倍
 	slice := []int{1}
 	old_cap := cap(slice)
 	for i:=0;i<10000 ;i++ {
 		slice = append(slice, i)
 		if old_cap < cap(slice){
 			old_cap = cap(slice)
 			fmt.Println(old_cap)
 		}
 	}
 }

**以上代码输出结果数值如下：**

2     4     8     16
    32    64    128   256
    512   1024  1280  1696
    2304  3072  4096  5120
    7168  9216  12288

**2.拷贝：copy(dest， src)**

package main
    
    import "fmt"
    
    func main() {
    	src_slice := []int{1, 2, 3}
    	dest_slice := []int{4, 5, 6, 7, 8, 9}
    	//copy(dest_slice, src_slice)
    	copy(src_slice, dest_slice)
    	//fmt.Println(dest_slice)
    	fmt.Println(src_slice)
    }

**另外：**

**结构体**作为函数参数是：值传递--->使用指针解决：数组指针，区别于指针数组  
**数组**作为函数参数是：值传递--->使用指针解决：结构体指针  
**切片**作为函数参数是：引用传递(传地址)  
**map**作为函数参数是：引用传递(传地址)  
**指针**作为函数参数是：值传递