Ordenar burbuja
- Enfoque de la burbuja, numerosas entrevistas fueron investigados especie
- La idea básica de la burbuja para ordenar: hacia delante (desde el inicio de los próximos grandes elementos estándar) mediante el tratamiento de la secuencia de clasificación del código de clasificación elementos vez relativamente adyacentes, si se descubre que revertir el intercambio, los elementos más pequeños gradualmente de los códigos de clasificación hacia la parte trasera.
- Debido a que el proceso de clasificación, cada elemento constantemente cerca de su lugar, si no hay viaje por el cambio, una secuencia de instrucciones ordenadas, para establecer el indicador de optimización proceso de clasificación se determina si una bandera elementos de conmutación, con el fin de reducir la comparación innecesaria.
Burbuja análisis Ordenar detallado desglose
-
En primer lugar hay una matriz o rebanada
-
matriz definida:
//方式1 var array [n]int = [n]int{xx,xx,xx,...} //方式2 var array = [...]int{xx,xx,xx,...} //方式3 var array = make([]int,n) -
La formación de una matriz de digital externo entrante
var n int = 0 //统计元素个数 fmt.Println("请输入数组的元素个数： ") fmt.Scanf("%d", &n) var arr []int = make([]int, n) //定义一个空切片，len为n for i := 0; i < n; i++ { var n1 int fmt.Printf("请输入第%d个元素的值：", i+1) fmt.Scanf("%d", &n1) //每个值都是切片中的一个值 arr[i] = n1 //赋值完毕 }
-
-
Con el fin de reutilización de código, escribimos una función puede ser llamada, llamada BubbleSort ( ARR * [] int ), de notar que esta función de paso de parámetros debe utilizar referencias de pasada, modifique la principal función actual () variables de ARR, Por lo tanto, la necesidad de pasar a variables de tipo puntero .
func bubbleSort(arr *[]int) { temp := 0 //定义一个中间变量当做交换值传递媒介 for i := 0; i < len(*arr)-1; i++ { //外循环为确定最值的循环次数，所以为(数组元素-1)次 for j := 0; j < len(*arr)-1-i; j++ { //内循环次数为元素两两交换次数，由于每外循环一次，最元素就不用再次比较，所以可以减少一次比较，随着外循环次数上升而减少 if (*arr)[j] < (*arr)[j+1] { //元素j < 元素j+1 就交换，最后就是降序排列； temp = (*arr)[j] //元素j > 元素j+1就交换，那么就是升序排列。 (*arr)[j] = (*arr)[j+1] (*arr)[j+1] = temp } } } }
El código final es la siguiente:
package main
import "fmt"
func bubbleSort(arr *[]int) {
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() {
/*
构建一个切片
*/
var n int
fmt.Println("请输入切片的元素个数： ")
fmt.Scanf("%d", &n)
var arr []int = make([]int, n)
for i := 0; i < n; i++ {
var n1 int
fmt.Printf("请输入第%d个元素的值：", i+1)
fmt.Scanf("%d", &n1)
arr[i] = n1
}
fmt.Println(arr)
/*
开始冒泡排序算法，从小到大排列(升序)，从大到小排列(降序)
*/
bubbleSort(&arr)
fmt.Println(arr)
}
búsqueda secuencial
Búsqueda secuencial, por ejemplo:
La primera manera: de largo aliento
package main
import "fmt"
func main() {
var arr = [...]string{"主宰","美杜莎","幻影刺客","杨叫兽"}
var heroName string
fmt.Println("请输入你要查找的对象： ")
fmt.Scanf("%v",&heroName)
for i := 0 ; i < len(arr) ; i++ {
if heroName == arr[i] {
fmt.Printf("找到%v，下标为%v",heroName,i)
break
} else if i == len(arr) - 1 {
fmt.Printf("没有找到%v",heroName)
}
}
}
La segunda manera: encontrar pruebas de que está cambiando el subíndice (recomendado)
package main
import "fmt"
func main() {
var arr = [...]string{"主宰","美杜莎","幻影刺客","杨叫兽"}
var heroName string
fmt.Println("请输入你要查找的对象： ")
fmt.Scanf("%v",&heroName)
index := -1
for i := 0 ; i < len(arr) ; i++ {
if heroName == arr[i] {
index = i
break
}
}
if index != -1 {
fmt.Printf("找到%v，下标为%v",heroName,index)
} else {
fmt.Printf("没有找到%v",heroName)
}
}
La búsqueda binaria
-
Enfoque, numerosas entrevistas fueron investigados búsqueda binaria
-
La idea básica de la mirada binaria para: Primera matriz debe ser ordenada, lo cual es una condición necesaria para la búsqueda binaria.
-
Encuentra los dos principios: los dos la mayoría de encontrar una secuencia ordenada de valores y leftindex y rightindex / 2 para obtener una media del índice, mediante la comparación del valor objetivo y encontrar el valor medio, las siguientes extensiones para dar dos resultados:
-
Ascendente gama fin
arr [medio]> findVal: Resultados recursiva rango de búsqueda se convierte en Medio ~ leftindex - 1.
ARR [Medio] <findVal:. Rango de búsqueda Resultados recursiva se convierte + 1 ~ rightindex Medio
ARR [Medio] = findVal: exactamente, desechable para encontrar
leftindex == rightindex: comparar última
leftindex> rightindex: no encontrado -
Las matrices en orden descendente
arr [medio]> findVal: rango de búsqueda Resultados recursiva se convierte + 1 ~ rightindex medio.
ARR [Medio] <findVal:. Resultados recursiva rango de búsqueda se convierte en Medio ~ leftindex - 1
ARR [Medio] = findVal: exactamente , de una sola vez para encontrar
leftindex == rightindex: comparar última
leftindex> rightindex: no encontrado -
Comparar estos dos maneras también interpretación de búsqueda binaria para encontrar qué mucho más rápido que un secuencial, debido a la continua media dicotomía hecho encontrar rápidamente.
-
El código final es la siguiente:
package main
import "fmt"
func binaryFind(slice *[]int,leftin int,rightin int,findVal int) {
midin := (leftin + rightin) / 2
if leftin > rightin {
fmt.Println("查找的内容不存在")
return
}
if (*slice)[midin] > findVal {
binaryFind(slice,leftin,midin - 1,findVal)
}
if (*slice)[midin] < findVal {
binaryFind(slice,midin + 1,rightin,findVal)
}
if (*slice)[midin] == findVal {
fmt.Println("找到了，下标为",midin)
}
}
func main() {
/*
- **重点，众多面试都考察二分查找**
- 二分查找的基本思想：首先数组一定要有序，这是进行二分查找的必要条件。
- 二分查找的原理：求有序数列 两个最值leftindex&rightindex之和/2 得到一个middle的下标，通过middle下标的值和查找值比较，得到下面两种结果扩展：
- **数组从小到大排列**
arr[middle] > findVal ：递归查找结果范围变成 leftindex ~ middle - 1
arr[middle] < findVal： 递归查找结果范围变成 middle + 1 ~ rightindex
arr[middle] = findVal： 正好，一次性就找到了
leftindex == rightindex ： 最后一次比较
leftindex > rightindex ：找不到
- **数组从大到小排列**
arr[middle] > findVal ：递归查找结果范围变成 middle + 1 ~ rightindex
arr[middle] < findVal： 递归查找结果范围变成 leftindex ~ middle - 1
arr[middle] = findVal： 正好，一次性就找到了
leftindex == rightindex ： 最后一次比较
leftindex > rightindex ：找不到
- 上述两种比较方式也就诠释了为何二分查找比顺序查找快很多，因为不断二分二分迅速完成查找。
*/
var arr = [...]int{2,3,4,6,8}
slice := arr[:]
binaryFind(&slice,0,4,2)
}
