【Golang】数组

*本文笔记参考：b站【尚硅谷】Golang入门到实战教程

1、一维数组

%p%v

1）定义

var 数组名 [长度]类型

var score [5]float64

2）初始化

var numArray01 [3]int = [3]int {1, 2, 3}  # 方法一
var numArray02 = [3]int {1, 2, 3}  # 方法二
var numArray03 = [...]int {1, 2, 3}  # 方法三
var numArray04 = [3]int {1:1, 0:2, 2:3}  # 方法四，指定下标
numArray05 := [...]int {1, 2, 3}  # 方法五，类型推导

3）数组的遍历

for index, value := range array {
    ...
}

index 是数组的下标；
value 是在该下标位置的值；
index，value 是仅在 for 循环内部可见的局部变量；
数组遍历元素的时候，如果不想使用下标 index，可以直接把下标 Index 标为下划线_；
index 和 value 的名称不是固定的，即程序员可以自行指定，一般命名为 index 和value。

4）数组使用的注意事项

package main

import "fmt"

func test(arr [3]int)  {
    arr[0] = 5            // 将arr[0]的值改为5
    fmt.Printf("1. 函数中的arr= %d\n", arr)
}

func main() {
    var arr = [3]int {1,2,3}
    test(arr)
    fmt.Printf("2. main中的arr= %d", arr)
}

package main

import "fmt"

func test(arr *[3]int)  {
    (*arr)[0] = 5           // 将arr[0]的值改为5
    fmt.Printf("1. 函数中的arr= %d\n", *arr)
}

func main() {
    var arr = [3]int {1,2,3}
    test(&arr)
    fmt.Printf("2. main中的arr= %d\n", arr)
    fmt.Printf("%T", arr)
}

5）数组的应用实例

（1）使用数组打印'A'-'Z'

创建一个byte类型的26个元素的数组，分别放置'A'-'Z'。使用for循环访问所有元素并打印出来。提示：字符数据运算：'A'+1 -> 'B'。

package main

import "fmt"

func main() {
    var arr [26]byte
    arr[0] = 'A'
    for i, _ := range arr {
        if i != 0 {
            arr[i] = arr[i-1] + 1
        }
        fmt.Printf("%c ", arr[i])  //byte类型的字符需用%c打印
    }
}

（2）求出一个数组的最大值，并得到对应的下标。

package main

import "fmt"

func main() {
    var arr = [...]int {1, -1, 9, 90, 11}
    max := arr[0]
    maxIndex := 0
    for i, _ := range arr {
        if i != 0 {
            if max < arr[i] {
                max = arr[i]
                maxIndex = i
            }
        }
    }
    fmt.Printf("最大值为: arr[%d]= %d", maxIndex, max)
}

（3）请求出一个数组的和和平均值。for-range

package main

import "fmt"

func main() {
    var arr = [...]int {1, -1, 9, 90, 10}
    sum := 0
    for _, v := range arr {
        sum += v
    }
    avg := float64(sum)/float64(len(arr))
    fmt.Printf("和: %d,  平均值: %.2f", sum, avg)
}

（4）随机生成5个数，并将其反转打印。

package main

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

func main() {
	var arr [5]int
	// 为了每次生成的随机数不一样，需要给一个seed值
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < len(arr); i++ {
		arr[i] = rand.Intn(10)  //取[0,n)范围内的随机数
	}
	fmt.Println(arr)
	for i, _ := range arr {
		fmt.Printf("%d ", arr[len(arr)-i-1])
	}
}

2、二维数组

1）基本使用

方式一：先定义，再赋值

var arr [4][6]int  //var 数组名 [大小][大小]type
arr[1][2] = 1

方式二：直接初始化

var arr [4][6]int = [4][6]int{{0, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 2, 0, 3}}

方式三：其他方式

//var 数组名 [大小][大小]type = [...][大小]type{{初值},...}
//var 数组名 = [大小][大小]type{{初值},...}
//var 数组名 = [...][大小]type{{初值},...}

