GO语言学习之路12

2022/02/03

package main

import "fmt"

func sortB(arr *[5]int) {
	fmt.Println("arr1 = ", &arr[0])
	fmt.Println("arr2 = ", &arr)
	fmt.Println("arr3 = ", (*arr)[0])

	temp := 0
	for i := 0; i < len(arr)-1; i++ {
		for j := 0; j < len(arr)-1-i; j++ {
			if (*arr)[j] < (*arr)[j+1] {
				temp = (*arr)[j]
				(*arr)[j] = (*arr)[j+1]
				(*arr)[j+1] = temp
			}
		}
	}
}

func main() {

	//1.内部排序
	//指将需要处理的所有数据都加载到内部存储器中进行排序。例如交换式排序，选择排序，插入排序等
	//交换式排序(很多) -例如-> 冒泡排序法 、 快速排序法
	//2.外部排序
	//数据量过大，无法全部加载到内存中，需要 借助外部存储进行排序。包括合并排序法和直接合并排序法

	//3.冒泡排序
	//排序 24， 69， 80， 57， 13 从小到大排序
	var arr [5]int = [5]int{24, 69, 80, 57, 13}

	sortB(&arr)
	fmt.Println("arr = ", arr)
}

package main

import "fmt"

/*
	常用的查找有两种：
	1.顺序查找
	2.二分查找(该数组有序)
*/

func binaryFind(arr *[6]int, leftIndex int, rightIndex int, findVal int) {
	/*
		//思路
		1.数组是有序数字且从小到大排序
		2.先找到中间的下标 middle = (leftIndex + rightIndex)/2
			然后让中间下标的值和要查找值findVal比较
		2.1 如果arr[middle] > findVal,就应该向leftIndex---(middle-1)查找
		2.2 如果arr[middle] < findVal,就应该向(middle+1)---rightIndex查找
		2.3 如果arr[middle] ==  findVal, 找到
		2.4 上面的2.1 2.2 2.3 的逻辑递归进行
		3.如果leftIndex > rightIndex //找不到
	*/
	middle := (leftIndex + rightIndex) / 2
	if leftIndex > rightIndex {
		fmt.Println("没有这个数字")
		return
	}
	if arr[middle] > findVal {
		//说明我们要查找的数应该在left -- middle-1 之间
		binaryFind(arr, leftIndex, middle-1, findVal)
	} else if arr[middle] < findVal {
		binaryFind(arr, middle+1, rightIndex, findVal)
	} else {
		//找到了
		fmt.Printf("找到了，下标为%v\n", middle)
	}
}

func main() {

	/*1.顺序查找
	有一个数列：白眉鹰王，青翼蝠王，金毛狮王，紫衫龙王
	输入一个名称 查找是否存在（顺序查找）
	1.定义字符串数组
	2.控制台接收一个名称，发现有提示
	*/
	nameArr := [4]string{"白眉鹰王", "青翼蝠王", "金毛狮王", "紫衫龙王"}
	name := ""
	fmt.Println("请输入需要查找的人名...")
	fmt.Scanln(&name)
	/*顺序查找第一种方式*/
	for i := 0; i < len(nameArr); i++ {
		if name == nameArr[i] {
			fmt.Printf("找到...%v:%v\n", i, nameArr[i])
			break
		} else if i == len(nameArr)-1 {
			fmt.Println("未找到...")
		}
	}
	/*顺序查找第二种方式(推荐)*/
	index := -1
	for i := 0; i < len(nameArr); i++ {
		if name == nameArr[i] {
			index = i //将找到的值对应的下标赋值给index
			break
		}
	}
	if index != -1 {
		fmt.Printf("找到...%v\n", index)
	} else {
		println("没有找到")
	}

	/*2.二分查找(该数组有序)(会使用到递归)
	[1, 8, 10, 89, 1000, 1234]
	请对一个有序数列进行二分查找，输入一个数组查看是否存在，并且求出下标
	没有提示 没有
	*/
	arr := [6]int{1, 8, 10, 89, 1000, 1234}
	binaryFind(&arr, 0, len(arr)-1, 89)
}

package main

import "fmt"

/*
	二维数组使用方式 先声明/定义，赋值
	1.语法 var 数组名[大小][大小]类型
	2.比如 var arr[2][3]int,再赋值
*/
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
	//默认初始值为0
	//赋初值
	arr[1][2] = 1
	arr[2][1] = 2
	arr[2][3] = 3
	fmt.Println(arr)
	fmt.Println(len(arr))

	//遍历二维数组，按照输出要求输出
	for i := 0; i < len(arr); i++ {
		fmt.Println(arr[i])
	}

	//输出每个元素，按照输出要求输出
	for i := 0; i < 4; i++ {
		for j := 0; j < 6; j++ {
			fmt.Printf("%d ", arr[i][j])
		}
		fmt.Println()
	}

	/*
		直接初始化
		var 数组名[大小][大小]类型 = [大小][大小]类型{{1, 2, 3}, {1, 2, 3}}
	*/
	var arr2 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println(arr2)
	var arr3 [2][3]int = [...][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println(arr3)
	var arr4 = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println(arr4)
	var arr5 = [...][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println(arr5)
	arr6 := [...][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println(arr6)

	/*
		二维数组的遍历
		1.双重for循环遍历
		2.for-range方式遍历
	*/
	//1.双重for循环遍历
	var arr7 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	for i := 0; i < len(arr7); i++ {
		for j := 0; j < len(arr7[i]); j++ {
			fmt.Printf("%v\t", arr7[i][j])
		}
		fmt.Println()
	}
	//2.for-range方式遍历
	for i, v := range arr7 {
		for j, v2 := range v {
			fmt.Printf("arr7[%v][%v] = %v\t", i, j, v2)
		}
		fmt.Println()
	}

	/*
		定义二维数组，用于保存三个班，每个班有五个成绩，
		求出每个班级平均分，以及所有班级平均分
	*/
	var stuArr [3][3]float64
	for i := 0; i < len(stuArr); i++ {
		sum := 0.0
		for j := 0; j < len(stuArr[i]); j++ {
			fmt.Printf("输入第%d班级第%d个学生的成绩", i+1, j+1)
			fmt.Scanln(&stuArr[i][j])
			sum += float64(stuArr[i][j])
		}
		fmt.Printf("%d班級的平均成绩是: %f", i+1, sum/float64(len(stuArr[i])))
	}
}