1.认识复杂度和简单排序算法

时间复杂度

        多项式最高项。

选择排序

        从第一个位置开始，选择剩余元素（包括当前位置）中最小的放在当前位置。

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]
			}
		}
	}
}

异或运算

性质

1. 0 ^ N = N,  N ^ N = 0
2. 交换律 a ^ b = b ^ a
3. 结合律 (a ^ b) ^ c = a ^ (b ^ c)
4. 顺序无关 

简单应用

        交换两数，不建议用。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
}