时间复杂度
多项式最高项。
选择排序
从第一个位置开始,选择剩余元素(包括当前位置)中最小的放在当前位置。
func SelectSort(array []int) {
size := len(array)
for i:= 0;i<size-1;i++{ //最后一位只有一个数不用排了
for j := i+1;j<size ;j++{ //之后的所有元素中选最小的
if array[i] > array[j]{
array[i], array[j] = array[j], array[i]
}
}
}
}
冒泡排序
进行数组长度-1轮,每轮从前往后对相邻两个元素作比较,更大的元素不断向后移动,每轮确定未排序序列中最后位置的元素。
func BubbleSort(array []int) {
size := len(array)
for i := size - 1; i > 0; i-- { //i标记每轮要排序好的元素的位置,实际无用只是方便理解
for j := 0; j < i; j++ { //从0开始往后,两个相邻的元素不断比较把更大者推到最后
if array[j] > array[j+1] {
array[j+1], array[j] = array[j], array[j+1]
}
}
}
}
异或运算
性质
- 0 ^ N = N, N ^ N = 0
- 交换律 a ^ b = b ^ a
- 结合律 (a ^ b) ^ c = a ^ (b ^ c)
- 顺序无关
简单应用
交换两数,不建议用。golang有多重赋值,不过多重赋值底层也是swap会开辟空间。
a = a ^ b
b = b ^ a
a = a ^ b
题一:一个序列,里面只有一种数出现奇数次,其余均出现偶数次,求这个出现奇数次的数。
package main
import "fmt"
func main() {
tmp := 0
var array = []int{1, 5, 1, 5, 6}
for _, i := range array {
temp = i ^ temp //全异或完,相同清除,不同留下
}
fmt.Println(temp)
}
题二 :一个序列,只有两种数出现了奇数次,其余均出现偶数次,求这两个出现奇数次的数
package main
import "fmt"
func main() {
a := 0
b := 0
var array = []int{1, 5, 1, 5, 6, 7}
for _, i := range array {
a = i ^ a
}
for _, i := range array {
if i&a == 0 {
b = i ^ b
}
}
a = a ^ b
fmt.Println(a, b)
}
用a^b的位将序列分为两个(如果a^b的二进制表示只有一位的值为1,其余为0)或三个部分,一个部分是这些位上为1的,另一个部分是这些位上为0的,以及剩余不重要的部分。因为这一步的核心是过滤数据把a和b分开(因为a^b就是a和b在位数上差异的地方,所以可以将a和b分开),从而可以像求解题一一样得到这两个数。故而异或其中一个部分得到所求两数之一。现假如得到a,则有了a和a^b的值,则有b = a ^ a ^ b。
插入排序
冒泡。其实我感觉和起牌不太一样,起牌是先找到位置再放进去。这个是拿到新值后往前冒泡。
func InsertionSort(array []int) {
size := len(array)
for i := 1; i < size; i++ { //从第二个数开始,指向要加入到已排序序列的数
for j := i; j > 0; j-- { //和前一个数依次比较
if array[j] < array[j-1] {
array[j-1], array[j] = array[j], array[j-1]
}
}
}
}
二分查找
题一:在一个有序数组中,找某个数是否存在
func BinarySearch(array []int, num, left, right int) int {
if left > right {
return -1//找不到退出
}
mid := left + (right - left) >> 1
if array[mid] == num {
return mid
} else if array[mid] < num {
return BinarySearch(array, num, mid+1, right)
} else {
return BinarySearch(array, num, left, mid-1)
}
}
>>1计算更快
题二:在一个有序数组中,找>=某个数最左侧的位置
使用递归实现
func BinarySearch(array []int, num, left, right int) int {
var flag = 0
mid := left + (right - left) /2
if array[mid] < num {
return BinarySearch(array, num, mid+1, right)
} else {
flag = mid
if left >= right {
return flag
}
return BinarySearch(array, num, left, mid-1)
}
return flag
}
这里>>1和/2是有区别的,如果要找的元素就是0位置的元素,那么在计算mid时,如果是右移则计算结果是-1,而/2会是0。所以使用右移会产生错误。
使用循环实现
func BinarySearch(array []int, num int) int {
left, right := 0, len(array)
index := -1
for right >= left {
mid := left + ((right - left) >> 1)
if num > array[mid] {
left = mid + 1
} else {
index = mid
right = mid - 1
}
}
return index
}
这个感觉循环比递归好实现多了,当然也是我太菜了。
题三:局部最小值问题
零点中值定理
func getLocalMinInArray(array []int) int {
var size = len(array)
if array == nil || size == 0 {
return -1
}
if array[0] < array[1] {
return 0
}
if array[size-1] < array[size-2] {
return size - 1
}
left, right := 1, size-2
var mid int
for left <= right {
mid = left + ((right - left) >> 1)
if array[mid] >= array[mid-1] {
right = mid - 1
} else {
if array[mid] < array[mid+1] {
return mid
} else {
left = mid + 1
}
}
}
return mid
}