go语言 接收二维数组为方法参数 golang 二维数组 初始化

1.定义方式有两种

1）先声明/定义，再赋值

var 数组名[大小][大小]类型

func main() {
    //二维数组示例演示
    /*
        0 0 0 0 0 0
        0 0 1 0 0 0
        0 2 0 3 0 0
        0 0 0 0 0 0
    */
    //定义、声明二维数组
    var arr [4][6]int
    arr[1][2] = 1
    arr[2][1] = 2
    arr[2][3] = 3
    //遍历二维数组，按照要求输出图形
    for i := 0; i < 4; i++ {
        for j := 0; j < 6; j++ {
            fmt.Print(arr[i][j], " ")
        }
        fmt.Println()
    }
}

2）直接初始化

var 数组名[大小][大小]类型 = [大小][大小]类型{{初值...},{初值...}}

var 数组名[大小][大小]类型 = [...][大小]类型{{初值...},{初值...}}

var 数组名 = [大小][大小]类型{{初值...},{初值...}}

var 数组名 = [...][大小]类型{{初值...},{初值...}}

数组名 := [...][大小]类型{{初值...},{初值...}}

func main() {
    var arr1 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
    fmt.Println(arr1)
}

2.二维数组遍历：for遍历和for-range遍历

func main() {
    var arr1 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
    //for循环遍历
    for i := 0; i < len(arr1); i++ {
        for j := 0; j < len(arr1[i]); j++ {
            fmt.Printf("%v\t", arr1[i][j])
        }
        fmt.Println()
    }
    //for-range来遍历二维数组
    for _, v := range arr1 {
        for _, v2 := range v {
            fmt.Printf("%v\t", v2)
        }
        fmt.Println()
    }
}

3.输入3个班每个班5个人的成绩，输出每个班的平均分和总平均分

func main() {
    var arr [3][5]float64
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[i]); j++ {
            fmt.Printf("请输入%v班第%v个学生的成绩：\n", i+1, j+1)
            fmt.Scanln(&arr[i][j])
        }
    }
    //求每个年级的平均分及总平均分
    var arrsum [3]float64
    var arravg [3]float64
    var n1 int
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[i]); j++ {
            arrsum[i] += arr[i][j]
            if arr[i][j] != 0 {
                n1++
            }
        }
        arravg[i] = arrsum[i] / float64(len(arr[i]))
    }
    var sum float64
    for _, v := range arrsum {
        sum += v
    }
    avg := sum / 15
    fmt.Printf("一共输入了%v学生的分数", n1)
    fmt.Println("每个班的平均分是：", arravg)
    fmt.Println("所有班级的平均分是：", avg)
}

4.随机生成一个[0,100)的数组，求其倒叙数组，平均值，最大值最大值下标，最小值，最小值下标，里面是否有55。

package main

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

func ran() {
    var num [10]int
    for i := 0; i < 10; i++ {
        rand.Seed(time.Now().UnixNano())
        num[i] = rand.Intn(100)
    }
    fmt.Println("数组num为：", num)
    var numf [10]int
    var sum int
    var max int = num[len(num)-1]
    var maxindex int
    var min int = num[len(num)-1]
    var minindex int
    var b1 bool = false
    for i := 0; i < 10; i++ {
        numf[i] = num[10-1-i]
        sum += numf[i]
        if max < numf[i] {
            max = numf[i]
            maxindex = i
        }
        if min > numf[i] {
            min = numf[i]
            minindex = i
        }
        if numf[i] == 55 {
            b1 = true
        }
}
fmt.Printf("倒叙数组为:%v\n 平均值为:%v\n 最大值为:%v\n 最大值下标为:%v\n 最小值为:%v\n 最小值下标为:%v\n 里面是否有55：%v\n ",
numf, sum/10, max, maxindex, min, minindex, b1)

}

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

