马哥高端Go语言百万并发高薪班/微服务/分布式高可用/Go高并发5期

爱分享 爱生活 加油 2021 

百度网盘

提取码：qhhv 

 

这是剑指offer的一道题。

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出以下图所示的二叉树并输出它的头结点。

思路以下：

• 中序遍历中根节点以前的节点属于左子树，以后为右子树。
• 前序遍历的第一个节点为根节点。
• 前序遍历结果的排列为：根节点-左子树节点-右子树节点
• 拆分出左子树和右子树递归重复上述过程

package main

import (
    "fmt"
)

// 重建二叉树

type Node struct {
    value int64
    left *Node
    right *Node
}

func main() {
    preOrder := []int64{1,2,4,7,3,5,6,8}
    inOrder := []int64{4,7,2,1,5,3,8,6}

    tree := constructBTree(preOrder, inOrder)
    
    //将构建好的二叉树 输出先序遍历和中序遍历的结果 用于检验
    preCatTree(tree)
    inCatTree(tree)
}

//重建二叉树
func constructBTree(preOrder, inOrder []int64) *Node{
    l := len(preOrder)
    if l == 0{
        return nil
    }

    root := &Node{
        value:preOrder[0],
    }
    if l == 1{
        return root
    }

    leftLen := 0
    rightLen := 0
    for _,v := range inOrder{
        if v == root.value{
            break
        }
        leftLen++ //根节点以前的为左子树长度
    }
    rightLen = l - leftLen - 1 //右子树长度

    if leftLen > 0{
        //fmt.Println("左子树",preOrder[1:leftLen+1], inOrder[0:leftLen]) //可打开注释查看详细过程
        root.left = constructBTree(preOrder[1:leftLen+1], inOrder[0:leftLen])
    }
    if rightLen >0{
        //fmt.Println("右子树",preOrder[leftLen+1:], inOrder[leftLen+1:])
        root.right = constructBTree(preOrder[leftLen+1:], inOrder[leftLen+1:])
    }

    return root
}


func preCatTree(t *Node) {
    fmt.Println(t.value)
    if t.left!=nil{
        preCatTree(t.left)
    }
    if t.right!=nil{
        preCatTree(t.right)
    }
}
func inCatTree(t *Node) {
    if t.left!=nil{
        inCatTree(t.left)
    }
    fmt.Println(t.value)
    if t.right!=nil{
        inCatTree(t.right)
    }
}

作的
1.格式输出

- %T 类型
- %t 布尔
- %d 10进制整数
- %x 16进制整数
- %f     浮点数
- %s     字符串
2.接口

一个类若是实现了一个接口的全部函数，那么这个类就实现了这个接口，即这个类的对象可使用接口的方法。

3.init

包的init 是初始化函数，在包引入的时候就会调用，一个包能够写多个init函数。

init 函数先于main函数自动执行，不能被其余函数调用;
init 函数没有输入参数、返回值；
每一个包能够有多个init函数；
同一个包的init执行顺序，golang没有明肯定义，编程时注意不要依赖这个执行顺序,不一样包的init函数的执行顺序依照包导入的依赖关系决定执行顺序。

4.执行顺序

 

5.多参数函数

 

6.类型转换

类型(变量)

 

7.引用

获取指针类型的所指向的值， 可使用： “*”取值符号。

好比 var p *int, 使用p获取p指针,slice、map、chan都是引用类型。

内置函数 new 计算类型大小，为其分配零值内存，返回指针。而 make 会被编译器翻译 成具体的建立函数，由其分配内存和初始化成员结构，返回对象而非指针。

8.切片

 

9.类成员函数

 

10.接口

若是两个接口有相同的方法列表，那么他们就是等价的，能够相互赋值。

11.锁

当一个goroutine(协程)得到了Mutex后，其余gorouline(协程)就只能乖乖的等待，除非该gorouline释放了该Mutex
RWMutex在 读锁 占用的状况下，会阻止写，但不阻止读
RWMutex在 写锁 占用状况下，会阻止任何其余goroutine（不管读和写）进来，整个锁至关于由该goroutine独占

12.通道

若是给一个 nil 的 channel 发送数据，会形成永远阻塞

若是从一个 nil 的 channel 中接收数据，也会形成永久爱阻塞

给一个已经关闭的 channel 发送数据， 会引发 pannic

从一个已经关闭的 channel 接收数据， 若是缓冲区中为空，则返回一个零值

无缓冲的 channel是同步的，而有缓冲的channel是非同步的。

13.通道关闭

通道关闭后，若是通道里面仍然有值，就会继续读取，直到没有值，读取到false

给一个关闭的通道传递值会引发panic

若是给一个 nil 的 channel 发送数据，会形成永远阻塞，靠协程进行疏通

若是从一个 nil 的 channel 接收数据，会形成永久阻塞，靠协程进行疏通

14.断言类型

x.(T)被称为断言类型，这里x表示一个接口的类型和T表示一个类型

15.继承

在一个结构体里面加一个架构体，就是继承

16.switch

go 当中switch语句和其余语言相似，只是有一个特殊的地方，switch后面能够不跟表达式

 

17.make与new

new返回的是指针

make用于slice map channel初始化，返回实例

18异同Printf(),Sprintf(),FprintF()

Printf()格式化输出到屏幕

Sprintf()格式化输出到变量

FprintF()输出到文件

19.数组与切片

数组定长值传递长度也是类型的一部分

切片变长引用传递  make初始化   

20.数组与切片的传递

数组是值传递，只能硬改值，若是是调用函数在函数内改变值的话，就不会达到目的。

切片是引用值，能够硬改，若是调用函数在函数内部的变化，也会反映到函数外部，它意味着[]切片类型默认使用了*切片。

21.runtime.GOMAXPROCS(逻辑CPU数量)

runtime.GOMAXPROCS 的做用是：调整并发的运行性能。 runtime.Gosched()

<1: 不修改任何数值。
=1: 单核心运行。
>1: 多核心运行。

 

22.defer执行顺序

 

23.切片

 

24.异步全局与局部变量

均为输出10， 第一个go func中i是外部for的一个变量，地址不变化。遍历完成后，最终i=10。

故go func执行时，i的值始终是10。

 

25.接口

结构体的空不是空  不等于nil

package main import (    "fmt") type People interface {}type Student struct {}   func live() People {    // 这个是结构体类型的    var stu *Student    return stu     // 这个是接口类型的    var stu People    return stu} func main() {    var a People    fmt.Println(live())    fmt.Println(a)     if a == nil {        fmt.Println("A")    } else {        fmt.Println("B")    }     if live() == nil {        fmt.Println("C")    } else {        fmt.Println("D")    }     b:=live()    if b == nil {        fmt.Println("E")    } else {        fmt.Println("F")    }}// <nil>// <nil>// A// D