Go语言-数组
目录
1、声明数组
2、初始化数组
3、访问数组元素
4、多维数组
5、向函数传递数组
数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如：整型、字符串或者自定义的类型。
相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。
数组元素可以通过索引（位置）来读取（或者修改），索引从0 开始，第一个元素索引为 0，第二个索引为1，以此类推。
1、声明数组
语法格式：
var variable_name [SIZE] variable_type
variable_name:数组的名称
SIZE:数组长度，必须是常量
variable_type:数组保存元素的类型例如：以下定义了数组 balanc 长度为10类型为 floa32
var balance [10] float322、初始化数组
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}可以通过字面量在声明数组的同时快速初始化数组
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}如果数组长度不确定，可以使用 ... 代替数组的长度，编译器会根据元素个数自行推断数组的长度
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}如果设置了数组的长度，还可以通过下标来初始化元素
package main
import "fmt"
func main() {
//将索引为1和3的元素进行初始定值，其他的为默认数值
balance := [5]float32{1: 2.0, 3: 7.0}
fmt.Println(balance)
}
//运行结果为：
[0 2 0 7 0]3、访问数组元素
数组元素可以通过索引（位置）来读取，格式为数组名后加 [] ,中括号里的值为索引值
var salary float32 = balance[9]示例：提取数组里的元素
package main
import "fmt"
//定义数组 元素 下标 数组长度
var Array = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
func main() {
//数组元素提取
fmt.Println(Array[0])
fmt.Println(Array[9])
}
//运行结果为：
1
10也可以通过遍历的方法提取元素
package main
import "fmt"
//定义数组
var Array = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
func main() {
//数组元素提取
//用len(Array)代表下标次数，防止出现下标越界
for i := 0; i < len(Array); i++ {
fmt.Println(Array[i])
}
//输出数组的长度
fmt.Println("数组长度是：", len(Array))
}
//运行结果为：
1
2
3
4
5
6
7
8
9
10
数组长度是： 10示例：随机输入5个数，求出输入数的最大值
package main
import "fmt"
//随机输入5个数，求出输入数的最大值
func main() {
var (
tmp int //定义平台
num int //定义数字
numbers [5]int //定义名单
)
for i := 0; i < 5; i++ {
fmt.Printf("请输入第%d个数字：", i+1)
fmt.Scan(&num)
//输入的数字添加到名单中
numbers[i] = num
}
fmt.Println("数字名单录入完成")
//定义第一个数字到平台
tmp = numbers[0]
for j := 1; j < 5; j++ {
//比较最大值
if numbers[j] > tmp {
tmp = numbers[j]
} else {
continue
}
}
fmt.Println("最大值：", tmp)
}
//运行结果为：
请输入第1个数字：99
请输入第2个数字：88
请输入第3个数字：77
请输入第4个数字：66
请输入第5个数字：55
数字名单录入完成
最大值： 99示例：冒泡排序
初始版本的详细过程，因为有过多的重复代码可以进行精简
package main
import "fmt"
var arr [5]int = [5]int{99, 66, 11, 55, 22}
func main() {
fmt.Println("排序之前的元素:", arr)
//第一轮排序
for i := 0; i < 4; i++ {
if arr[i] > arr[i+1] {
//两数交换
arr[i], arr[i+1] = arr[i+1], arr[i]
}
}
fmt.Println("第一排序后的元素:", arr)
//第二轮排序
for i := 0; i < 3; i++ {
if arr[i] > arr[i+1] {
//两数交换
arr[i], arr[i+1] = arr[i+1], arr[i]
}
}
fmt.Println("第二排序后的元素:", arr)
//第三轮排序
for i := 0; i < 2; i++ {
if arr[i] > arr[i+1] {
//两数交换
arr[i], arr[i+1] = arr[i+1], arr[i]
}
}
fmt.Println("第三排序后的元素:", arr)
//第四轮排序
for i := 0; i < 1; i++ {
if arr[i] > arr[i+1] {
//两数交换
arr[i], arr[i+1] = arr[i+1], arr[i]
}
}
fmt.Println("第四排序后的元素:", arr)
}
//运行结果为：
排序之前的元素: [99 66 11 55 22]
第一排序后的元素: [66 11 55 22 99]
第二排序后的元素: [11 55 22 66 99]
第三排序后的元素: [11 22 55 66 99]
第四排序后的元素: [11 22 55 66 99]通过分析得到外层有4轮排序，内层比较次数每次少一次
package main
import "fmt"
var arr [5]int = [5]int{99, 66, 11, 55, 22}
func main() {
fmt.Println("排序之前：", arr)
//外层比较轮数
for j := 0; j < 4; j++ {
//内层比较次数
for i := 0; i < 4-j; i++ {
if arr[i] > arr[i+1] {
//两数交换
arr[i], arr[i+1] = arr[i+1], arr[i]
}
}
}
fmt.Println("排序之后：", arr)
}
//运行结果为：
排序之前： [99 66 11 55 22]
排序之后： [11 22 55 66 99]继续优化代码，用 len 的方式获取数组的长度，使定义的数组更加灵活
package main
import "fmt"
//不固定长度，随便添加元素
var arr = [...]int{99, 33, 88, 66, 11, 44, 55, 77, 22}
func main() {
fmt.Println("排序之前：", arr)
fmt.Println("数组长度", len(arr))
//外层比较轮数
for j := 0; j < len(arr)-1; j++ {
//内层比较次数
for i := 0; i < len(arr)-1-j; i++ {
if arr[i] > arr[i+1] {
//两数交换
arr[i], arr[i+1] = arr[i+1], arr[i]
}
}
}
fmt.Println("排序之后：", arr)
}
//运行结果为：
排序之前： [99 33 88 66 11 44 55 77 22]
数组长度 9
排序之后： [11 22 33 44 55 66 77 88 99]示例：定义不定长数组添加元素
package main
import "fmt"
func main() {
var (
name string
names []string
)
for i := 0; i < 5; i++ {
fmt.Printf("请输入第%d个人姓名：", i+1)
fmt.Scan(&name)
//数组元素的添加
names = append(names, name)
fmt.Println("添加成功")
}
fmt.Println(names)
}
//运行结果为：
请输入第1个人姓名：zhangsan
添加成功
请输入第2个人姓名：lisi
添加成功
请输入第3个人姓名：wangwu
添加成功
请输入第4个人姓名：zhaoliu
添加成功
请输入第5个人姓名：tianqi
添加成功
[zhangsan lisi wangwu zhaoliu tianqi]4、多维数组
多维数组声明格式：
var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type以下实例声明了二维数组定义方式：
var arrayName [x][y] variable_type以下实例声明了三维的整型数组：
var threedim [5][10][4]int示例：
package main
import "fmt"
//定义二维数组[[1,2,3],[4,5,6]]
func main() {
//声明二维数组
var nums [][]int
//定义一维数组
row1 := [3]int{1, 2, 3}
row2 := [3]int{4, 5, 6}
//把一维数组作为元素添加到二维数组
nums = append(nums, row1[:])
nums = append(nums, row2[:])
fmt.Println("二维数组中的第一个元素：", nums[0])
fmt.Println("二维数组中的第一个元素：", nums[1])
fmt.Println("二维数组中的第一个一维数组中的第一个元素", nums[0][0])
fmt.Println("二维数组中的第二个一维数组中的第一个元素", nums[1][0])
}
//运行结果为：
二维数组中的第一个元素： [1 2 3]
二维数组中的第一个元素： [4 5 6]
二维数组中的第一个一维数组中的第一个元素 1
二维数组中的第二个一维数组中的第一个元素 4初始化二维数组
多维数组可以通过大括号来初始值，以下实例为一个2行3列的二维数组：
nums := [2][3]int{
{1,2,3},
{4,5,6},
}访问二维数组
二维数组通过指定坐标来访问。如数组中的行索引与列索引：
package main
import "fmt"
func main() {
nums := [2][3]int{
{1, 2, 3},
{4, 5, 6},
}
//外循环二维数组
for i := 0; i < 2; i++ {
//内循环一维数组
for j := 0; j < 3; j++ {
fmt.Printf("nums[%d][%d] = %d\n", i, j, nums[i][j])
}
}
}
//运行结果为：
nums[0][0] = 1
nums[0][1] = 2
nums[0][2] = 3
nums[1][0] = 4
nums[1][1] = 5
nums[1][2] = 6示例：创建各个维度元素数量不一致的多维数组
用 range 函数，通过下标位置来定位元素
package main
import "fmt"
func main() {
//创建空的二维数组
names := [][]string{}
//创建三个一个数组，各数组长度不同
row1 := []string{"zhangsan", "lisi", "wangwu"}
row2 := []string{"zhaoliu"}
row3 := []string{"tianqi", "laoba"}
//使用append()函数将一维数组添加到二维数组中
names = append(names, row1)
names = append(names, row2)
names = append(names, row3)
//循环输出
for i := range names {
fmt.Printf("row:%v\n", i)
fmt.Println(names[i])
}
}
//运行结果为：
row:0
[zhangsan lisi wangwu]
row:1
[zhaoliu]
row:2
[tianqi laoba]5、向函数传递数组
如果想向函数传递数组参数，需要在函数定义时，声明形参为数组
方式一：形参设定数组大小
void myFunction(param [10]int)
{
.
.
.
}方式二：形参未设定数组大小
void myFunction(param []int)
{
.
.
.
}示例：函数接收整数型数组参数，并求出整数和。
package main
import "fmt"
var nums [5]int
func main() {
nums = [5]int{10, 20, 30, 40, 50}
fmt.Println("元素的和为：", sum(nums))
}
func sum(arr [5]int) int {
//定义求和的变量
s := 0
//求和过程
for i := range arr {
s += arr[i]
}
return s
}
//运行结果为：
元素的和为： 150