代理服务器、虚拟专用网络、网关

注意点⚠️

fmt.Scan(&n)

	var n int
	var s string
	num, _ := fmt.Scan(&n, &s)
	if num == 0 {
		fmt.Println("没有元素")
	}else {
		fmt.Println("输入元素：",n,s)
	}

var{}niln,m = m,nmath

绝对值：func Abs(x float64) float64
次方值：func Pow(x, y float64) float64
最大值：func Max(x, y float64) float64
最小值：func Min(x, y float64) float64

向下取整：func Floor(x float64) float64
向上取整：func Ceil(x float64) float64

最大整数：MaxInt64
最小整数：MinInt64

mid := (right + left) >> 1,

	res := []int{3}

	res := []int{
		3,
	}

• 不要只使用基本数据类型啊！！！
  使用工具结构体实现高效读写：

	/ 高效读写byte流
	buf := bytes.Buffer{}
	buf.WriteByte('1')
	buf.WriteString("2")
	buf.Bytes()

	/ 高效读写字符串
	str := strings.Builder{}
	str.WriteByte('1')
	str.WriteString("2")
	str.String()

var

	var m map[int]int
	m[0] = 0

10e3101021<<31n&1n&1[]byte[]rune

a := []byte{}
b := string(a)
c := []rune(b)

• 数组，字符串是基本数据类型啊 赋值会拷贝
• 当出现点与点有向关联：画图 ⇒ 拓扑排序 【map存节点+入度】

func canFinish(numCourses int, prerequisites [][]int) bool {
    / topo[节点]入度
    topo := make(map[int]int,numCourses)
    。。。
    / 入度为0的节点存入stack
    stack := []int{}
    for i:=0;i<numCourses;i++ {
        if topo[i] == 0 {
            stack = append(stack,i)
        }
    }
    count := 0 / 也可以是[]res 返回拓扑过程
    for len(stack) > 0 {
        // 取出入度为0的节点
        zeroIndegree := stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        count++
        // 将0度节点所指向的节点的入度减1
        for _,v := range prerequisites {
            if v[1] == zeroIndegree {
                topo[v[0]]--
                / 注意 ：直接在这里再获取入度为0的点
                if topo[v[0]] == 0 {
                    stack = append(stack,v[0])
                }
            }
        }
    }
    return count == numCourses
}

一、链表

fast.Next

for fast.Next != nil {
     fast = fast.Next.Next
     if fast == nil {
         break
     }
     slow = slow.Next
 }

二、数组

排序

• 默认递增

import "sort"

/ int切片
func Ints(a []int)
/ float64切片
func Float64s(a []float64)
/ string切片
func Strings(a []string)

<>

    sss := [][]int{}
    
    / 根据二维数组第一个元素排序
    / 注意⚠️：i、j是下标
	sort.Slice(sss, func(i, j int) bool {
		return sss[i][0] < sss[j][0]
	})
	
	/ 稳定排序
	sort.SliceStable(...,...)

copy(dst, src []Type) intmin(len(dst),len(src))

	dst := make([]int,len(src))
	copy(dst,src)

• 前缀和：将遍历累加和存放到map中

三、二叉树

• 按层遍历
• 递归YYDS：只思考第一步和第二步的关系 再加个递归终止条件就👌！！！

1. 手动遍历二叉树：

记住：

    for root != nil || len(stack) > 0 {
		for root != nil {
			......	
            stack = append(stack,root)
            root = root.Left
        }
        ......
   }

前序遍历

func preorderTraversal(root *TreeNode) []int {
    var res []int
    stack := []*TreeNode{}
    for root != nil || len(stack) > 0 {
        for root != nil {
            res = append(res,root.Val)
            stack = append(stack,root)
            root = root.Left
        }
        root = stack[len(stack)-1].Right
        stack = stack[:len(stack)-1]
    }
    return res
}

中序遍历

func inorderTraversal(root *TreeNode) []int {
    var res []int
    stack := []*TreeNode{}
	for root != nil || len(stack) > 0 {
		for root != nil {
			stack = append(stack, root)
			root = root.Left
		}
		root = stack[len(stack)-1].Right
		res = append(res, stack[len(stack)-1].Val)
        stack = stack[:len(stack)-1]
	}
	return res
}

后续遍历(多一个变量：上一个被记录的节点)

func postorderTraversal(root *TreeNode) []int {
    var res []int
    stack := []*TreeNode{}
    var pre *TreeNode //上一个被记录的元素
    for root != nil || len(stack) > 0 {
        for root != nil {
            stack = append(stack,root)
            root = root.Left
        }
        node := stack[len(stack)-1]
        if node.Right != nil && node.Right != pre {
            root = node.Right
        }else{
            res = append(res,node.Val)
            pre = node //该节点已被记录
            stack = stack[:len(stack)-1]
        }
    }
    return res
}

2. 🌲任意节点间路径问题：

路径：在二叉树中走一条线 且每个节点只走一遍
124. 二叉树中最大路径和
543. 二叉树的直径

func diameterOfBinaryTree(root *TreeNode) int {
    // 全局遍历作为最终结果
    var res int
    // 求数深度函数
    var depth func(*TreeNode) int
    depth = func(node *TreeNode) int {
    	......
    	/ 递归求左右子树的深度
        leftDepth := depth(node.Left)
        rightDepth := depth(node.Right)
        
        ......
        将root + left + right 作为更新最终结果res的一种情况
		......
        / 而只将 root+left 和 root+right作为返回的结果
        return max(leftPath,rightPath)+1
    }
    depth(root)
    return res
}