[go学习笔记.第八章.排序和查找] 3.二维数组练习

package main

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

func func1() {
	//1.随机生成10个整数,(1~100)保存到数组,并倒序打印以及求平均值,最大值,最小值的下标,
	//并查找里面是否有55
	//1.1声明一个数组
	var arr1 [10]int
	//1.2 循环随机生成10个整数
	lenArr1 := len(arr1)
	for i := 0; i < lenArr1; i++ {
		//为了生成随机数,需要通过rand生成一个随机数种子
		rand.Seed(time.Now().UnixNano())
		//生成1~100的整数
		arr1[i] = rand.Intn(100) + 1
		time.Sleep(1)
	}
	fmt.Println("随机生成的数组为:", arr1)
	//求平均值,最大值,最小值的下标,并查找里面是否有55
	//假设下标为0的是最大值
	maxValue := arr1[0]
	maxIndex := 0
	//假设下标为0的是最小值
	minValue := arr1[0]
	minIndex := 0
	sum := 0
	//顺序查找是否存在55
	index := -1
	for  i := 0; i < lenArr1; i++ {
		if arr1[i] > maxValue {
			maxValue = arr1[i]
			maxIndex = i
		}
		if arr1[i] < minValue {
			minValue = arr1[i]
			minIndex = i
		}
		if 55 == arr1[i] {
			index = i
			break
		}
		sum += arr1[i]
	}
	fmt.Printf("平均值:%v,最大值下标:%v, 最小值下标:%v\n", float64(sum/lenArr1), maxIndex, minIndex)
	if index != -1 {
		fmt.Printf("找到了, 下标为:%v\n", index)
	 } else {
	 	fmt.Printf("没找到\n")
	 }
	//倒序打印
	var temp int
	for j := 0; j < lenArr1; j++ {
		for i := 0; i < lenArr1 - j - 1; i++ {
			if arr1[i] < arr1[i + 1] {
				temp = arr1[i]
				arr1[i] = arr1[i + 1]
				arr1[i + 1] = temp
			}
		}
	}
	fmt.Println("倒序打印:", arr1)
}

func func2(n int) {
	//2.已知一个排好(升序)的数组,要求插入一个元素,最后打印该数组,顺序依然是升序
	arr2 := [5]int{3, 4, 14, 15, 18}
	// 声明一个切片
	slice := arr2[:]
	// 把参数n放入slice中
	slice = append(slice, n)
	//排序slice
	var temp int
	for j := 0; j < len(slice); j++ {
		for i := 0; i < len(slice) - j - 1; i++ {
			if slice[i] < slice[i + 1] {
				temp = slice[i]
				slice[i] = slice[i + 1]
				slice[i + 1] = temp
			}
		}
	}

	fmt.Println(slice)
}

func func3()  {
	//3.定义一个3行4列的二维数组,逐个从键盘输入,编写程序将四周的数清0
	var arr [3][4]int
	lenArr3 := len(arr)
	lenArr4 := len(arr[0])
	for i := 0; i < lenArr3; i++ {
		for j := 0; j < lenArr4; j++ {
			fmt.Printf("请输入第%v行,第%v列数:\n", i + 1, j + 1)
			fmt.Scanln(&arr[i][j])
		}
		fmt.Println()
	}
	fmt.Println("数组:", arr)
	//将四周的数清0
	for i := 0; i < lenArr3; i++ {
		for j := 0; j < lenArr4; j++ {
			if (i == 0 && j >= 0) || (i >= 0 && j ==0) || (i == lenArr3 -1) || (j == lenArr4 -1) {
				arr[i][j] = 0
			} 
		}
		fmt.Println()
	}
	fmt.Println("四周的数清0,数组:", arr)
}	

