+ 翻转单词顺序(简单)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

func reverseWords(s string) string {

    s = strings.TrimSpace(s)

    j := len(s)-1
    i := j
    res := []string{}
    for i >= 0 {
        for i >= 0 &&  s[i] != ' '{
            i--
        }
        res = append(res, s[i+1:j+1])
        for i >= 0 &&  s[i] == ' '{
            i--
        }
        j = i

    }

    return strings.Join(res," ")
}

+ 罗马数字转整数(简单)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

func romanToInt(s string) int {
  res := map[string]int{
        "I": 1,
        "V": 5,
        "X": 10,
        "L": 50,
        "C": 100,
        "D": 500,
        "M": 1000,
    }
    sum := 0
    for i := 0; i < len(s); i++ {
        val := res[string(s[i])]
        if i < len(s)-1 && val < res[string(s[i+1])] {
            sum -= val
        } else {
            sum += val
        }
    }
    return sum
}

两个套路，一个是递归遍历二叉树traverse() 无返回值 ，一个是分解处理子数，有返回值。

综上，遇到一道二叉树的题目时的通用思考过程是：

1、是否可以通过遍历一遍二叉树得到答案？如果可以，用一个 traverse 函数配合外部变量来实现。

2、是否可以定义一个递归函数，通过子问题（子树）的答案推导出原问题的答案？如果可以，写出这个递归函数的定义，并充分利用这个函数的返回值。

3、无论使用哪一种思维模式，你都要明白二叉树的每一个节点需要做什么，需要在什么时候（前中后序）做。

1. 照片导出到手机上(方便快速使用和修改)

1. sony 相机-> 第三项 -> 发送到智能手机 -> 在智能手机上选择 -> 出现了 wifi
2. 手机连接sony 相机的 wifi
3. 手机->Imaging Edge Mobile->连接装置->查看照片

1. 双指针技巧

1.1 反转链表🔥

• 循环版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func ReverseList(head *ListNode) *ListNode {
	var prev, next *ListNode // 1. 三个辅助指针，前后和当前
	curr := head             // 2. 当前指针指向头结点，循环判断
	for curr != nil {
		next = curr.Next // 3. 先给后面的指针赋值，四连咬
		curr.Next = prev
		prev = curr
		curr = next
	}

	return prev
}

func main() {
	List1 := BuildList()
	fmt.Println("old", GetList(List1))
	List2 := ReverseList(List1)
	fmt.Println("new", GetList(List2))
}

func BuildList() *ListNode {
	L3 := &ListNode{Val: 3}
	L2 := &ListNode{Val: 2, Next: L3}
	L1 := &ListNode{Val: 1, Next: L2}
	return L1
}

func GetList(head *ListNode) []int {
	var arr []int
	for head != nil {
		arr = append(arr, head.Val)
		head = head.Next
	}
	return arr
}

1. 数组中重复的数字(简单)

• 头脑风暴: 临时数组++

  1 2 3 4 5 6 7 8 9 10 11 12

  func findRepeatNumber(nums []int) int { arr := make([]int, len(nums), len(nums)) for i := 0; i < len(nums); i++{ arr[nums[i]]++ // 题目说明, <n, 不会越界 if arr[nums[i]] > 1{ return nums[i] } } return 0 }

2. 合并两个有序数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

func merge(nums1 []int, m int, nums2 []int, n int)  {

    res := make([]int, 0, m+n)
    p1 := 0
    p2 := 0
    for {
        if p1 == m {
            res = append(res, nums2[p2:]...)
            break
        }
        if p2 == n {
            res = append(res, nums1[p1:]...)
            break
        }
        if nums1[p1] < nums2[p2] {
            res = append(res, nums1[p1])
            p1++
        }else{
            res = append(res, nums2[p2])
            p2++
        }
    }

    copy(nums1, res)
}

复杂度分析主要从「时间」和「空间」两个维度来进行分析。

• 时间维度顾名思义就是算法需要消耗的时间，「时间复杂度」是常用的分析单位。

• 空间维度代表算法需要占用的内存空间，我们通常用「空间复杂度」来分析。

mac上写作markdown，个人感觉目前还没有比typora更优秀的工具（obsidian不服）。

YAML介绍

YAML 语言（发音 /ˈjæməl/ ）的设计目标，就是方便人类读写。它实质上是一种通用的数据串行化格式。它的基本语法规则如下。

• 大小写敏感
• 使用缩进表示层级关系
• 缩进时不允许使用Tab键，只允许使用空格。
• 缩进的空格数目不重要，只要相同层级的元素左侧对齐即可

YAML 支持的数据结构有三种。

• 对象：键值对的集合(map)
• 数组：一组按次序排列的值(array)
• 纯量（scalars）：单个的、不可再分的值

1. 信号

1.1 产生信号的条件

• 用户在终端按下某些键时，终端驱动程序会发送信号给前台进程，例如Ctrl-C产生SIGINT信号，Ctrl-\产生SIGQUIT信号，Ctrl-Z产生SIGTSTP信号。
• 硬件异常产生信号，这些条件由硬件检测到并通知内核，然后内核向当前进程发送适当的信号。例如当前进程执行了除以0的指令，CPU的运算单元会产生异常，内核将这个异常解释为SIGFPE信号发送给进程。再比如当前进程访问了非法内存地址，，MMU会产生异常，内核将这个异常解释为SIGSEGV信号发送给进程。
• 一个进程调用kill(2)函数可以发送信号给另一个进程。
• 可以用kill(1)命令发送信号给某个进程，kill(1)命令也是调用kill(2)函数实现的，如果不明确指定信号则发送SIGTERM信号，该信号的默认处理动作是终止进程。
• 当内核检测到某种软件条件发生时也可以通过信号通知进程，例如闹钟超时产生SIGALRM信号，向读端已关闭的管道写数据时产生SIGPIPE信号。

先看一个例子:

1
2

export CFLAGS="-I/root/ARM/opt/include"
export LDFLAGS="-L/root/ARM/opt/lib"

CFLAGS： 指定头文件（.h文件）的路径，如：CFLAGS=-I/usr/include -I/path/include。同样地，安装一个包时会在安装路径下建立一个include目录，当安装过程中出现问题时，试着把以前安装的包的include目录加入到该变量中来。

LDFLAGS：gcc 等编译器会用到的一些优化参数，也可以在里面指定库文件的位置。用法：LDFLAGS=-L/usr/lib -L/path/to/your/lib。每安装一个包都几乎一定的会在安装目录里建立一个lib目录。如果明明安装了某个包，而安装另一个包时，它愣是说找不到，可以抒那个包的lib路径加入的LDFALGS中试一下。

LIBS：告诉链接器要链接哪些库文件，如LIBS = -lpthread -liconv