go数据结构整理

迷南。 2022-05-14 03:15 141阅读 0赞

初始化基本一样，不同点需要注意，make使用，nil变量的访问

## array ##

初始化：

57 //修改元素值函数，指针版本和副本版本，指针版会修改原值
     58 func modify(arr [3]int, i int, v int) {
     59     //func modify(arr *[3]int, i int, v int) {
     60     arr[i] = v
     61 }   
     62 
     63 func main() {
     64     var v [2]int        //默认初始化为0
     65     v1 := [2]int{}      //默认初始化为0
     66     v2 := [...]int{}    //根据初始化列表决定元素个数，元素个数为0
     67     v3 := [3]int{2: 99} //指定索引初始化
     68     
     69     fmt.Println(v, v1, v2, v3)
     70 }

## slice ##

初始化：

71 //切片函数参数版本
     72 func modify(arr []int, i int, v int) {
     73     arr[i] = v
     74 }
     75 
     76 func main() {
     77     //和数组区别在于是否指定元素个数，和数组一样都是有长度的，所有随机访问时小心越界
     78     var v []int      //v == nil，nil值切片没有底层数组
     79     vv := []int(nil) //vv == nil，nil值切片没有底层数组
     80 
     81     v0 := []int{} //v != nil，nil切片和0长度切片行为一致，函数会等同对待
     82     v1 := []int{1, 2}
     83 
     84     var arr [3]int
     85     v2 := arr[:]
     86     v3 := arr[2:]
     87 
     88     v3 = v1
     89     modify(v3, 0, 111)
     90     v2 = nil
     91 
     92     v4 := make([]int, 3, 6) //若不指定cap，则和len一致
     93 
     94     //v5 := make([]int, 4)
     95     //v5 = v4[4:] //panic:slice bounds out of range，v4超过了len()
     96     v4 = push(v4, 123)
     97     v4 = push(v4, 123)
     98     v4 = push(v4, 123)
     99     v4 = push(v4, 123)
    100 
    101     fmt.Println(v == nil, vv == nil, v0 == nil, v1, v2 == nil, v3, cap(v4), len(v4), v4)
    102 
    103 }

数组可以用==进行比较，切片编译错误

append简单实现：

45 func push(s []int, v int) []int {
     46     var tmp_s []int
     47     if len(s) < cap(s) {
     48         tmp_s = s[:(len(s) + 1)]
     49     } else {
     50         tmp_s = make([]int, len(s)+1, 2*len(s))
     51         copy(tmp_s, s)
     52     }
     53 
     54     tmp_s[len(s)] = v
     55 
     56     return tmp_s
     57 }

copy函数，按照src,dst最小长度进行底层数组数据拷贝

appen使用：

105     v5 := make([]int, 2, 6)
    106     v5 = append(v5, 1, 2)
    107     v5 = append(v5, v4...)

append变长简单实现：

76 func push_s(s []int, v ...int) []int {
     77     var tmp = make([]int, len(s)+len(v))
     78     copy(tmp, s)
     79     copy(tmp[len(s):], v)
     80 
     81     return tmp
     82 }

slice内存技巧：

不用分配新空间，在原slice上修改

清理0数据

84 func RemoveInvalid2(s []int) []int {
     85     i := 0
     86     for _, v := range s {
     87         if v != 0 {
     88             s[i] = v
     89             i++
     90         }
     91     }
     92 
     93     return s[:i]
     94 }
     95 
     96 func RemoveInvalid(s []int) []int {
     97     s_tmp := s[:0]
     98     for _, v := range s {
     99         if v != 0 {
    100             s_tmp = append(s_tmp, v)
    101         }
    102     }
    103 
    104     return s_tmp
    105 }

107 func RemoveIndex(s []int, i int) []int {
    108     if i >= len(s) {
    109         return s
    110     }
    111     copy(s[i:], s[i+1:])
    112     return s[:len(s)-1]
    113 }
    114 
    115 func Reverse(s []int) []int {
    116     if len(s) < 2 {
    117         return s
    118     }
    119     for i := range s {
    120         if i >= (len(s) - i - 1) {
    121             return s
    122         }
    123         s[i], s[len(s)-i-1] = s[len(s)-i-1], s[i]
    124     }
    125     return s
    126 }

我们也看到了slice作为函数参数的使用，同样map也是会作为引用来使用的，使用时要注意slice和map内部变化，防止得不到想要的结果，所以我一般会在函数返回后进行赋值

## map ##

128 func insert(m map[int]string, i int, s string) map[int]string {
    129     m[i] = s
    130     return m
    131 }
    132 
    133 func main() {
    134     var m map[int]string
    135     m1 := map[int]string{2: "ss", 5: "aa"}
    136     delete(m1, 5)
    137 
    138     m2 := make(map[int]string)
    139     m3 := map[int]string{}
    140     m3 = insert(m3, 2, "aaaaaaa")
    141 
    142     m4 := make(map[int]map[string]bool)
    143     fmt.Println(m == nil, m1, m2, m3, m4)
    144 }

注意：key必须是可比较的类型，如字符串，数组（可比较的字段），结构体（可比较的字段）

slice不能比较，但可以转换成字符串再存储为key

##       struct ##

149 type Point struct {
    150     x, y float64
    151 }
    152 
    
    158 
    159 type line struct {
    160     pt []Point
    161 }
    163 func main() {
    164     /*
    165         l := []struct {
    166             pt  []Point
    167             cnt int
    168         }{
       {
    169             pt: []Point{
       {
    170                 x: 1,
    171                 y: 2,
    172             }, {
    173                 x: 3,
    174                 y: 4,
    175             }},
    176             cnt: 2,
    177         }}
    178     */
    179 
    180     var pt Point
    181     pt.x = 1
    182     pt.y = 2
    183 
    184     pt1 := Point{1, 2} //这种初始化方式不推荐，建议用下方
    185     pt2 := Point{x: 1, y: 2}
    186 
    187     l := []line{}
    188 
    189     var l1 line
    190     //l1 := line{}
    191 
    192     l = append(l, l1)
    193     l[0].pt = append(l[0].pt, Point{11, 22})
    194     fmt.Println(pt, pt1, pt2, l, l1)
    195 }

结构方法使用

153 //func (p *Point) Distance(target *Point) float64 {
    154 func (p Point) Distance(target *Point) float64 {
    154     p.x = 0.1
    155     target.x = 0.2
    156     return 0.0
    157 }
    
    197     pt.Distance(&pt1)
    198     fmt.Println(pt, pt1)

改变函数调用方类型，试试结果的不同

go会根据调用方类型隐式转换，所以197行可以正确运行