6. go数组与冒泡排序

include

数组

• 定义数组的格式：var
• 数组长度也是类型的一部分，因此具有不同的长度的数组为不同类型。
• 注意区分指数组指针和指针数组
• 数组在Go中为值类型。
• 数组之间可以使用==或者!=进行比较，但是不可以使用<或>
• 可以使用new来创建数组，此方法返回一个指向数组的指针。
• go支持数组

定义数组

不同长度的数组不可以互相定义，否则编译会报错的

如下的代码：

func main() {
    var a [2]int
    var b [1]int
    b = a
    fmt.Println(b)
}

如果长度相同的两个数组，那么可以互相赋值

func main() {
    var a [2]int
    var b [2]int
    b = a
    fmt.Println(b)  // 这里打印出来的结果是两个00，[0 0]   //，因为没有给数组设值，所以默认就为零值
}

不同类型的数组之间也不可以互相赋值

如果定义数组的时候没有设值，那么久会使用零值

给数组设值：

1.定义数组我们可以使用简写的方式省去var,同时设值，如下所示：

func main() {
    a := [3]int{1, 2, 3}  // 注意为花边号
    fmt.Println(a)
}

2.给指定的索引设值

func main() {
    a := [10]int{9: 3}  // 9为这个索引的值
    fmt.Println(a)
}

3.使用三个点（...）来定义数组长度，数组的长度是动态的。

func main() {
    a := [...]int{1, 2, 3, 6}
    fmt.Println(a)
}

4.根据索引批量设值

func main() {
    a := [...]int{0: 1, 2: 2, 6: 3, 9: 6}   //因为三个点是动态的长度，所以我们的设值也可以跳跃来设
    fmt.Println(a)
}

指针数组

func main() {
    x, y := 1, 2
    a := [...]*int{&x, &y}
    fmt.Println(a)
}

数组之间的比较

go解释器 数组之间的比较是建立在数组长度和类型相同的情况下才可以比较。

func main() {
    a := [2]int{1, 2}
    b := [2]int{1, 2}
    fmt.Println(a == b)
}

new方法设定的数组和普通方法设定的数组，都可以通过下标(比如a[x]=1)来给数组元素赋值

func main() {
    a := [10]int{}
    a[1] = 3
    p := new([10]int)
    p[1] = 2   // 都可以通过这样的方法来设定指定下标的值
    fmt.Println(p, a)
}

数组

go也支持数组，和python下面的数组一样的效果

func main() {
    a := [2][3]int{
        {1, 1, 1},
        {2, 2, 2},
    }
    fmt.Println(a)
}

修改数组的值

func main() {
    a := [2][3]int{
        {1, 1, 1},
        {2, 2, 2},
    }
    a[1][1] = 6   // 指定下标来设值
    fmt.Println(a[1])
}

go语言版冒泡排序

冒泡排序的概念就不多说了，可以参考我这篇
下面我们直接拿代码来练手

// heh1
package main

import (
    "fmt"
)

func main() {
    a := [...]int{5, 3, 2, 8, 9, 1}

    fmt.Println("a ==>", a)

    num := len(a)

    for i := 0; i < num; i++ {
        for j := i + 1; j < num; j++ {
            if a[i] < a[j] {
                tmp := a[j]
                a[j] = a[i]
                a[i] = tmp
            }
        }
    }
    fmt.Println("after sort a", a)
}