2）二维数组的应用实例

（1）定义二维数组，用于保存三个班，每个班五名同学的成绩，并求出每个班级平均分、以及所有班级平均分。

package main

import "fmt"

func main() {
	var scores [3][5]float64
	var avg [3]float64
	var avgAll float64
	for i := 0; i < len(scores); i++ {
		for j := 0; j < len(scores[i]); j++ {
			fmt.Printf("请输入第%d个班，第%d个学生的成绩：", i+1, j+1)
			fmt.Scanln(&scores[i][j])
			avg[i] += scores[i][j]
		}
		avgAll += avg[i]
		fmt.Printf("第%d个班级的平均分为：%v\n", i+1, avg[i]/float64(len(scores[i])))
	}
	fmt.Printf("所有班级的平均分为：%v", avgAll/15)
}

（2）随机生成10个整数（1-100的范围）保存到数组，并倒序打印以及求平均值、最大值和最大值的下标，并查找里面是否有55。

package main

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

func main() {
	var arr [10]int
	avg := 0
	max := arr[9]
	maxIndex := 0
	flag := false
	for i := 9; i >= 0; i-- {
		rand.Seed(time.Now().UnixNano())
		arr[i] = rand.Intn(100)
		avg += arr[i]
		if max < arr[i] {
			max = arr[i]
			maxIndex = i
		}
		if arr[i] == 55 {
			flag = true
		}
		time.Sleep(100)
	}
	for _, v := range arr {
		fmt.Print(v)
		fmt.Print(" ")
	}
	fmt.Println()
	fmt.Printf("平均值为%v\n最大值为%v，下标为%v\n", avg/10, max, maxIndex)
	if flag == false {
		fmt.Println("找不到55")
	} else {
		fmt.Println("有55")
	}
}

（3）已知有个排序好（升序）的数组，要求插入一个元素，最后打印该数组，顺序依然是升序。

package main

import (
	"fmt"
)

func main() {
	var arr = [5]int{2, 4, 6, 8, 10}
	var resArr [6]int
	var num int
	fmt.Println("请输入要插入的数：")
	fmt.Scanln(&num)
	//把插入的数与数组的每个元素进行比较
	for i := 0; i < len(arr); i++ {
		if num < arr[i] {
			resArr[i] = num
			//插入后，resArr[j] = arr[j-1]
			for j := i + 1; j < len(resArr); j++ {
				resArr[j] = arr[j-1]
			}
			break
		} else {
			resArr[i] = arr[i]
		}
	}
	if resArr[5] == 0 {
		resArr[5] = arr[4]
	}
	fmt.Println(resArr)
}

（4）定义一个3行4列的二维数组，逐个从键盘输入值，编写程序将四周的数据清0。

package main

import (
	"fmt"
)

func main() {
	var arr [3][4]int
	for i := 0; i < 3; i++ {
		for j := 0; j < 4; j++ {
			fmt.Printf("请输入第%v行第%v列的数：", i+1, j+1)
			fmt.Scan(&arr[i][j])
		}
	}
	for i := 0; i < 3; i++ {
		for j := 0; j < 4; j++ {
			if i == 0 || j == 0 || j == 3 || i == 2 {
				arr[i][j] = 0
			}
			fmt.Print(arr[i][j], " ")
		}
		fmt.Println()
	}
}

（5）定义一个4行4列的二维数组逐个从键盘输入值，然后将第1行和第4行的数据进行交换，将第2行和第3行的数据进行交换。

package main

import (
	"fmt"
)

func main() {
	var arr [4][4]int
	for i := 0; i < 4; i++ {
		for j := 0; j < 4; j++ {
			fmt.Printf("请输入第%v行第%v列的数：", i+1, j+1)
			fmt.Scan(&arr[i][j])
		}
	}
	for i := 0; i < 4; i++ {
		for j := 0; j < 4; j++ {
			if i < 2 {
				arr[i][j], arr[3-i][j] = arr[3-i][j], arr[i][j]
			}
			fmt.Print(arr[i][j], " ")
		}
		fmt.Println()
	}
}

