今天带大家认识一下Golang中的数组类型

// 指定初始值
数组名称 := [数组长度]数组类型 {初始值1,初始值2,......,初始值n}
// 初始化一个数组
var 数组名 [数组长度]数组类型

// 这两个数组不是不是同一类型的数组
var arrray1 = [10]int {1, 2}
var arrray2 = [11]int {1, 2}
// 这两组数组是同一类型的数组
var arrray1 = [10]int {1, 2}
var arrray2 = [...]int {1, 2}

func IndexArray() {
 // 长度和初始值都不设置，打印一个空数组,[]
 array1 := [...]int{}
 fmt.Println(array1)
 // 长度设置，初始值不设置，打印一个长度为1，初始值为0的数组,[0]
 array2 := [1]int{}
 fmt.Println(array2)
 // 长度不设置，设置初始值，打印出初始值[1 2]
 array3 := [...]int{1,2}
 fmt.Println(array3)
 // 长度和初始值都设置，打印出初始值[1 2 3 4]
 array4 := [4]int{1,2,3,4}
 fmt.Println(array4)
 // 长度设置，初始值设置的个数小于长度,未设置的初始值根据数组类型编译时自动设置默认值，打印出[1 2 0 0]
 array5 := [4]int{1,2}
 fmt.Println(array5)
 // 长度设置，指定索引设置初始值，其他未设置初始值的编译时自动设置默认值，打印出[0 0 0 0 0 1]
 array6 := [6]int{5: 1}
 fmt.Println(array6)
 // 长度和初始值设置，指定索引,打印出[2 2 2]
 array7 := [3]int{0:2,1:2,2:2}
 fmt.Println(array7)
}

var 数组名称 [数组长度][二维的长度]....[n维的长度] 数组类型

// 多维数组的定义
func MoreArray() {
 var array1 [1][2]int
 var array2 = [1][2]int{
  {1, 2},
 }
 // 正确定义
 var array3 = [3][2][3]int{
  {{1, 2, 3}, {3, 2, 1}},
 }
 // 正确定义
 var array3 = [3][2][3]int{
  {
   {1, 2, 3}, 
   {3, 2, 1}},
 }
 // 错误定义
 var array3 = [3][2][3]int{
  {
    {1, 2, 3}, 
    {3, 2, 1},
  },
 }
}

// output
[[[1 2 3] [3 2 1]] [[0 0 0] [0 0 0]] [[0 0 0] [0 0 0]]]

// 多维数组需要注意的地方
// 错误的定义方式
var array3 = [...][2][3]int{
    {{1, 2, 3}, {3, 2, 1}},
}
// 正确的定义方式(注意第二行结尾的","不能省略)
var array3 = [][2][3]int{
    {{1, 2, 3}, 
    {3, 2, 1}},
}

//output
[
   [[1 2 3] [3 2 1]]
   [[0 0 0] [0 0 0]] 
   [[0 0 0] [0 0 0]]
]

func LoopArray() {
 array := [4]int{1,2,3,4}
 len := len(array)
 for i := 0; i < len; i++ {
  fmt.Printf("数组array的索引%d对应的值是%d", i, array[i])
  fmt.Println()
 }
}

arr := [...]int{1, 2, 3, 4}
 for index, value := range arr {
  fmt.Println(index, value)
 }

len := len(数组名)

数组命[下标] = 值
array := [4]int{1,2,3}
array[3] = 100

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c) // "true false false"
d := [3]int{1, 2}
fmt.Println(a == d) // 编译错误：无法比较 [2]int == [3]int

func 函数名(形参名称 [数组长度]数组类型) 函数返回值 {
    // 函数体
}

// 数组与函数的使用
func Function(arr [] int) int {
    return len(arr)
}

Function([5]int{})

// 从大到小进行排序
func BubbleSort() {

 array := [...]int{2,9,3,5,1,2}
 len := len(array)
 fmt.Println(array)

 for i := 1; i < len; i++ {// 控制外层循环次数
  for j := 0; j < len-i; j++ { // 控制内部每次循环个数
   if array[j] < array[j+1] {
    tmp := array[j]
    array[j] = array[j+1]
    array[j+1] = tmp
   }
  }
 }
 fmt.Println(array)
}

// 插入排序
func InsertSort() {
 array := [...]int{2,9,3,5,1,2}
 len := len(array)
 fmt.Println(array)
 // var j int = 0
 // for i := 1; i < len; i++ {
 //  tmp := array[i]
 //  for j = i; j > 0 && tmp < array[j - 1]; j-- {
 //   array[j] = array[j - 1]
 //  }
 //  array[j] = tmp
 // }
 for i := 1; i < len; i++ {// 控制外层循环个数
  tmp := array[i]
  for j := i-1; j >= 0; j-- {// 针对已经排序好的数组再次排序
   if tmp > array[j] {
    array[j+1] = array[j]
    array[j] = tmp
   }
  }
 }
 fmt.Println(array)
}