6. go数组与冒泡排序

include

1. 数组的概念
2. 如何定义数组
3. 数组常用的用法
4. 数组如何指定下标设值
5. 二维数组
6. 冒泡排序

数组

• 定义数组的格式：var [n] , n>=0
• 数组长度也是类型的一部分，因此具有不同的长度的数组为不同类型。
• 注意区分指数组指针和指针数组
• 数组在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)
}