func sx() {
    arr := []int{1, 4, 6, 8, 20}
    n1 := 18
    for i := 0; i < len(arr); i++ {
        if n1 < arr[i] {
            arr = append(arr[:i], append([]int{n1}, arr[i:]...)...)
            break
        }
    }
    fmt.Println(arr)
}

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

func erwei() {
    var arr [3][4]int
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[i]); j++ {
            fmt.Printf("请输入%v行%v列的数据：\n", i+1, j+1)
            fmt.Scanln(&arr[i][j])
            if i == 0 || j == 0 || i == (len(arr)-1) || j == (len(arr[i])-1) {
                arr[i][j] = 0
            }
        }
    }
    fmt.Println("输出四周的数据清0的数组：\n")
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[i]); j++ {
            fmt.Printf("%v ", arr[i][j])
        }
        fmt.Println()
    }
}

7.定义一个4行4列的二维数组，从键盘输入值，然后将第一行和第四行进行交换，第二行和第三行进行交换。

func chg() {
    var arr [4][4]int
    //给数组输入数组
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[i]); j++ {
            fmt.Printf("请输入%v行%v列的数据：\n", i+1, j+1)
            fmt.Scanln(&arr[i][j])
        }
    }
    //输出源数组
    fmt.Println("原数组的数据：\n")
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[i]); j++ {
            fmt.Printf("%v ", arr[i][j])
        }
        fmt.Println()
    }
    //当为第一行或者第二行时进行交换
    for i := 0; i < len(arr); i++ {
        var temp [4]int
        for j := 0; j < len(arr[i]); j++ {
            if i == 0 || i == 1 {
                temp[j] = arr[i][j]
                arr[i][j] = arr[4-1-i][j]
                arr[4-1-i][j] = temp[j]
            }
        }
    }
    //输出交换后的数组
    fmt.Println("交换后数组的数据：\n")
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[i]); j++ {
            fmt.Printf("%v ", arr[i][j])
        }
        fmt.Println()
    }
}

8.保存1 3 5 7 9 五个奇数到数组，并倒叙打印

func jishu() {
    n1 := 5
    var arr []int
    for i := 0; i < n1; i++ {
        arr = append(arr, (2*i + 1))
    }
    fmt.Println(arr)
    temp := 0
    for i := 0; i < len(arr)/2; i++ {
        temp = arr[i]
        arr[i] = arr[len(arr)-1-i]
        arr[len(arr)-1-i] = temp
    }
    fmt.Println(arr)
}

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

func fncz() {
    var arr [10]string = [10]string{"CA", "AA", "HG", "BY", "AA", "CD", "RE", "AA", "OU", "AT"}
    a1 := "AA"
    var n1 []int
    for i, v := range arr {
        if v == a1 {
            n1 = append(n1, i)
        }
    }
    fmt.Printf("下标为%v有字符%v", n1, a1)
}

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

func erfen(arr *[10]int, maxindex int, minindex int, cz int) {

    if maxindex < minindex {
        fmt.Println("找不到该数")
        return
    }
    middleindex := (maxindex + minindex) / 2
    if (*arr)[middleindex] == cz {
        fmt.Printf("找到该数%v，下标为%v", cz, middleindex)
    } else if (*arr)[middleindex] > cz {
        erfen(arr, middleindex-1, minindex, cz)
    } else {
        erfen(arr, maxindex, middleindex+1, cz)
    }
}
func suier() {
    var arr [10]int
    //生成随机数组
    for i := 0; i < len(arr); i++ {
        rand.Seed(time.Now().UnixNano())
        arr[i] = rand.Intn(100)
    }
    fmt.Println("随机数组为：", arr)
    //冒泡排序
    temp := 0
    for i := 0; i < len(arr)-1; i++ {
        for j := 0; j < (len(arr) - 1 - i); j++ {
            if arr[j+1] < arr[j] {
                temp = arr[j+1]
                arr[j+1] = arr[j]
                arr[j] = temp
            }
        }
    }
    fmt.Println("排序后的数组为：", arr)
    //二分法查找
    var cz int = 55
    erfen(&arr, len(arr)-1, 0, cz)
}