func func4()  {
	//4.定义一个4行4列的二维数组,逐个从键盘输入值,然后将第1行和第4行的元素进行交换,将第2行和第3行的数据进行交换
	var arr4 [4][4]int
	for i := 0; i < 4; i++ {
		for j := 0; j < 4; j++ {
			fmt.Printf("请输入第%v行第%v列的数据:", i + 1, j + 1)
			fmt.Scanln(&arr4[i][j])
		}
	}
	fmt.Println("交换前的数组:")
	for i := 0; i < 4; i++ {
		for j := 0; j < 4; j++ {
			fmt.Printf("%v \t", arr4[i][j])
		}
		fmt.Println()
	}
	fmt.Println("交换后的数组:")

	var arr4_change [4][4]int
	for i := 0; i < 4; i++ {
		for j := 0; j < 4; j++ {
			arr4_change[3 - i][j] = arr4[i][j]
		}
	}
	for i := 0; i < 4; i++ {
		for j := 0; j < 4; j++ {
			fmt.Printf("%v \t", arr4_change[i][j])
		}
		fmt.Println()
	}
}

func func5()  {
	//5.试保存	1 3 5 7 9五个奇数,并倒序打印
	var arr5 [5]int 
	lenarr5 := len(arr5)
	i := 0
	for {
		if i >= lenarr5 {
			break
		}
		fmt.Printf("请输入第%v个奇数:\t", i + 1)
		fmt.Scanln(&arr5[i])
		if arr5[i] % 2 == 0 {
			fmt.Println("你输入的不是奇数,请重新输入")
			continue
		}
		i++
	}
	var temp int
	for i := 0; i < lenarr5; i++ {
		if i > lenarr5 / 2 {
			break
		}
		temp = arr5[i]
		arr5[i] = arr5[lenarr5 - i - 1]
		arr5[lenarr5 - i -1] = temp
	}
	fmt.Printf("倒序打印:%v", arr5)
}

func func6()  {
	//6.试写出实现查找的核心代码,
	//eg:已知数组arr [10]string里面保存了十个元素,现要查找"AA"在其中是否存在,
	//打印提示,如果有多个"AA",也要找到对应的下标
	arr6 := [10]string{"AA","asdfasd","你好","32","asfdAsd","AA","#sdfa","fsd","1223","fsdf43"}
	lenArr6 := len(arr6)
	//顺序查找
	i := 0
	flag := false
	for {
		if i >= lenArr6 {
			break
		}
		if "AA" == arr6[i] {
			flag = true
			fmt.Printf("存在AA,下标为%v\t", i)
		}
		i++
	}

	if !flag {
		fmt.Println("不存在AA")
	}
}

func func7()  {
	//7.随机生成10个整数(1~100),使用冒泡排序进行排序,
	//然后使用二分查找是否有90这个数,并显示下标,如果没有,则提示"找不到该数"
	var arr [10]int
	lenArr := len(arr)
	i := 0
	for {
		if i >= lenArr {
			break
		}
		//为了生成随机数,需要通过rand生成一个随机数种子
		rand.Seed(time.Now().UnixNano())
		arr[i] = rand.Intn(100) + 1
		time.Sleep(1)
		i++
	}
	fmt.Println("冒泡前数组:", arr)
	bubleSort(&arr)
	BinaryFind(&arr, 0, lenArr - 1, 90)
}

//冒泡排序算法
func bubleSort(arr *[10]int) {
	temp := 0
	lenArr := len(*arr)
	for j := 0; j < lenArr - 1; j++ {
		for i := 0; i < lenArr - j -1; i++ {
			if (*arr)[i] > (*arr)[i + 1] {
				temp = (*arr)[i]
				(*arr)[i] = (*arr)[i + 1]
				(*arr)[i + 1] = temp
			}
		}
	}
	fmt.Println("冒泡排序后= ", (*arr))
}

