算法golang篇

1.slice反转，偏移

func reverse(s []int) {
    for i, j := 0, len(s) -1 ; i < j; i, j = i+1, j-1 {
        s[i], s[j] = s[j], s[i]
    }
}

一种将slice元素循环向左旋转n个元素的方法是三次调用reverse反转函数，第一次是反转开头 的n个元素，然后是反转剩下的元素，最后是反转整个slice的元素。（如果是向右循环旋转， 则将第三个函数调用移到第一个调用位置就可以了。）

a := [...]int{0, 1, 2, 3, 4, 5}
//Rotate a left    by two positions.
reverse(a[:2])
reverse(a[2:])
reverse(a[:])
//output [2 3 4 5 0 1]

排序：

type tree struct {
    value       int
    left, right *tree
}

func Sort(values []int) {
    var root *tree
    for _, val := range values {
        root = add(root, val)
    }
    appendValues(values[:0], root)
}

func appendValues(values []int, node *tree) []int {
    if node != nil {
        values = appendValues(values, node.left)
        values = append(values, node.value)
        values = appendValues(values, node.right)
    }
    return values
}

func add(node *tree, val int) *tree {
    if node == nil {
        node = new(tree)
        node.value = val
        return node
    }
    if node.value > val {
        node.left = add(node.left, val)
    } else {
        node.right = add(node.right, val)
    }
    return node
}

 斐波那契数列

func fib(x int) int {
    if x < 2 {
        return x
    }
    return fib(x-1) + fib(x-2)
}

func fib2(x int) int { //GP 20180309
    c, la := 1, 1
    for i := 3; i <= x; i++ {
        c, la = la, c
        c += la
    }
    return c
}

如果我们有一个指向结构体的指针 p，那么可以通过 (*p).X来访问其字段 X。不过这么写太啰嗦了，所以语言也允许我们使用隐式间接引用，直接写 p.X 就可以。

计算两个整数值的的最大公约数（GCD）（greatest common divisor的缩写，欧几里德的GCD是最早的非平凡算法）：

func gcd(x, y int) int {
    for y != 0 {
        x, y = y, x%y
    }
    return x
}