golang入门笔记—基本数据结构

//数组
//var 数组变量名 [元素数量]T
func main(){
 var a1 [3]bool
 var a2 [3]bool
 
 //数组的初始化
 a1:= [3]bool{true,false,true}
 a2:=[...]int{0,1,2,3,4,5} //根据初始值自动填写长度，多维数组只有最外层能够加...
 a3:=[5]int{1,2}//其他的默认为0
 a4:=[5]int{0:1,4:2}//根据索引来初始化

//数组的遍历
citys:=[...]string{"北京","上海","深圳"}
for i:=0;i<len(citys);i++{
fmt.Println(citys[i])
}

//二维数组
var all[3][2]int //定义二维数组
all = [3][2]int{
   [2]int{1,2},
   [2]int{3,4},
   [2]int{5,6},
}//二维数组初始化
all2= [3][2]int{
    {1,2},
    {3,4},
    {5,6},
}

for _,v:=range all{
fmt.Println(v)
}//每一项都是一个大小为2的一维数组
}

//切片
//切片指向了一个底层数组
//切片的长度就是它元素的个数
//切片的容量是底层数组从切片的第一个元素到最后一个元素的数量
//切片就是一个框，框住了一块连续内存。真正的数据保存在底层数组。
//切片的遍历与数组遍历相同
//切片的扩容策略：
//1.如果申请的容量大于原来的两倍，那么直接扩容至申请的容量
//2.如果小于1024，那么就直接两倍
//3.如果大于1024，就按照1.25倍去扩容
//4.具体存储的值类型不同，扩容策略也有一定的不同
var a []string  //声明一个string型的切片
var b []int    //声明一个int型的切片
 
 b= []int{1,2,3}
 a=[]string{"沙河","张江","平山村"}

fmt.Printf("len:%d cap:%d\n",len(a),cap(a))
fmt.Printf("len:%d cap:%d\n",len(b),cap(b))
//len求切片长度，cap求切片容量

a1:=[...]int{1,3,5,7,9,11,13}
s3:=a1[0:4]//[1,3,5,7]

//make函数制作切片
//make([]类型，元素个数，容量)
s1：=make([]int,5,10) 
s2:=make([]int,0,5)
fmt.Println(s2==nll) //打印false
//因为make函数会给切片分配内存，所以不为nll

//append:切片的扩充
s1:=[]string{"北京","上海","深圳"}
s1 =append(s1,"广州")
s1 =append(s1,"杭州","成都")
ss:=[]string{"武汉","西安","苏州"}
s1=append(s1,ss...)//ss...为将切片ss切分成一个个元素
//调用append函数必须用原来的切片变量接受返回值
//append追加元素，原来的底层数组放不下的时候，Go底层就会把底层数组换一个

//切片删除元素
a1:=[]int{1,3,5}
a1=append(a1[:1],a1[2:]...) //只有一个元素也要加...拆开

a := []int{1, 2, 5, 7, 8}
	s := a[:3]
	fmt.Printf("%v\n", s) //[1,2,5]
	s[1] = 0
	fmt.Printf("%v\n", a) //[1,0,5]
	//可以通过切片修改底层数组

//面试题
var a = make([]int,5,10) //创建切片，长度为5，容量为10
fmt.Println(a) //输出[0,0,0,0,0]
for i:=0;i<10;i++{
    a=append(a,i)
}
fmt.Println(a) //输出[0,0,0,0,0,0,1,2,3,4,5,6,7,8,9]

//对切片进行排序
var a1=[...]int{3,7,8,9,1}
sort.Ints(a1[:]) //对切片进行排序
fmt.Println(a1)

//面试题
a:=[]int{1,3,5,7,9,11,13,15,17}
s:=a[:] 
s=append(s[0:1],s[2:]...)
fmt.Println(s) //输出[1,5,7,9,11,13,15,17]
fmt.Println(a) //输出[1,5,7,9,11,13,15,17,17]

//指针
//Go语言不存在指针操作，只需要记住两个符号： 
1.&：取地址
2.*：根据地址取值
func main(){
  n:=18
  p:=&n
  fmt.Printf("%T\n",p)
  fmt.Println(*p)
  
  var a=new(int) //new用于分配内存，返回地址
  *a=100
  fmt.Println(*a)
  //make和new的区别
  //1.make和new都是用来申请内存的
  //2.new很少用，一般用来给基本数据类型申请内存，string/int，返回的是对应类型的指针
  //3.make是用来给slice、map、chan申请内存的，make函数返回的是对应的三个类型本身
}

//map
//map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用
//map[KeyType]ValueType

func main(){
 var m1 map[string]int
 fmt.Println(m1==nll) //还没有初始化（没有在内存开辟空间）
 m1=make(map[string]int,10)
 //var m1=make(map[string]int,10)
 m1["理想"]=18
 m1["jiwuming"]=35
 fmt.Println(m1)
 value, ok := a["其它"] //ok是一个bool类型，判断是否找到
 if !ok {
	fmt.Println("查无此值")
  } else {
	fmt.Println(value)
}

//map的遍历
for k,v:=range m1{
   fmt.Println(k,v) //k是字符下标，v是值
}

//map键值的删除
//delete（map,key）
//map:表示删除键值的map
//key:表示要删除的键值对的键
delete（m1,"jiwuming"）
}

//元素类型为map的切片
 var s1=make([]map[int]string,1,10)
 s1[0]=make(map[int]string,1)
 s1[0][100]="A"
 fmt.Println(s1)

//值为切片类型的map
var m1=make(map[string][]int,10)
m1["北京"]=[]int{1,2,3,4}

type a struct{
	val int
	next *a
}//链表