Go 基本语法（方便查询，不断完善中。。。）

一、tips

1、main函数只有在main包中才可以跑起来

2、package名字是随便起的，不一定非要有个实体的文件夹

3、一个较为复杂的傻瓜for循环 ：）

for i, j := 0, len(stringValue)-1; i <= j; i, j = i+1, j-1 {
   if stringValue[i] != stringValue[j] {
      return false
   }
}

4、go中实现while

i:=0
for {
    do something
    if i <= 10 {
        break;
    }
}

等同于如下：

int i = 0;
while(i<10){// notice there is only <
    do something
}

5、注意指针类型和普通类型

https://leetcode.com/problems/sum-of-left-leaves/submissions/

错误的做法：

func sumOfLeftLeaves(root *TreeNode) int {
	sum := 0
	dfSearch(root, sum, false)
	return sum
}

//到leaf的时候判断是不是left leaf。用一个boolean function来记录搜索的是左枝还是右枝。
func dfSearch(root *TreeNode, sum int, left bool) {
	if root == nil {
		return
	}
	if root.Left == nil && root.Right == nil {
		if left {
			sum += root.Val
		}
	}
	dfSearch(root.Left, sum, true)
	dfSearch(root.Right, sum,false)
}

正确的做法：

func sumOfLeftLeaves(root *TreeNode) int {
	sum := 0
	dfSearch(root, &sum, false)
	return sum
}

//到leaf的时候判断是不是left leaf。用一个boolean function来记录搜索的是左枝还是右枝。
func dfSearch(root *TreeNode, sum *int, left bool) {
	if root == nil {
		return
	}
	if root.Left == nil && root.Right == nil {
		if left {
			*sum += root.Val
		}
	}
	dfSearch(root.Left, sum, true)
	dfSearch(root.Right, sum,false)
}

6、int float转换

int(1.1)

float64(1)

7、go中的INT_MAX与INT_MIN

无符号整型uint
其最小值是0，其二进制表示的所有位都为0，

const UINT_MIN uint = 0

其最大值的二进制表示的所有位都为1，那么，

const UINT_MAX = ^uint(0)

有符号整型int
根据补码，其最大值二进制表示，首位0，其余1，那么，

const INT_MAX = int(^uint(0) >> 1)

根据补码，其最小值二进制表示，首位1，其余0，那么，

const INT_MIN = ^INT_MAX
 

二、struct

1、结构体初始化

type Rect struct {

    x, y float64

    width, height float64

}

rect1 := new (Rect)

rect2 := &Rect{}

rect3 := &Rect{0, 0, 100, 300}

rect1 := &Rect{width=100, height =300}

2、定义结构体方法

type ListNode struct {
   Val  int
   Next *ListNode
}

//自定义打印链表方法
func (temp *ListNode) myPrint() {
   for temp != nil {
      fmt.Print(strconv.Itoa(temp.Val) + "->")
      temp = temp.Next
   }
}

调用方法：

node1.myPrint()

3、leetcode 705. Design HashSet

package main

type MyHashSet struct {
	mySet []bool
}

/** Initialize your data structure here. */
func Constructor() MyHashSet {
	mySet := make([]bool, 1000001)
	result := MyHashSet{
		mySet: mySet,
	}
	return result
}

func (this *MyHashSet) Add(key int) {
	this.mySet[key] = true

}

func (this *MyHashSet) Remove(key int) {
	this.mySet[key] = false

}

/** Returns true if this set contains the specified element */
func (this *MyHashSet) Contains(key int) bool {
	return this.mySet[key]

}

三、字符串

1、String int相互转换

string转成int： 
int, err := strconv.Atoi(string)
string转成int64： 
int64, err := strconv.ParseInt(string, 10, 64)
int转成string： 
string := strconv.Itoa(int)

int32 to string:

strconv.Itoa(int(value))

注意：ascii码转换

s := strconv.Itoa(97) // s == "97"

s := string(97) // s == "a"

2、求字符串长度

len(stringValue)

3、去掉string的空格

strings.TrimSpace

4、split