（6）试保存1 3 5 7 9五个奇数到数组，并倒序打印。

func main() {
	var arr = [5]int{1, 3, 5, 7, 9}
	for i := 4; i >= 0; i-- {
		fmt.Print(arr[i], " ")
	}
}

（7）写出实现查找的核心代码，比如已知数组arr[10] string，里面保存了十个元素，现要查找"AA"在其中是否存在，打印提示，如果有多个"AA"，也要找到对应的小标。

func main() {
	var arr = [10]string{"AA", "BB", "CC", "AA", "DD", "HUB", "HUB", "hub", "aa", "nj"}
	flag := false
	for i := 0; i < 10; i++ {
		if arr[i] == "AA" {
			fmt.Printf("有AA，下标为%v\n", i)
			flag = true
		}
	}
	if flag == false {
		fmt.Println("没有AA")
	}
}

（8）随机生成10个整数（1-100之间），使用冒泡排序法进行排序，然后使用二分查找法，查找是否有90这个数，并显示下标，如果没有则提示“找不到该数”。

package main

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

func bubbleSort(arr *[10]int) {
	for i := 1; i < 10; i++ {
		for j := 0; j < 10-i; j++ {
			if (*arr)[j] > (*arr)[j+1] {
				(*arr)[j], (*arr)[j+1] = (*arr)[j+1], (*arr)[j]
			}
		}
	}
	fmt.Println("排序后的arr: ", *arr)
}

func binaryFind(arr [10]int, leftIndex int, rightIndex int, findVal int) {
	middle := (leftIndex + rightIndex) / 2
	if leftIndex > rightIndex {
		fmt.Println("找不到")
		return
	}
	if arr[middle] > findVal {
		binaryFind(arr, leftIndex, middle-1, findVal)
	} else if arr[middle] < findVal {
		binaryFind(arr, middle+1, rightIndex, findVal)
	} else {
		fmt.Printf("找到了，下标为%v", middle)
	}
}

func main() {
	var arr [10]int
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < 10; i++ {
		arr[i] = rand.Intn(100) + 1
	}
	fmt.Println("排序前的arr：", arr)
	bubbleSort(&arr)
	binaryFind(arr, 0, 9, 90)
}

（9）编写一个函数，可以接收一个数组，该数组有5个数，请找出最大的数和最小的数及对应的数组下标。

package main

import "fmt"

func array(arr [5]int) {
	max := arr[0]
	min := arr[0]
	maxIndex := 0
	minIndex := 0
	for i := 0; i < 5; i++ {
		if max < arr[i] {
			max = arr[i]
			maxIndex = i
		}
		if min > arr[i] {
			min = arr[i]
			minIndex = i
		}
	}
	fmt.Printf("最大的数为%d，下标为%d\n最小的数为%d，下标为%d", max, maxIndex, min, minIndex)
}

func main() {
	var arr = [5]int{90, 78, 101, 24, 37}
	array(arr)
}

（10）定义一个数组，并给出8个整数，求该数组中大于平均值的数的个数，和小于平均值的数的个数。

package main

import "fmt"

func array(arr [8]int, avg int) {
	big := 0
	short := 0
	for i := 0; i < 8; i++ {
		if arr[i] < avg {
			short++
		} else if arr[i] > avg {
			big++
		}
	}
	fmt.Printf("大于平均值的数有%d个\n小于平均值的数有%d个", big, short)
}

func main() {
	var arr = [8]int{90, 78, 101, 24, 37, 68, 48, 67}
	avg := 0
	for i := 0; i < 8; i++ {
		avg += arr[i]
	}
	avg = avg / 8
	fmt.Println(arr, avg)
	array(arr, avg)
}

