数组

常见问题

数组长度必须是常量
下标：数组的下标不能越界
两个数组类型相同，个数相同，可以赋值
数组名表示整个数组，数组名对应的地址就是数组的第一个

数组的定义和使用

func main01()  {
    //数组是指一系列同一类型数据的集合
    //数组的定义
    //var 数组名 [数组的长度] 数据类型
    var shuzhu[5] int
    fmt.Println(len(shuzhu))          //len计算长度
    fmt.Println(shuzhu)
    //数组赋值
    //1.根据下标来赋值
    shuzhu[0]=1
    shuzhu[1]=2
    shuzhu[2]=3
    shuzhu[3]=4
    shuzhu[4]=15
    fmt.Println(shuzhu)
    //fmt.Println(shuzhu[2])
    //  2.for循环赋值
    for i:=0;i<5;i++ {
        shuzhu[i]=i+1
    }
    fmt.Println(shuzhu)
    //输出组合中的数值
    for i:=0;i<5;i++{
        fmt.Println(shuzhu[i])
    }
    for _,v:=range shuzhu{       //range输出下标和值
        fmt.Println(v)
    }

    //
    //var a [10]float64   //直接输出，默认为0
    //var a [10]string  //直接输出，默认为空字符串
    //var a [10]bool        //默认输出false




}

数组内元素的初始化及其相关操作

func main02(){
    //数组初始化
    //1.全部初始化
    var a[5] int =[5]int{1,2,3,4,5}
    fmt.Println(a)

    //自动推导
    b:=[5]int{1,2,3,4,5}
    fmt.Println(b)
    //部分初始化
    c:=[5]int{1,2,3}
    fmt.Println(c)
    //指定元素初始化
    d:=[5]int{2:10,4:20}
    fmt.Println(d)
    //未知长度
    f:=[...]int{1,2,3,4,5}
    fmt.Println(len(f))

}

从数值内输出最大值和最小值

func main03()  {

    //练习从数组中输出最大最小值，平均值和总和
    var a[6]int= [6]int{11,21,113,44,25,6}

    //声明变量来储存
    var max,min,sum int
    min=a[0]            //此时min和max和sum都为0

    //for循环，if
    for i:=0;i<len(a);i++{
        if a[i]>max {               //如果下位为i的数大于max（0），则这个数值成为max                    
            max=a[i]             //循环6次
        }
        if a[i]<min {       //最小打印出来为0，因为min一开始未被赋值，所以值为0，比数组里面的数值都小
            min=a[i]
        }
        sum+=a[i]
    }
    fmt.Println(min,max,sum,sum/len(a))

}

数组的逆置

for的3种使用格式

for 表达式1；表达式2；表达式3{ }
for 返回值：=range加集合{ }
for 条件{}

func main04(){
    //数值的逆置
    var a[10]int=[10]int{1,2,3,4,5,6,7,8,9,10}

    i:=0    //最小下标
    j:=len(a)-1     //最大下标是9  len=10所以要-1

    for i<j {
        //if i>j{        //for后面跟条件就可以省去这个if
        //  break
        //}
        //交换数据
        a[i],a[j]=a[j],a[i]
        //改变下标
        i++
        j--
    }
    fmt.Println(a)


}

冒泡排序

指无序的数字集合
将他们重新排列

func main05()  {         //冒泡排序
    var arr [6] int=[6]int{7,6,9,2,8,1}

    //  外层控制行  5次
    for i:=0;i<len(arr)-1;i++ {
        //内层控制列 4次
        for j:=0;j<len(arr)-1-i;j++{
            //满足条件
            if arr[j]>arr[j+1] {
                //交换数据
            arr[j],arr[j+1]=arr[j+1],arr[j]
            }
        }
        fmt.Println(arr)

    }

随机数

由随机数字组成的数字，需要导入头文件（自动导入）来使用随机数这个功能，并利用随机数种子来创建随机数，用的是时间来改变随机数字代码为rand.Seed(time.Now().UnixNano())，通常使用rand.Intn（）来表达，下面代码是模拟六合彩，6个蓝色的球，不能够重复，1个红球，可以重复。数字分别为33和16

//随机数
func main06()  {
    //1导入头文件 math/rand
    //2随机数种子
    //创建随机数

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

    //
    //fmt.Println(rand.Int())   //生产比较大的随机数
    //fmt.Println(rand.Intn(100))   //常用

    //a:=[6]int{rand.Intn(33)+1,rand.Intn(33)+1,rand.Intn(33)+1,rand.Intn(33)+1,rand.Intn(33)+1,rand.Intn(33)+1}
    var a [6]int
    b:=rand.Intn(16)
    for i:=0;i<len(a);i++ {
        v:=rand.Intn(33)+1           //+1因为左闭右开

        //处理数据重复
        for j:=0;j<i;j++{
            if v==a[j] {
                v=rand.Intn(33）+1
                j = -1 //可以进行重新的对比整个数组,保证整个数组不会重复

            }
        }
        a[i]=v
    }
    fmt.Println("篮球",a,"红球",b)
}

数组作为函数参数

/数组作为函数参数
func 数组作为函数参数(arrs [10]int) [10]int {

    //数值作为函数参数是传值
    //形参和实参 是不同地址

    //内存中有两份独立的数值 存储不同的数据
    //在函数调用结束后 内存回收 不会影响主函数实参的值



        for i:=0;i<len(arrs)-1;i++ {
            for j := 0; j <len(arrs)-i-1; j++ {
                if arrs[j]>arrs[j+1] {
                    arrs[j], arrs[j+1] = arrs[j+1], arrs[j]
                }


            }
        }
        fmt.Println(arrs)
        return arrs
}

func main()  {
    var arrs [10]int=[10]int{23,4512,213,412,123,214,123,12312,3,123}

    //如果想通过函数计算结果改变实参的值，那么需要数组作为函数的返回值
    //赋值
    arrs=数组作为函数参数(arrs)
    fmt.Println(arrs)

如果没有使用return返回值，main函数中的arrs的值不会发生变化

简单补充二维数组,后面暂时不会用到

//前面是行后面是列
b:=[3][4]int{{1,2,3,4},{2,3,5,6},{7,5,3,5}}
fmt.Println(b)

Go语言的数组[]