11.编写一个函数，可以接收一个数组，该数组有五个数，请找出最大数和最小数和对应的下标是多少

func f1(arr *[5]int) {
    var min int = (*arr)[0]
    var max int
    var minindex int
    var maxindex int
    for i := 0; i < len(*arr); i++ {
        if min > (*arr)[i] {
            min = (*arr)[i]
            minindex = i
        }
        if max < (*arr)[i] {
            max = (*arr)[i]
            maxindex = i
        }
    }
    fmt.Printf("最大值为：%v,最大值下标为：%v,最小值为：%v,最小值下标为：%v", max, maxindex, min, minindex)
}
func main() {
    var arr [5]int = [5]int{34, 2, 8, 12, 54}
    fmt.Println("数组为：%v", arr)
    f1(&arr)
}

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

func f2() {
    var arr [8]float64 = [8]float64{23, 45, 1, 8, 29, 34, 90, 12}
    fmt.Printf("数组为：%v\n", arr)
    sum := 0.0
    for i := 0; i < len(arr); i++ {
        sum += arr[i]
    }
    avg := sum / float64(len(arr))
    var dy int
    var xy int
    for j := 0; j < len(arr); j++ {
        if arr[j] > avg {
            dy++
        } else if arr[j] < avg {
            xy++
        }
    }
    fmt.Printf("平均值为：%v,大于平均值的个数是：%v,小于平均值的个数是：%v\n", avg, dy, xy)
}

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

1）请把打最高分的评委和最低分的评委找出来

2）找出最佳评委和最差评委，最佳评委就是打分和最后得分最接近的评委，最差评委就是打分和最后得分相差最大的。

func f3() {
    var arr1 []float64 = []float64{5, 1, 8.3, 7, 6, 9.1, 7.8, 9.5}
    fmt.Println("原始数组为:", arr1)
    var min float64 = arr1[0]
    var minindex int
    var max float64
    var maxindex int
    for i := 0; i < len(arr1); i++ {
        if min > arr1[i] {
            min = arr1[i]
            minindex = i
        }
        if max < arr1[i] {
            max = arr1[i]
            maxindex = i
        }
    }
    fmt.Printf("最大值为：%v,最大值下标为：%v,最小值为：%v,最小值下标为：%v\n", max, maxindex, min, minindex)

    var arr2 []float64
    var arr3 []float64
    var arr4 []float64
    var arr5 []float64
    if maxindex < minindex {
        arr2 = append(arr1[0:maxindex])
        arr3 = append(arr1[maxindex+1 : minindex])
        arr4 = append(arr1[minindex+1:])
    } else {
        arr2 = append(arr1[0:minindex])
        arr3 = append(arr1[minindex+1 : maxindex])
        arr4 = append(arr1[maxindex+1:])
    }
    arr5 = append(arr2, arr3...)
    arr5 = append(arr5, arr4...)
    fmt.Println("去除一个最大值一个最小值之后的最终数组为：\n", arr5)
    sum := 0.0
    for _, v := range arr5 {
        sum += v
    }
    avg := sum / float64(len(arr5))
    fmt.Println("选手评分为：", avg)
    zj := 10.0
    zjindex := 0
    zc := 0.0
    zcindex := 0
    for i := 0; i < len(arr1); i++ {
        if math.Abs(arr1[i]-avg) > zc {
            zc = math.Abs(arr1[i] - avg)
            zcindex = i
        }
        if math.Abs(arr1[i]-avg) < zj {
            zj = math.Abs(arr1[i] - avg)
            zjindex = i
        }
    }
    fmt.Printf("最佳评委为：%v,最差评委为：%v\n", arr1[zjindex], arr1[zcindex])

}