（11）跳水比赛，8个评委打分。运动员的成绩是8个成绩去掉1个最高分、去掉一个最低分，剩下的6个分数的平均分就是最后评分。使用一维数组实现如下功能：

把打最高分的评委和打最低分的评委找出来。
找出最佳评委和最差评委。最佳评委就是打分和最后得分最接近的评委。最差评委就是打分和最后得分相差最大的评委。

package main

import (
	"fmt"
	"math"
)

func maxMin(arr [8]float64) (avg float64) {
	max := arr[0]
	min := arr[0]
	maxIndex := 0
	minIndex := 0
	avg = 0.0
	for i := 0; i < 8; i++ {
		if max < arr[i] {
			max = arr[i]
			maxIndex = i
		}
		if min > arr[i] {
			min = arr[i]
			minIndex = i
		}
		avg += arr[i]
	}
	avg = (avg - max - min) / 6
	fmt.Printf("平均分为：%.2f\n", avg)
	fmt.Printf("打分最高的评委为%d\n打分最低的评委为%d\n", maxIndex, minIndex)
	return avg
}

func best(arr [8]float64, avg float64) {
	max := math.Abs(arr[0] - avg)
	min := math.Abs(arr[0] - avg)
	maxIndex := 0
	minIndex := 0
	for i := 0; i < 8; i++ {
		if max < math.Abs(arr[i]-avg) {
			max = math.Abs(arr[i] - avg)
			maxIndex = i
		}
		if min > math.Abs(arr[i]-avg) {
			min = math.Abs(arr[i] - avg)
			minIndex = i
		}
	}
	fmt.Printf("最佳评委：%d\n最差评委：%d", minIndex, maxIndex)
}

func main() {
	var arr = [8]float64{90.6, 78.0, 101.8, 24.9, 37, 92, 56, 80}
	fmt.Println(arr)
	avg := maxMin(arr)
	best(arr, avg)
}

1）定义

2）初始化

3）数组的遍历

4）数组使用的注意事项

5）数组的应用实例

（1）使用数组打印'A'-'Z'

（2）求出一个数组的最大值，并得到对应的下标。

（3）请求出一个数组的和 和 平均值。for-range

（4）随机生成5个数，并将其反转打印。

1）基本使用

2）二维数组的应用实例

（1）定义二维数组，用于保存三个班，每个班五名同学的成绩，并求出每个班级平均分、以及所有班级平均分。

（2）随机生成10个整数（1-100的范围）保存到数组，并倒序打印以及求平均值、最大值和最大值的下标，并查找里面是否有55。

（3）已知有个排序好（升序）的数组，要求插入一个元素，最后打印该数组，顺序依然是升序。

（4）定义一个3行4列的二维数组，逐个从键盘输入值，编写程序将四周的数据清0。

（5）定义一个4行4列的二维数组逐个从键盘输入值，然后将第1行和第4行的数据进行交换，将第2行和第3行的数据进行交换。

（6）试保存1 3 5 7 9五个奇数到数组，并倒序打印。

（7）写出实现查找的核心代码，比如已知数组arr[10] string，里面保存了十个元素，现要查找"AA"在其中是否存在，打印提示，如果有多个"AA"，也要找到对应的小标。

（8）随机生成10个整数（1-100之间），使用冒泡排序法进行排序，然后使用二分查找法，查找是否有90这个数，并显示下标，如果没有则提示“找不到该数”。

（9）编写一个函数，可以接收一个数组，该数组有5个数，请找出最大的数和最小的数及对应的数组下标。

（10）定义一个数组，并给出8个整数，求该数组中大于平均值的数的个数，和小于平均值的数的个数。

（11）跳水比赛，8个评委打分。运动员的成绩是8个成绩去掉1个最高分、去掉一个最低分，剩下的6个分数的平均分就是最后评分。使用一维数组实现如下功能：

（3）请求出一个数组的和和平均值。for-range