strings.Split(

四、数组

1、切片数组定义&初始化：

result := make([]int, 2) //里面有2个元素，为0

nums := []int{1,3,5,6}

2、切片数组填充元素：

result[0] = index

n、常见错误

3、二维数组定义&初始化

var e [][]float64
for i := 0; i < n; i++ {
   tmp := make([]float64, n)
   e = append(e, tmp)
}

 

五、map

1、map定义：

var tempMap map[int] int

2、map定义&初始化：

var tempMap = make(map[int]int)

3、map填充元素：

tempMap[index] = value

3、map查找元素：

value, ok := tempMap[index]
if ok {

}

n、常见错误

var tempMap map[int] int
for index, value := range nums {
   tempMap[value] = index
}

但是这样执行会报错：panic: assignment to entry in nil map

原因是：map必须初始化后才能使用，要改成如下

tempMap := make(map[int]int)
for index, value := range nums {
   tempMap[value] = index
}

六、高级数据结构

用双向链表实现stack

https://blog.csdn.net/preyta/article/details/80056069

type Stack struct {
	list *list.List
}

func NewStack() *Stack {
	list := list.New()
	return &Stack{list}
}

func (stack *Stack) Push(value interface{}) {
	stack.list.PushBack(value)
}

func (stack *Stack) Pop() interface{} {
	e := stack.list.Back()
	if e != nil {
		stack.list.Remove(e)
		return e.Value
	}
	return nil
}

func (stack *Stack) Peak() interface{} {
	e := stack.list.Back()
	if e != nil {
		return e.Value
	}

	return nil
}

func (stack *Stack) Len() int {
	return stack.list.Len()
}

func (stack *Stack) Empty() bool {
	return stack.list.Len() == 0
}

list包下的List是双向链表，方法如下

func (e *Element) Next() *Element  //返回该元素的下一个元素，如果没有下一个元素则返回nil
func (e *Element) Prev() *Element//返回该元素的前一个元素，如果没有前一个元素则返回nil
func New() *List //返回一个初始化的list
func (l *List) Back() *Element //获取list l的最后一个元素
func (l *List) Front() *Element //获取list l的第一个元素
func (l *List) Init() *List  //list l初始化或者清除list l
func (l *List) InsertAfter(v interface{}, mark *Element) *Element  //在list l中元素mark之后插入一个值为v的元素，并返回该元素，如果mark不是list中元素，则list不改变。
func (l *List) InsertBefore(v interface{}, mark *Element) *Element//在list l中元素mark之前插入一个值为v的元素，并返回该元素，如果mark不是list中元素，则list不改变。
func (l *List) Len() int //获取list l的长度
func (l *List) MoveAfter(e, mark *Element)  //将元素e移动到元素mark之后，如果元素e或者mark不属于list l，或者e==mark，则list l不改变。
func (l *List) MoveBefore(e, mark *Element)//将元素e移动到元素mark之前，如果元素e或者mark不属于list l，或者e==mark，则list l不改变。
func (l *List) MoveToBack(e *Element)//将元素e移动到list l的末尾，如果e不属于list l，则list不改变。
func (l *List) MoveToFront(e *Element)//将元素e移动到list l的首部，如果e不属于list l，则list不改变。
func (l *List) PushBack(v interface{}) *Element//在list l的末尾插入值为v的元素，并返回该元素。
func (l *List) PushBackList(other *List)//在list l的尾部插入另外一个list，其中l和other可以相等。
func (l *List) PushFront(v interface{}) *Element//在list l的首部插入值为v的元素，并返回该元素。
func (l *List) PushFrontList(other *List)//在list l的首部插入另外一个list，其中l和other可以相等。
func (l *List) Remove(e *Element) interface{}//如果元素e属于list l，将其从list中删除，并返回元素e的值。
 

List遍历，获取元素的value并判断类型，因为value是interface{}类型的

for e := list.Front(); e != nil; e = e.Next() {
		//fmt.Println("type:", reflect.TypeOf(e.Value))
		switch value := e.Value.(type) {
		case int32:
            xxxx
		}
	}

七、go的字符类型

声明字符类型

var ch byte

八、类型判断

1、用反射获取类型

fmt.Println("type:", reflect.TypeOf(x))

2、用x.(type)判断类型

import (
	"fmt"
)

type Element interface {}

func main() {
	var e Element = 100
	switch value := e.(type) {
	case int:
		fmt.Println("int", value)
	case string:
		fmt.Println("string", value)
	default:
		fmt.Println("unknown", value)
	}
}