Bruce Blog
Bruce
2022-10-27
目录

Array数组

# 一、数组(Array)

# 1.1 什么是数组
  • Go语言提供了数组类型的数据结构.数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整形、字符串或者自定义类型.
  • 数组元素可以通过索引(位置)来读取(或者修改),索引从0开始,第一个元素索引为0,第二个索引为1,以此类推.数组的下标取值范围是从0开始,到长度减1.
  • 数组一旦定义后,大小不能更改.
# 1.2 数组的语法
# 声明和初始化数组

需要指明数组的大小和存储的数据类型.

var variable_name [SIZE] variable_type
1

示例代码

var balance [10] float32
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
1
2

初始化数组中{}中的元素个数不能大于[]中的数字. 如果忽略[]中的数字不设置数组大小,Go语言会根据元素的个数来设置数组的大小：

var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}

balance[4] = 50.0
1
2
3

数组的其他创建方式

  var a [4] float32 // 等价于：var arr2 = [4]float32{}
  fmt.Println(a) // [0 0 0 0]
  var b = [5] string{"ruby", "王二狗", "rose"}
  fmt.Println(b) // [ruby 王二狗 rose  ]
  var c = [5] int{'A', 'B', 'C', 'D', 'E'} // byte
  fmt.Println(c) // [65 66 67 68 69]
  d := [...] int{1,2,3,4,5}// 根据元素的个数,设置数组的大小
  fmt.Println(d)//[1 2 3 4 5]
  e := [5] int{4: 100} // [0 0 0 0 100]
  fmt.Println(e)
  f := [...] int{0: 1, 4: 1, 9: 1} // [1 0 0 0 1 0 0 0 0 1]
  fmt.Println(f)
1
2
3
4
5
6
7
8
9
10
11
12
# 访问数组元素
float32 salary = balance[9]

# 示例代码
package main

import "fmt"

func main() {
   var n [10]int /* n 是一个长度为 10 的数组 */
   var i,j int

   /* 为数组 n 初始化元素 */         
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* 设置元素为 i + 100 */
   }

   /* 输出每个数组元素的值 */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109
1
2
3
4
5
6
7
8
9
10
# 数组的长度

通过将数组作为参数传递给len函数,可以获得数组的长度.

package main

import "fmt"

func main() {  
    a := [...]float64{67.7, 89.8, 21, 78}
    fmt.Println("length of a is",len(a))

}
1
2
3
4
5
6
7
8
9

运行结果：

length of a is 4
1

甚至可以忽略声明中数组的长度并将其替换为…让编译器为你找到长度.

package main

import (  
    "fmt"
)

func main() {  
    a := [...]int{12, 78, 50} // ... makes the compiler determine the length
    fmt.Println(a)
}
1
2
3
4
5
6
7
8
9
10
# 遍历数组
# 示例代码1
package main

import "fmt"

func main() {  
    a := [...]float64{67.7, 89.8, 21, 78}
    for i := 0; i < len(a); i++ { //looping from 0 to the length of the array
        fmt.Printf("%d th element of a is %.2f\n", i, a[i])
    }
}



# 示例代码2
package main

import "fmt"

