Go 语言数组

数组定义及其使用

语法：var 数组名 [数组长度]数组类型

重点：数组内保存的都是同一种类型的数据

package main

import "fmt"

func main() {

	// 1. 声明 int 类型的数组
	var arr1_int [5]int

	// 给 int 类型的数组 arr_int 赋值
	arr1_int[0] = 0
	arr1_int[1] = 1
	arr1_int[2] = 2
	arr1_int[3] = 3
	arr1_int[4] = 4

	// 2. 初始化 int 类型的数组
	var arr2_int [5]int = [5]int{0, 1, 2, 3, 4}

	// 3. range 范围循环遍历数组 arr1_int 中的每个元素
	for _, value := range arr1_int {
		fmt.Println(value)
	}

	// 4. range 范围循环遍历数组 arr2_int 中的每个元素
	for _, value := range arr2_int {
		fmt.Println(value)
	}
}

长度为 5，类型为 int 的数组声明

var arr_int [5]int

长度为 5，类型为 int 的数组初始化

第一种：直接初始化

var arr_int [5]int = [5]int{1, 2, 3, 4, 5}

第二种：自动推导进行初始化

arr_int := [5]int{1, 2, 3, 4, 5}

第三种：部分初始化

arr_int := [5]int{1, 2, 3}

第四种：通过索引指定某个元素初始化

arr_int := [5]int{2: 1, 4: 2}

第五种：通过初始化来确定数组的长度

arr_int := [...]int{1, 2, 3, 4, 5}

定义其它类型的数组来分析不进行初始化数组的结果！

float64 类型数组若未进行初始化，其中的数据都将置为 0

package main

import "fmt"

func main() {

	var arr_float64 [5]float64

	// range 范围循环遍历数组 arr_float64 中的每个元素
	for _, value := range arr_float64 {
		fmt.Print(value)
	}

	// output:00000
}

string 类型数组若未进行初始化，其中的数据都将置为空字符串

package main

import "fmt"

func main() {

	var arr_string [5]string

	// range 范围循环遍历数组 arr_float64 中的每个元素
	for _, value := range arr_string {
		fmt.Print(value)
	}

	// output:_____(_代表空字符串)
}

bool 类型数组若未进行初始化，其中的数据都将置为 false

package main

import "fmt"

func main() {

	var arr_bool [5]bool

	// range 范围循环遍历数组 arr_bool 中的每个元素
	for _, value := range arr_bool {
		fmt.Print(value)
	}

	// output:falsefalsefalsefalsefalse
}

自定义需求：通过自定义的函数从某个数组中取出最大值，最小值和总和

package main

import "fmt"

func max_min_sum(arr_int [5]int) (max, min, sum int) {
	max, min, sum = 0, 100, 0

	for i := 0; i < len(arr_int); i++ {
		if arr_int[i] > max {
			max = arr_int[i]
		}

		if arr_int[i] < min {
			min = arr_int[i]
		}

		sum += arr_int[i]
	}

	return
}

func main() {

	// 声明 int 类型的数组
	arr_int := [5]int{1, 3, 7, 9, 13}

	// 调用函数
	max, min, sum := max_min_sum(arr_int)

	// 输出数据
	fmt.Printf("最大值为：%d，最小值为：%d，总和为：%d", max, min, sum)

	// output:最大值为：13，最小值为：1，总和为：33
}

数组逆置

package main

import "fmt"

func nizi(arr_int [5]int) {
	// 数组起始节点
	Start := 0
	// 数组末尾节点
	End := len(arr_int) - 1

	for Start < End {
		arr_int[Start], arr_int[End] = arr_int[End], arr_int[Start]

		Start++
		End--
	}

	for _, value := range arr_int {
		fmt.Print(value)
	}
}

func main() {

	// 初始化 int 类型的数组
	arr_int := [5]int{1, 2, 3, 4, 5}

	// 调用函数
	nizi(arr_int)

	// output:54321
}

冒泡排序

package main

import "fmt"