//二分查找
func BinaryFind(arr *[10]int, leftIndex int, rightIndex int, findVal int) {
	if leftIndex > rightIndex {
		fmt.Println("没有找到")
		return 
	}
	//先找中间下标
	middleIndex := (leftIndex + rightIndex) / 2
	if (*arr)[middleIndex] > findVal {
		//说明要查找的值在leftIndex ~ middelIndex - 1之间
		BinaryFind(arr, leftIndex, middleIndex - 1 , findVal)  
	} else if (*arr)[middleIndex] < findVal {
			//说明要查找的值在middelIndex + 1 ~ rightIndex之间
			BinaryFind(arr, middleIndex + 1, rightIndex , findVal)  
	} else {
		fmt.Println("找到了,下标为:", middleIndex)
	}
}

func func8(arr *[5]int)  {
	//8.编写一个函数,可以接收一个数组,该数组有5个数,找出最大数和最小数和对应数组的下标
	lenArr := len(*arr)
	//假设第一个元素是最大值
	maxValue := arr[0]
	maxIndex := 0
	//假设第一个元素是最小值
	minValue := arr[0]
	minIndex := 0
	for i := 0; i < lenArr; i++ {
		if maxValue < (*arr)[i] {
			maxValue = (*arr)[i]
			maxIndex = i
		} 
		if minValue > (*arr)[i] {
			minValue = (*arr)[i]
			minIndex = i
		}
	}
	fmt.Printf("最大值为:%v,下标为:%v \n, 最小值为:%v, 下标为:%v\t", maxValue, maxIndex, minValue, minIndex)
}

func func9() {	
	//9.定义一个数组,并给出8个整数,求该数组中大于平均值的个数,和小于平均数的个数
	arr := [8]int{12, 34, 56, 33, 10, 90, 27, 56}
	lenArr := len(arr)
	//大于平均数的个数
	gtNum := 0
	//小于平均数的个数
	ltNum := 0
	//平均数
	var avg float64
	//和
	var sum int
	//循环求和
	for i := 0; i < lenArr; i++ {
		sum += arr[i]
	}
	//循环获取大于平均数的个数,小于平均数的个数
	avg = float64(sum / lenArr)
	for i := 0; i < lenArr; i++ {
		if float64(arr[i]) > avg {
			gtNum ++
		}
		if float64(arr[i]) < avg {
			ltNum ++
		}
	}
	fmt.Printf("平均数:%v,大于平均数的个数:%v,小于平均数的个数:%v\t", avg, gtNum, ltNum)
}

func main()  {
	//1.随机生成10个整数,(1~100)保存到数组,并倒序打印以及求平均值,最大值,最小值的下标,并查找里面是否有55
	// func1()
	//2.已知一个排好(升序)的数组,要求插入一个元素,最后打印该数组,顺序依然是升序
 	// func2(5)
	//3.定义一个3行4列的二维数组,逐个从键盘输入,编写程序将四周的数清0
	// func3()
	//4.定义一个4行4列的二维数组,逐个从键盘输入值,然后将第1行和第4行的元素进行交换,将第2行和第3行的数据进行交换
	// func4()
	//5.试保存	1 3 5 7 9五个奇数,并倒序打印
	// func5()
	//6.试写出实现查找的核心代码,
	//eg:已知数组arr [10]string里面保存了十个元素,现要查找"AA"在其中是否存在,
	//打印提示,如果有多个"AA",也要找到对应的下标
	// func6()
	//7.随机生成10个整数(1~100),使用冒泡排序进行排序,
	//然后使用二分查找是否有90这个数,并显示下标,如果没有,则提示"找不到该数"
	// func7()
	//8.编写一个函数,可以接收一个数组,该数组有5个数,找出最大数和最小数和对应数组的下标
	// arr8 := [5]int{37,12,78,6,50}
	// func8(&arr8)
	//9.定义一个数组,并给出8个整数,求该数组中大于平均值的个数,和小于平均数的个数
	// func9()
}

[上一节][go学习笔记.第八章.排序和查找] 2.二维数组

[下一节][go学习笔记.第九章.map] 1.map的介绍,声明,使用方式,crud操作以及遍历