func main() {
	/*
		数据的遍历:
			依次访问数组中的元素
			方法一: arr1[0],arr1[1],arr1[2]....

			方法二: 通过循环,配置下标
				for i:=0;i<len(arr);i++{
					arr[i]
				}

			方法三: 使用range
				range,词义"范围"
				不需要操作数组的下标,到达数组的末尾,自动结束for range循环,
					每次都获取数组中喜爱宝和对应的数值
	*/
	arr1 := [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr1[0])
	fmt.Println(arr1[1])
	fmt.Println(arr1[2])
	fmt.Println(arr1[3])
	fmt.Println(arr1[4])

	fmt.Println("-----------------------")
	for i := 0; i < len(arr1); i++ {
		fmt.Println(arr1[i])
	}
	fmt.Println(arr1)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# 使用range遍历数组
# 示例代码1

package main

import "fmt"

func main() {  
    a := [...]float64{67.7, 89.8, 21, 78}
    sum := float64(0)
    for i, v := range a {//range returns both the index and value
        fmt.Printf("%d the element of a is %.2f\n", i, v)
        sum += v
    }
    fmt.Println("\nsum of all elements of a",sum)
}


# 示例代码2
package main

import "fmt"

func main() {
	/*
		数据的遍历:
			依次访问数组中的元素
			方法一: arr1[0],arr1[1],arr1[2]....

			方法二: 通过循环,配置下标
				for i:=0;i<len(arr);i++{
					arr[i]
				}

			方法三: 使用range
				range,词义"范围"
				不需要操作数组的下标,到达数组的末尾,自动结束for range循环,
					每次都获取数组中喜爱宝和对应的数值
	*/
	arr1 := [5]int{1, 2, 3, 4, 5}
	fmt.Println(arr1[0])
	fmt.Println(arr1[1])
	fmt.Println(arr1[2])
	fmt.Println(arr1[3])
	fmt.Println(arr1[4])

	fmt.Println("-------------------------")
	for indx, value := range arr1 {
		fmt.Printf("下标是: %d,数值是: %d\n", indx, value)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

如果只需要值并希望忽略索引,那么可以通过使用_ blank标识符替换索引来实现这一点.

for _, v := range a { //ignores index  
}
1
2
# 数组示例代码
package main

import "fmt"

func main() {
	/*
		数据类型:
			基本类型: 整型,浮点,布尔,字符串
			复合类型: array,slice,map,struct,pointer,function,channel....
		数组:
			1.概念: 存储一组相同数据类型的数据结构
					理解为容器,存储一组数据
			2.语法:
				var 数组名 [长度]  数据类型
				var 数组名 = [长度] 数据类型{元素1,元素2...}
				数组名 := [...]数据类型{元素....}
			3.通过下标访问
				下标,也叫索引: index
				数组名[index]
					赋值
					取值
				不能越界: [0,长度-1]

			4.长度和容量:
				len(array/map/slice/string),长度
				cap(),容量
	*/
	var num1 int
	num1 = 100

	num1 = 200
	fmt.Println(num1)

	//step1: 创建数组
	var arr1 [4]int
	arr1[0] = 1
	arr1[1] = 2
	arr1[2] = 3
	arr1[3] = 4
	fmt.Println(arr1[0])
	fmt.Println(arr1[2])
	//fmt.Println(arr1[4])	// invalid argument: array index 4 out of bounds [0:4]
	fmt.Println("数组的长度: ", len(arr1)) //容器中实际存储的数据量
	fmt.Println("数组的容量: ", cap(arr1)) //容器中能够存储的最大的数量
	//因为数组定长,长度和容量相同
	arr1[0] = 100
	fmt.Println(arr1[0])

	//数组的其他创建方式
	var a [4]int //同 var a= [4] int
	fmt.Println(a)

	var b = [4]int{1, 2, 3, 4}
	fmt.Println(b)

	var c = [5]int{1, 2, 4}
	fmt.Println(c)

	var d = [5]int{1: 1, 3: 2}
	fmt.Println(d)

	var e = [5]string{"rose", "王二狗", "ruby"}
	fmt.Println(e)

	f := [...]int{1, 2, 3, 4, 5}
	fmt.Println(f)
	fmt.Println(len(f))
	g := [...]int{1: 3, 6: 5}
	fmt.Println(g)
	fmt.Println(len(g))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
# 1.3 多维数组

Go语言支持多维数组,以下为常用的多维数组声明语法方式

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type
1
var threedim [5][10][4]int
1

三维数组

a = [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11}   /*  第三行索引为 2 */
}
1
2
3
4
5
int val = a[2][3]
1
# 1.4 数组是值类型
  • 数组是值类型
  • Go中的数组是值类型,而不是引用类型.这意味着当它们被分配给一个新变量时,将把原始数组的副本分配给新变量.如果对新变量进了更改,则不会在原始数组中反映.
package main

import "fmt"

func main() {  
    a := [...]string{"USA", "China", "India", "Germany", "France"}
    b := a // a copy of a is assigned to b
    b[0] = "Singapore"
    fmt.Println("a is ", a)
    fmt.Println("b is ", b) 
}
1
2
3
4
5
6
7
8
9
10
11

运行结果：

a is [USA China India Germany France]  
b is [Singapore China India Germany France]
1
2

数组的大小是类型的一部分.因此[5]int和[25]int是不同的类型.因此,数组不能被调整大小.不要担心这个限制,因为切片的存在是为了解决这个问题.

package main

func main() {  
    a := [3]int{5, 78, 8}
    var b [5]int
    b = a //not possible since [3]int and [5]int are distinct types
}
1
2
3
4
5
6
7
# 示例代码
package main

import "fmt"

func main() {
	/*
		数据类型:
			基本类型: int,float,string,bool....
			复合类型: array,slice,map,function,pointer,channel......

		数组的数据类型:
			[size]type

		值类型: 理解为存储的数据本身
			将数值传递给其他的变量,传递的是数据的副本(备份)
			int,float,string,bool,array
		引用类型: 理解为存储数据的内存地址
				slice,map....

	*/
	//1.数据类型
	num := 10
	fmt.Printf("%T\n", num)

	arr1 := [4]int{1, 2, 3, 4}
	arr2 := [3]float64{2.15, 3.18, 6.19}
	arr3 := [4]int{5, 6, 7, 8}
	arr4 := [2]string{"hello", "world"}
	fmt.Printf("%T\n", arr1) //[4]int
	fmt.Printf("%T\n", arr2) //[3]float64
	fmt.Printf("%T\n", arr3) //[4]int
	fmt.Printf("%T\n", arr4) //[2]string

	//2.赋值
	num2 := num //值传递
	fmt.Println(num, num2)
	num2 = 20
	fmt.Println(num, num2)

	arr5 := arr1 //值传递
	fmt.Println(arr1)
	fmt.Println(arr5)

	arr5[0] = 1
	fmt.Println(arr1)
	fmt.Println(arr5)

	a := 3
	b := 4
	fmt.Println(a == b)       // 比较a和b的数值是否相等
	fmt.Println(arr5 == arr1) //比较数字的对应下标位置的数值是否相等
	//fmt.Println(arr1 == arr2) //invalid operation: arr1 == arr2 (mismatched types [4]int and [3]float64)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

# 二、数组排序

package main

import "fmt"

func main() {

	/*
		数组的排序:
			让数组中的元素具有一定的顺序.
		arr :=[5]int{15,23,8,10,7}
			升序: [7,8,10,15,23]
			降序: [23,15,10,8,7]

		排序算法:
			冒泡排序,插入排序,选择排序,希尔排序,堆排序,快速排序......

		冒泡排序:(Bubble Sort)
			依次比较两个相似的元素,如果他们的排序(如从大到小)就把他们交换过来.
	*/
	arr := [5]int{15, 23, 8, 10, 7}
	////第一轮
	//for j := 0; j < 4; j++ {
	//	if arr[j] > arr[j+1] {
	//		arr[j], arr[j+1] = arr[j+1], arr[j]
	//	}
	//}
	//fmt.Println(arr)
	////第二轮
	//for j := 0; j < 3; j++ {
	//	if arr[j] > arr[j+1] {
	//		arr[j], arr[j+1] = arr[j+1], arr[j]
	//	}
	//}
	//fmt.Println(arr)

	for i := 1; i < len(arr); i++ {
		for j := 0; j < len(arr)-i; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
			}
		}
		//fmt.Println(arr)
	}
	fmt.Println(arr)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# 三、多维数组

Go语言支持多维数组,以下为常用的多维数组声明语法

var variable_name [SIZE1][SIZE2]...[SIZE3]
variable_type
1
2
var threedim [5][10][4]int
1
# 二维数组

image-20220824233501249

package main

import (
	"fmt"
)

func main() {
	/*
		一维数组: 存储的多个数据是数值本身
			a1 := [3]int{1,2,3}

		二维数组: 存储的是一维的一维
			a2 := [3][4]int{{},{},{}}

			该二维数组的长度,就是3
			存储的元素是一维数组,一维数组的元素是数值,每个一维数组长度为4

		多维数组....
	*/
	a2 := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
	fmt.Println(a2)
	fmt.Printf("二维数组的地址: %p\n", &a2)
	fmt.Printf("二维数组的长度: %d\n", len(a2))

	fmt.Printf("一维数组的长度: %d\n", len(a2[0]))
	fmt.Println(a2[0][3])
	fmt.Println(a2[1][2])
	fmt.Println(a2[2][1])

	//遍历二维数组
	for i := 0; i < len(a2); i++ {
		for j := 0; j < len(a2[i]); j++ {
			fmt.Print(a2[i][j], "\t")
		}
		fmt.Println()
	}
	fmt.Println("----------------------------------------")
	for _, arr := range a2 {
		for _, val := range arr {
			fmt.Print(val, "\t")
		}
		fmt.Println()
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# 三维数组
a =[3][4]int{
    {0,1,2,3},  /* 第一行索引为0 */
    {4,5,6,7},	/* 第二行索引为1 */
    {8,9,10,11} /* 第三行索引为2 */
}
1
2
3
4
5
int val = a[2][3]
1

# 四、数组排序

  • 算法是程序的灵魂,而排序算法则是一种最基本的算法.排序算法有许多种：冒泡排序,选择排序,快速排序和插入排序,以从小到大为例.
# 冒泡排序
  • 冒泡排序的原理是,对给定的数组进行多次遍历,每次均比较相邻的两个数,如果前一个比后一个大,则交换这两个数.经过第一次遍历之后,最大的数就在最右侧了;第二次遍历之后,第二大的数就在右数第二个位置了;以此类推.
//冒泡排序(排序10000个随机整数,用时约145ms)
func bubbleSort(nums []int) {
	for i := 0; i < len(nums); i++ {
		for j := 1; j < len(nums)-i; j++ {
			if nums[j] < nums[j-1] {
				//交换
				nums[j], nums[j-1] = nums[j-1], nums[j]
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
# 选择排序
  • 选择排序的原理是,对给定的数组进行多次遍历,每次均找出最大的一个值的索引.
//选择排序(排序10000个随机整数,用时约45ms)
func selectSort(nums []int) {
	length := len(nums)
	for i := 0; i < length; i++ {
		maxIndex := 0
		//寻找最大的一个数,保存索引值
		for j := 1; j < length-i; j++ {
			if nums[j] > nums[maxIndex] {
				maxIndex = j
			}
		}
		nums[length-i-1], nums[maxIndex] = nums[maxIndex], nums[length-i-1]
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 快速排序
  • 快速排序的原理是,首先找到一个数pivot把数组‘平均’分成两组,使其中一组的所有数字均大于另一组中的数字,此时pivot在数组中的位置就是它正确的位置.然后,对这两组数组再次进行这种操作.
//快速排序(排序10000个随机整数,用时约0.9ms)
func quickSort(nums []int) {
	recursionSort(nums, 0, len(nums)-1)
}

func recursionSort(nums []int, left int, right int) {
	if left < right {
		pivot := partition(nums, left, right)
		recursionSort(nums, left, pivot-1)
		recursionSort(nums, pivot+1, right)
	}
}

func partition(nums []int, left int, right int) int {
	for left < right {
		for left < right && nums[left] <= nums[right] {
			right--
		}
		if left < right {
			nums[left], nums[right] = nums[right], nums[left]
			left++
		}

		for left < right && nums[left] <= nums[right] {
			left++
		}
		if left < right {
			nums[left], nums[right] = nums[right], nums[left]
			right--
		}
	}

	return left
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 插入排序
  • 插入排序的原理是,从第二个数开始向右侧遍历,每次均把该位置的元素移动至左侧,放在放在一个正确的位置(比左侧大,比右侧小).
//插入排序(排序10000个整数,用时约30ms)
func insertSort(nums []int) {
	for i := 1; i < len(nums); i++ {
		if nums[i] < nums[i-1] {
			j := i - 1
			temp := nums[i]
			for j >= 0 && nums[j] > temp {
				nums[j+1] = nums[j]
				j--
			}
			nums[j+1] = temp
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

通过多次测试可以发现,快速排序是效率最高的.

上次更新: 2024/04/09, 16:48:42
数组
切片

← 切片→

最近更新
01
AWS NAT-NetWork-Firwalld配置(一)
04-09
02
AWS NAT-NetWork-Firwalld配置(二)
04-09
03
kubernetes部署minio对象存储
01-18
更多文章>
Theme by Vdoing | Copyright © 2019-2024 Bruce Tao Blog Space | MIT License