func bubbleSort(arr_int [9]int) {
	for i := 0; i < 8; i++ {
		for j := 0; j < 8-i; j++ {
			if arr_int[j] > arr_int[j+1] {
				arr_int[j], arr_int[j+1] = arr_int[j+1], arr_int[j]
			}
		}
	}

	// range 函数打印
	for _, value := range arr_int {
		fmt.Print(value)
	}
}

func main() {

	// 初始化 int 类型的数组
	arr_int := [...]int{1, 3, 2, 5, 7, 6, 4, 9, 8}

	// 调用函数
	bubbleSort(arr_int)

	// output:123456789
}

随机数

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {

	// 1. 导入随机数种子 -- 如果没有此语句那么生成的随机数都是固定不变的
	rand.Seed(time.Now().UnixNano())

	// 2. 生成随机数
	fmt.Println(rand.Int())    //生成比较大随机数
	fmt.Println(rand.Intn(10)) // 限定范围的随机数 0 ~ 9

	// output:123456789
}

根据时间来生成随机数来保证每次生成的随机数不一样

rand.Seed(time.Now().UnixNano())

使用随机数创建一个没有重复数据的数组

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {

	// 随机数种子
	rand.Seed(time.Now().UnixNano())

	// 1. 创建一个数组
	var arr_int [10]int

	// 2. 利用循环来为数组中添加元素
	for i := 0; i < len(arr_int); i++ {
		rand_num := rand.Intn(100) // 生成 0~99 的随机数

		// 进行内部比较
		for j := 0; j < i; j++ {
			if rand_num == arr_int[j] {
				rand_num = rand.Intn(100)
				// 从头开始比较
				j = -1
			}
		}

		arr_int[i] = rand_num
	}

	fmt.Print(arr_int)

	// output:[61 19 13 0 85 33 53 46 62 14]
}

案例：双色球

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {

	//自定义场景
	// 红球  1~33 选择 6 个(不重复)
	// 蓝球  1~16 选择 1 个(可以和红球重复)

	// 随机数种子
	rand.Seed(time.Now().UnixNano())

	// 1. 创建一个数组
	var red [6]int

	// 2. 利用循环来为数组中添加元素
	for i := 0; i < len(red); i++ {
		rand_num := rand.Intn(33) + 1 // 生成 1~33 的随机数

		// 进行内部比较
		for j := 0; j < i; j++ {
			if rand_num == red[j] {
				rand_num = rand.Intn(33) + 1
				// 从头开始比较
				j = -1
			}
		}

		red[i] = rand_num
	}

	fmt.Println("红球", red, "篮球", rand.Intn(16)+1)

	// output:红球 [12 25 21 3 6 11] 篮球 7
}

二维数组

语法：var 数组名 [数组行数][数组列数]数组类型

package main

import "fmt"

func main() {

	// 声明一个二行三列的整型数组
	var arr_int [2][3]int

	// 打印二维数组的行数
	fmt.Println(len(arr_int)) // 2

	// 打印二维数组的列数
	fmt.Println(len(arr_int[0])) // 3
}

二维数组的赋值及取值操作

重点：int 数组内未赋值的元素用 0 自动填充

package main

import "fmt"

func main() {

	// 声明一个二行三列的整型数组
	var arr_int [2][3]int

	// 给二维数组的第一行第一列的元素赋值为 0
	arr_int[0][0] = 0
	// 给二维数组的第二行第二列的元素赋值为 0
	arr_int[1][1] = 5

	// 循环打印数组内的值
	for _, value := range arr_int {
		fmt.Print(value)
	}

	// output:[0 0 0][0 5 0]
}

自动推导类型创建二维数组

package main

import "fmt"

func main() {

	// 初始化一个二行三列的整型数组
	arr_int := [2][3]int{
		{1, 2, 3},
		{4, 5, 6},
	}

	// 循环打印数组内的值
	for _, value := range arr_int {
		fmt.Print(value)
	}

	// output:[1 2 3][4 5 6]
}