バブルソート
- フォーカス、数多くのインタビューを調査したバブルソート
- 仕分けコードからの交換を逆転することが分かった場合、前方（次の大きな標準的な要素の先頭から）比較的隣接する要素一度ソートコードからソート順序を処理することにより、より小さな要素徐々に：バブルソートの基本的な考え方後方に。
- 不要な比較を低減するようにソート処理するので、常に近いそれらの位置に各要素は、交換ダウンない旅行場合、ソート処理の最適化フラグを設定する順序付き命令のシーケンスは、フラグはスイッチング素子か否かが判断されます。
バブルソート詳細な内訳分析
-
まずそこにある配列やスライスは
-
定義された配列：
//方式1 var array [n]int = [n]int{xx,xx,xx,...} //方式2 var array = [...]int{xx,xx,xx,...} //方式3 var array = make([]int,n) -
入ってくる外部デジタルのアレイを形成します
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 //赋值完毕 }
-
-
コードの再利用するために、我々は関数を記述バブルソート（名前は、呼び出すことができARR * [] INT、この関数のパラメータを渡すには渡して参照を使用しなければならないことに留意すべき、主現在の関数を変更する（）ARR変数）したがって、ポインタ型の変数を渡す必要。
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 } } } }
次のように最終的なコードです。
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)
}
シーケンシャル検索
例えばシーケンシャル検索：
最初の方法：長期ったらしいです
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)
}
}
}
第二の方法：その証拠を見つけるためには、添字を変えている（推奨）
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)
}
}
バイナリ検索
-
フォーカス、数多くのインタビューでは、バイナリ検索を調査しました
-
以下のためのバイナリ見ての基本的な考え方：最初の配列は、バイナリサーチのために必要な条件である、注文する必要があります。
-
二つの結果を与えるために、2つは、ほとんどの目標値を比較することで、インデックスの真ん中を取得した値とleftindex＆rightindex / 2の順序付けられたシーケンスを見つけて、中間値を見つけ、次の拡張子：2つの原則を探します：
-
昇順アレイ
。ARRは、[ミドル]> findVal：結果再帰検索範囲が中東〜leftindexなり- 1つの
ARR [中] <findValは：。結果再帰検索範囲となり+ 1〜rightindex中東
ARR [中] = findVal：正確には、見つけるのは使い捨て
最後の比較：leftindex == rightindex
leftindex> rightindex：見つかりません。 -
注文降順で配列
。ARRを[ミドル]> findVal：結果再帰探索範囲が+になり1〜rightindex中東
ARR [中] <findVal：結果再帰検索範囲は中東〜はleftindexなり- 1つの。
ARR [中] = findVal：正確に、見つけるためのワンタイム
leftindex == rightindex：最後は比較
leftindex> rightindex：見つかりません。 -
なぜなら見つける迅速に行う継続的な二分法の半分の、はるかに高速シーケンシャルよりを見つけるためにも、なぜバイナリ検索の解釈をこれら二つの方法を比較してください。
-
次のように最終的なコードです。
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)
}
