使用golang 实现部分算法：二分查找，顺序查找，冒泡排序，斐波拉契数列，断言....

二分查找

//有序的二分查找,返回索引
func SeekBinary(seekArr []int, leftIndex int, rightIndex int, seekVal int)(int){
	retVal := -1

	if(leftIndex > rightIndex){
		return retVal
	}
	midIndex := (leftIndex + rightIndex) / 2

	if seekArr[midIndex] > seekVal {
		retVal = SeekBinary(seekArr, leftIndex, midIndex - 1, seekVal)
	}else if seekArr[midIndex] < seekVal {
		retVal = SeekBinary(seekArr, midIndex + 1, rightIndex, seekVal)
	}else{
		retVal = midIndex
	}

	return retVal

}

顺序查找

//顺序查找
func seekStr(seekArr [] string, seekVal string)(int){
	retVal := -1;

	for index, val := range(seekArr){
		if(val == seekVal){
			retVal = index
			break;
		}
		if(len(seekArr) <= index + 1){
			retVal = -1
		}
	}

	return retVal
}

冒泡排序

//冒泡排序【以下是从小到大】，如果要从大到小只需将 bubArr[j] > bubArr[j+1] 改为 bubArr[j] < bubArr[j+1]
func bubbing(bubArr [] uint64)([] uint64){
	len := len(bubArr)

	for i := 0; i < len-1; i++{
		for j := 0; j < len - 1- i; j++{
			if bubArr[j] > bubArr[j+1]{
				temp := bubArr[j+1]
				bubArr[j+1] = bubArr[j]
				bubArr[j] = temp 
			}
		}
		
	}
	return bubArr
}

斐波拉契数列

//以下方法是输入n个斐波拉契数 使用切片处理
func fbn(n int)([] uint64){
	fbArr := make([] uint64, n)

	if(n <= 0){
		return fbArr;
	}

	if(n <= 2){
		for i := 1; i <= n; i++{
			fbArr[i-1] = 1
		}
	}

	if(n > 2){
		fbArr[0] = 1
		fbArr[1] = 1

		for i:= 2; i < n; i++{
			fbArr[i] = fbArr[i-1] + fbArr[i-2]
		}
	}

	return fbArr;

}

使用断言 判断字段的类型

func JudgeType(items ... interface{}){
	for index, val := range items{
		switch val.(type){
			case bool:
				fmt.Printf("第%v个参数是bool类型，值为%v\n", index, val)
			case int, int32, uint64:
				fmt.Printf("第%v个参数是int类型，值为%v\n", index, val)
			case float, float32, float64:
				fmt.Printf("第%v个参数为float类型，值为%v\n", index, val)
			case string:
				fmt.Printf("第%v个参数为string类型，值为%v\n", index, val)
			...
		}
	}
}