4 |
5 |
2 |
3 |
4 |
5 |
17 | 新手入门Go语言学习最佳指南与实践，涵盖Go基础语法、网络、操作系统、算法与数据结构、中间件、微服务、云原生、机器学习、大数据等领域全面指南与最佳实践 18 |
19 |
39 |
40 | 为此，我们需要一种更加粗粒度的方法来对复杂度进行分析，这就是常被提到的大 O 复杂度表示法
41 |
42 | > 注：真实世界的复杂度远不止时空复杂度这么简单，但为了方便理解，本章以时间复杂度的分析为主
43 |
44 | ## Go - 大 O 复杂度表示法
45 |
46 | 因为只需要做粗略计算，我们假设：
47 |
48 | - 代码的执行时间用 T(n) 来表示
49 | - 代码的执行次数用 f(n) 来表示
50 | - 每行语句的执行效率是 unit-time，通常将其假设为单位 1
51 |
52 | 以如下代码段为例：
53 |
54 | ```go
55 | func cal(n int) {
56 | //Loop 1
57 | i := 1
58 | for ; i <= n; i++ {
59 | //Loop 2
60 | for j:= 1; j <= n ; j++{
61 | fmt.Println("i: ", i,"j: ", j)
62 | }
63 | }
64 | }
65 | ```
66 |
67 | 在 Loop 2 中，每行语句需要执行 n 遍，即 f(n) = 2 _ n ，在 Loop 1 中，Loop 2 需要执行 n 遍，那么这段代码的执行时间 T(n) = (( 2 _ n2 ) + 1 ) \* 1( 前 1 是 i 初始化，后 1 是 unit-time )。
68 |
69 | 很容易看出，T(n) 与 f(n) 是成正比的，于是，可以总结：**T(n) = O(f(n))**。
70 |
71 | 因此，类似 T(n) = O(2 \* n2) 这样的表达式被称为大 O 时间复杂度表示法。
72 |
73 | ## Go - 时空复杂度
74 |
75 | ### Go - 时间复杂度
76 |
77 | 大 O 时间复杂度只能粗略地描述代码执行时间随数据规模增长的变化趋势，故也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度。
78 |
79 | 想要精益求精，优化自己的代码，降低其时间复杂度，首先就要学会如何分析时间复杂度：
80 |
81 | 1. 基本法则：只关注 f(n) 最多的代码段。
82 |
83 | T(n) = O(f(1) + f(1000000) + f(n)) = O(f(n))
84 |
85 | 1. 加法法则：O(n) 是量级最大的 f(n) 的代码段之和。
86 |
87 | T(n) = T(f(2 \* n)) + T(f(n2)) = O(n2)
88 | T(n) = T(g(2 \* n)) + T(f(n2)) = O(max(O(g(n)), O(f(n)))
89 |
90 | 1. 乘法法则：O(n) 是嵌套代码段的 f(n) 之积。
91 |
92 | T(n) = T(g(n)) _ T(f(2 _ n)) = O(2 \* n2)
93 |
94 | 1. 保留法则：保留不同的数据规模
95 |
96 | 加法法则失效：T(n) = T(f(n)) + T(f(m)) = O(m + n)
97 | 乘法法则有效：T(n) = T(f(n)) _ T(f(m)) = O(m _ n)
98 |
99 | ### Go - 空间复杂度
100 |
101 | 大 O 表示法同样也可以用来表示空间复杂度，当其粗略地描述代码的存储空间与数据规模之间的增长关系时，就被称为渐进空间复杂度（asymptotic space complexity），简称空间复杂度。
102 |
103 | 空间复杂度的分析通过类比时间复杂度的分析即可，只需要记住，现在的关注点在于算法的存储空间，即运行代码所需要使用的内存。
104 |
105 | 如以下片段：
106 |
107 | ```go
108 | func cal() {
109 | // ...
110 | //
120 |
121 | 如果求 fib(20)，难以想象同样一个值会被重复计算多少次，因此，我们可以利用一些数据结构（如数组、散列表等）巧妙地避免这个问题：
122 |
123 | ```go
124 | // tmp[]: 存储中间值
125 | func fib(n int) (res int) {
126 | if n == 0 {
127 | return 0
128 | }
129 | if n == 1 {
130 | return 1
131 | }
132 | if tmp[n] != 0 {
133 | return tmp[n]
134 | }
135 | res = fib(n-1) + fib(n-2)
136 | tmp[n] = res
137 | return res
138 | }
139 | ```
140 |
141 | 当然，为了避免重复计算，还有更加高级的方法，我提出以上方法，便是在这里抛砖引玉了。
142 |
--------------------------------------------------------------------------------
/docs/Algorithm/basic/03-sort.md:
--------------------------------------------------------------------------------
1 | # 3. Sort - 排序
2 |
3 | - [3. Sort - 排序](#3-sort---排序)
4 | - [Go - 排序算法的指标](#go---排序算法的指标)
5 | - [Go - 排序算法的执行效率](#go---排序算法的执行效率)
6 | - [Go - 排序算法的内存消耗](#go---排序算法的内存消耗)
7 | - [Go - 排序算法的稳定性](#go---排序算法的稳定性)
8 | - [Go - 排序算法的分类](#go---排序算法的分类)
9 | - [Go - 时间复杂度 O(n2) 级](#go---时间复杂度-onsup2sup-级)
10 | - [Go - 时间复杂度 O(nlogn) 级](#go---时间复杂度-onlogn-级)
11 | - [Go - 时间复杂度 O(n) 级](#go---时间复杂度-on-级)
12 |
13 | 排序是生活中最常见的算法，可能现在你还没有接触过排序算法，但当你深入学习时，你发现它有种莫名的熟悉感。
14 |
15 | 排序算法数不胜数，短短一节肯定无法面面俱到，本节只会对最经典的排序算法进行介绍。
16 |
17 | 在介绍排序算法之前，我还需要向你简单说明一下排序算法的衡量指标。
18 |
19 | ## Go - 排序算法的指标
20 |
21 | 通常情况下，我们需要对排序算法的执行效率、内存消耗和稳定性进行比较：
22 |
23 | ### Go - 排序算法的执行效率
24 |
25 | 1. 最好、最坏、平均情况时间复杂度
26 | 2. 时间复杂度的系数、常数、低阶
27 | 3. 比较次数和移动（交换）次数
28 |
29 | 现实中的排序算法应该充分考虑数据的特点，同样的算法，面对不同数据的表现往往是不同的。
30 |
31 | ### Go - 排序算法的内存消耗
32 |
33 | - 原地排序：空间复杂度为 O(1) 的排序算法，即不需要额外的存储空间
34 |
35 | 需要消耗额外内存的排序算法往往更加稳定、效果更优，但是内存并不是无限的，面对 TB 级的数据量，非原地排序算法就会显得格外奢侈。
36 |
37 | ### Go - 排序算法的稳定性
38 |
39 | - 前提条件：假设原序列中存在值相等的元素。
40 | - 判断依据：值相同的元素在排序算法结束后，原有的先后关系是否发生变化。
41 |
42 | 面对复杂的业务，当需要使用多种排序算法时，具有稳定性的算法着能继承前一次排序的结果。
43 |
44 | ## Go - 排序算法的分类
45 |
46 | 接下来，我会按照排序算法的执行效率来介绍：
47 |
48 | ### Go - 时间复杂度 O(n2) 级
49 |
50 | **冒泡排序**
51 |
52 | 实现步骤：
53 | 1. 检查原数组长度：
54 | - 大于 1 则需要排序，否则不需要排序，直接返回原函数
55 | 2. 遍历数组，对相邻的两个数据进行比较：
56 | - 每次只会对相邻的两个数据进行比较和交换
57 | - 经过一轮遍历，如果未交换过数据，说明此时数组已有序
58 |
59 | ```Golang
60 | func bubblesort(arr []int) []int {
61 | length := len(arr)
62 | if length <= 1 {
63 | return arr
64 | }
65 |
66 | for tail := length - 1; tail > 0; tail-- {
67 | var flag bool
68 | for i := 0; i < tail; i++ {
69 | if arr[i] > arr[i+1] {
70 | flag = true
71 | tmp := arr[i]
72 | arr[i] = arr[i+1]
73 | arr[i+1] = tmp
74 | }
75 | }
76 | if !flag {
77 | break
78 | }
79 | }
80 | return arr
81 | }
82 | ```
83 |
84 | **插入排序**
85 |
86 | 实现步骤：
87 | 1. 检查原数组长度：
88 | - 大于 1 则需要排序，否则不需要排序，直接返回原函数
89 | 2. 将原数组视为两部分，已排序区间和未排序区间：
90 | - 在已排序区间中依次寻找插入数据的位置：
91 | - 大于插入数据则进行数据移动
92 | - 小于插入数据则跳出循环
93 | - 找到合适的位置插入数据
94 |
95 | ```Golang
96 | func insertsort(arr []int) []int {
97 | length := len(arr)
98 | if length <= 1 {
99 | return arr
100 | }
101 | for tail := 1; tail < length; tail++ {
102 | val := arr[tail]
103 | i := tail - 1
104 | for ; i >= 0; i-- {
105 | if arr[i] > val {
106 | arr[i+1] = arr[i]
107 | } else {
108 | break
109 | }
110 | }
111 | arr[i+1] = val
112 | }
113 | return arr
114 | }
115 | ```
116 |
117 | **选择排序**
118 |
119 | 1. 检查原数组长度：
120 | - 大于 1 则需要排序，否则不需要排序，直接返回原函数
121 | 2. 将原数组视为两部分，已排序区间和未排序区间：
122 | - 在未排序区间中寻找值最小的数
123 | - 交换数据，使其添加到已排序区间的末尾
124 |
125 | ```Golang
126 | func selectsort(arr []int) []int {
127 | length := len(arr)
128 | if length <= 1 {
129 | return arr
130 | }
131 | for tail := 0; tail < length; tail++ {
132 | pos := tail
133 | for i := tail + 1; i < length; i++ {
134 | if arr[i] < arr[pos] {
135 | pos = i
136 | }
137 | }
138 | tmp := arr[tail]
139 | arr[tail] = arr[pos]
140 | arr[pos] = tmp
141 | }
142 | return arr
143 | }
144 | ```
145 |
146 | 冒泡、插入、选择排序均是原地排序，但其中选择排序是不稳定的。
147 |
148 | 而将冒泡排序和插入排序进行比较，插入排序往往更受欢迎，虽然两者的元素移动次数都是原始数据的逆序度，但在进行数据交换的过程中，冒泡排序需要 3 个赋值操作，而插入排序仅需 1 个。
149 |
150 | 当然，插入排序还有优化空间，感兴趣的话，可以参考一下 [希尔排序](https://zh.wikipedia.org/wiki/%E5%B8%8C%E5%B0%94%E6%8E%92%E5%BA%8F)
151 |
152 | ### Go - 时间复杂度 O(nlogn) 级
153 |
154 | **归并排序**
155 |
156 | 实现步骤：
157 |
158 | 1. 把原数组从中间分成前后两部分
159 | 2. 对前后两部分分别排序
160 | 3. 将排好序的两部分合并在一起
161 | - 创建临时数组暂存已排序数据
162 | - 临时数组覆盖原数组
163 |
164 | ```Golang
165 | func MergeSort(arr []int) []int {
166 | arrLen := len(arr)
167 | if arrLen <= 1 {
168 | return arr
169 | }
170 |
171 | mergesort(arr, 0, arrLen-1)
172 | return arr
173 | }
174 |
175 | func mergesort(arr []int, head, tail int) {
176 | if head >= tail {
177 | return
178 | }
179 |
180 | mid := (head + tail) / 2
181 | mergesort(arr, head, mid)
182 | mergesort(arr, mid+1, tail)
183 | merge(arr, head, mid, tail)
184 | }
185 |
186 | func merge(arr []int, head, mid, tail int) {
187 | tmpArr := make([]int, tail-head+1)
188 |
189 | i, j, k := head, mid+1, 0
190 | for ; i <= mid && j <= tail; k++ {
191 | if arr[i] <= arr[j] {
192 | tmpArr[k] = arr[i]
193 | i++
194 | } else {
195 | tmpArr[k] = arr[j]
196 | j++
197 | }
198 | }
199 |
200 | for ; i <= mid; i++ {
201 | tmpArr[k] = arr[i]
202 | k++
203 | }
204 | for ; j <= tail; j++ {
205 | tmpArr[k] = arr[j]
206 | k++
207 | }
208 | copy(arr[head:tail+1], tmpArr)
209 | }
210 | ```
211 |
212 | 我们可以很明显的发现，归并排序另外为临时数组开辟了新的空间，因此它并不是原地排序。
213 |
214 | 我们以归并排序为例，分析一下它的空间复杂度：
215 |
216 | 1. 通过递推公式求解，整个归并过程需要的复杂度是 O(nlogn)
217 | 2. 但实际上，在合并完成后，临时开辟的内存空间会被释放掉，一个函数执行时，只会使用一个内存空间
218 | 3. 因此，临时内存空间最大不会超过 n 个数据的大小，因此，空间复杂度应该为 O(n)
219 |
220 | **快速排序**
221 |
222 | 实现步骤：
223 |
224 | 1. 选取一个数作为 pivot
225 | 2. 将数组分为三部分：
226 | - 小于 pivot 的数放到左边
227 | - pivot 放在中间
228 | - 大于 pivot 的数放到右边
229 | 3. 分别对左右两个分区做相同的操作
230 |
231 | ```Golang
232 | package quicksort
233 |
234 | func QuickSort(arr []int) []int {
235 | arrLen := len(arr)
236 | if arrLen <= 1 {
237 | return arr
238 | }
239 |
240 | quicksort(arr, 0, arrLen-1)
241 | return arr
242 | }
243 |
244 | func quicksort(arr []int, head, tail int) {
245 | if head >= tail {
246 | return
247 | }
248 |
249 | mid := partition(arr, head, tail)
250 | quicksort(arr, head, mid)
251 | quicksort(arr, mid+1, tail)
252 | }
253 |
254 | func partition(arr []int, head, tail int) int {
255 | pivot := arr[tail]
256 | i := head
257 | for j := head; j < tail; j++ {
258 | if arr[j] < pivot {
259 | arr[i], arr[j] = arr[j], arr[i]
260 | i++
261 | }
262 | }
263 | arr[i], arr[tail] = arr[tail], arr[i]
264 | return head
265 | }
266 | ```
267 |
268 | 尽管归并和快排都采用了分治的思想，但它们的处理过程是截然相反的：
269 |
270 | - 归并自下而上，先排序，再合并
271 | - 快排自上而下，先分区，再排序
272 |
273 | 快排是一种不稳定的排序，但它巧妙的设计，使其成为原地排序，相比归并排序而言，较高的空间复杂度成为了它致命的缺陷，这也是快排更受欢迎的原因
274 |
275 | 当然，快排并不是完美的，在分区极度不均匀的情况下，快排的时间复杂度将会退化到 O(n2)
276 |
277 | **堆排序**
278 |
279 | 实现步骤：
280 |
281 | 1. 建堆
282 | - 自上而下进行 **堆化**
283 | 2. 排序
284 | - 从后向前排
285 |
286 | ```Golang
287 | func HeadSort(arr []int) []int {
288 | arrLen := len(arr)
289 | if arrLen <= 1 {
290 | return arr
291 | }
292 |
293 | buildheap(arr, arrLen-1)
294 |
295 | tail := arrLen - 1
296 | for tail > 0 {
297 | arr[0], arr[tail] = arr[tail], arr[0]
298 | tail--
299 | heapify(arr, tail, 0)
300 | }
301 |
302 | return arr
303 | }
304 |
305 | func buildheap(arr []int, tail int) {
306 | for i := tail / 2; i >= 0; i-- {
307 | heapify(arr, tail, i)
308 | }
309 | }
310 |
311 | func heapify(arr []int, tail, i int) {
312 | maxPos := i
313 | for {
314 | if i*2 <= tail && arr[i] < arr[i*2] {
315 | maxPos = i * 2
316 | }
317 | if i*2+1 <= tail && arr[maxPos] < arr[i*2+1] {
318 | maxPos = i*2 + 1
319 | }
320 | if maxPos == i {
321 | return
322 | }
323 | arr[i], arr[maxPos] = arr[maxPos], arr[i]
324 | i = maxPos
325 | }
326 | }
327 | ```
328 |
329 | 同样是原地排序，但相比快排，堆排序的时间复杂度非常稳定 O(nlogn)
330 |
331 | 但堆排序的性能往往没有快排优秀：
332 |
333 | 1. 堆排序的数据访问方式对 CPU 缓存很不友好，它不如快排那般是局部顺序访问
334 | 2. 堆排序的数据交换次数往往高于快排，并且建堆的过程很容易降低其有序度
335 |
336 |
337 | ### Go - 时间复杂度 O(n) 级
338 |
339 | 线性排序的复杂度似乎是不可思议的，最主要的原因在于同之前介绍的排序相比，它是非基于比较的排序算法
340 |
341 | **桶排序**
342 |
343 | > 桶排序和计数排序十分相似，为了方便测试，我将以计数排序为例展示代码
344 |
345 | 核心思想：
346 |
347 | 1. 将数据分到 m 个有序的桶里
348 | 2. 对每个桶的数据单独进行排序
349 | 3. 排序结束后依次取出
350 |
351 |
352 | **计数排序**
353 |
354 | > 这是桶排序的一种特殊情况
355 |
356 | ```Golang
357 | func CountingSort(arr []int) []int {
358 | arrLen := len(arr)
359 | if arrLen <= 1 {
360 | return arr
361 | }
362 |
363 | max := arr[0]
364 | for _, val := range arr {
365 | if val > max {
366 | max = val
367 | }
368 | }
369 |
370 | c := make([]int, max+1)
371 |
372 | for _, val := range arr {
373 | c[val]++
374 | }
375 |
376 | for i := 1; i <= max; i++ {
377 | c[i] = c[i-1] + c[i]
378 | }
379 |
380 | r := make([]int, arrLen)
381 | for i := max - 1; i >= 0; i-- {
382 | index := c[arr[i]] - 1
383 | r[index] = arr[i]
384 | c[arr[i]]--
385 | }
386 |
387 | return r
388 | }
389 | ```
390 |
391 | **基数排序**
392 |
393 | 核心思想：
394 |
395 | 1. 将原数据补齐到同一长度
396 | 2. 分割成位进行稳定排序
397 |
398 | 基数排序对数据的要求很特别：
399 |
400 | 1. 位之间存在递进关系
401 | 2. 每一位的数据范围要能满足线性排序的要求
--------------------------------------------------------------------------------
/docs/Algorithm/basic/04-hash.md:
--------------------------------------------------------------------------------
1 | # 4. Hash - 哈希
2 |
3 | - [4. Hash - 哈希](#4-hash---哈希)
4 | - [Go - 哈希算法的定义](#go---哈希算法的定义)
5 | - [Go - 哈希算法的特征](#go---哈希算法的特征)
6 | - [Go - 哈希算法的应用](#go---哈希算法的应用)
7 |
8 | 看到 Hash 是否会感到疑惑，在数据结构的章节中我们也见过这个单词，不过在数据结构中，我们往往称之为散列表
9 |
10 | 哈希算法在生活中的应用很广，但在实际中基本有一套公认的标准，因此，本章仅对 Hash 做理论上的解释
11 |
12 | ## Go - 哈希算法的定义
13 |
14 | 哈希算法的定义非常简单，用一句话即可概括：将任意长度的二进制值串映射为固定长度的二进制值串
15 |
16 | ## Go - 哈希算法的特征
17 |
18 | 想要设计一个优秀的哈希算法，首先，需要满足一下特征：
19 | 1. 单项推导
20 | 2. 数据敏感
21 | 3. 冲突概率低
22 | 4. 高效执行
23 |
24 | ## Go - 哈希算法的应用
25 |
26 | 1. 安全加密
27 | 2. 哈希函数
28 | 3. 负载均衡
29 | 4. 分布式存储
30 |
--------------------------------------------------------------------------------
/docs/Algorithm/basic/07-greedy.md:
--------------------------------------------------------------------------------
1 | # 7. Greedy - 贪心
2 |
3 | > 掌握基础的数据结构和算法后，我还为你准备四种更加基本的、常用的算法：分治算法、回溯算法、贪心算法和动态规划
4 | >
5 | > 与其说是算法，不如说它们是算法思想，因为它们不是具体的算法，而是常作为我们设计具体算法的指导
6 |
7 | - [7. Greedy - 贪心](#7-greedy---贪心)
8 | - [Go - 贪心算法的通常适用场景](#go---贪心算法的通常适用场景)
9 | - [Go - 贪心算法的核心思想](#go---贪心算法的核心思想)
10 | - [Go - 贪心算法与最优解的关系](#go---贪心算法与最优解的关系)
11 | - [Go - 贪心算法的应用](#go---贪心算法的应用)
12 |
13 | 贪心算法可以说是生活中最常见的一种思想
14 |
15 | ## Go - 贪心算法的通常适用场景
16 |
17 | 贪心算法的适用场景往往具有两个特征：
18 |
19 | 1. 同时包含限制值和期望值
20 | 2. 要求在满足限制值的情况下，期望值最大
21 |
22 | ## Go - 贪心算法的核心思想
23 |
24 | 顾名思义，该算法的核心在于如何去贪，实际上很简单：
25 |
26 | - 每一步都保证期望值最大
27 |
28 | 但实际上，保证每一步期望值最大，并不能代表结果的期望值最大。
29 | 因此，贪心算法真正困难的地方在于如何平衡与最优解的关系
30 |
31 | ## Go - 贪心算法与最优解的关系
32 |
33 | 想要从理论上严格证明贪心算法的正确性是十分复杂的，
34 | 但从绝大部分实践的情况来看，贪心算法的正确性又是显而易见
35 |
36 | 假设我们有若干 10，9，1 面值的纸币，请问最少需要多少张纸币可以凑齐 36 元钱？
37 |
38 | - 从贪心的角度：3 张 10 元和 6 张 1 元的纸币是最优解
39 | - 但如果你对数字稍微敏感一点：4 张 9 元的纸币即可
40 |
41 | 因此，贪心算法并不能总是给出最优解
42 |
43 | ## Go - 贪心算法的应用
44 |
45 | 从 0-1 背包问题中理解贪心算法：
46 |
47 | 场景一：物品是可切割（或分块）的
48 |
49 | 背包能装 10kg 物品，从商店中选购如下几种散装的糖果：
50 | 1. s1: 10 RMB/kg 存量 2kg
51 | 2. s2: 2 RMB/kg 存量 5kg
52 | 3. s3: 20 RMB/kg 存量 4kg
53 | 4. s4: 5 RMB/kg 存量 8kg
54 |
55 | 如何购置才能让背包所装糖果的总值最高？
56 |
57 | ```Golang
58 | // 找到单价最大的下标
59 | func find_pos_max(prices []int) (pos_max int) {
60 | for i := 0; i < len(prices); i++ {
61 | if prices[pos_max] < prices[i] {
62 | pos_max = i
63 | }
64 | }
65 | return pos_max
66 | }
67 |
68 | func greedy(prices, stocks []int, bag int) (ans int) {
69 | pos_max, left := 0, bag
70 |
71 | find_pos_max(prices)
72 |
73 | for left != 0 {
74 | if stocks[pos_max] >= left {
75 | return ans + prices[pos_max]*left
76 | }
77 | ans += prices[pos_max] * stocks[pos_max]
78 | left -= stocks[pos_max]
79 | // 使用完存量后，只需要置零单价即可
80 | prices[pos_max] = 0
81 | pos_max = find_pos_max(prices)
82 | }
83 |
84 | return -1
85 | }
86 | ```
87 |
--------------------------------------------------------------------------------
/docs/Algorithm/basic/08-divide-conquer.md:
--------------------------------------------------------------------------------
1 | # 8. Analysis of Complexion - 分治
2 |
3 | - [8. Analysis of Complexion - 分治](#8-analysis-of-complexion---分治)
4 | - [Go - 分治算法的三个步骤](#go---分治算法的三个步骤)
5 | - [Go - 分治算法的条件](#go---分治算法的条件)
6 | - [Go - 分治算法的应用](#go---分治算法的应用)
7 |
8 | 早在递归一节，我们便见识过了分治算法，这里需要再区别一下两者间的关系：
9 |
10 | - 分治算法是处理问题的思想
11 | - 递归是一种编程技巧
12 |
13 | ## Go - 分治算法的三个步骤
14 |
15 | 1. 分解：将原问题分解为一系列子问题
16 | 2. 解决：递归地求解各个子问题，并且当子问题足够小时，能直接求解
17 | 3. 合并：将子问题的结果合并成原问题
18 |
19 | ## Go - 分治算法的条件
20 |
21 | 1. 原问题与分解产生的子问题具有相同的模式
22 | 2. 子问题可以独立求解，且子问题之间没有相关性
23 | 3. 具有分解终止条件
24 | 4. 可以将子问题合并成原问题
25 | 5. 合并操作的复杂度不能太高
26 |
27 | ## Go - 分治算法的应用
28 |
29 | 从归并排序中理解分治算法：[归并排序](03-sort.md#go---时间复杂度-onlogn-级)
30 |
--------------------------------------------------------------------------------
/docs/Algorithm/basic/09-backtracking.md:
--------------------------------------------------------------------------------
1 | # 9. Backtracking - 回溯
2 |
3 | - [9. Backtracking - 回溯](#9-backtracking---回溯)
4 | - [Go - 经典的八皇后问题](#go---经典的八皇后问题)
5 | - [Go - 回溯的核心思想](#go---回溯的核心思想)
6 | - [Go - 回溯算法的应用](#go---回溯算法的应用)
7 |
8 | 谈到回溯算法，就一定要讨论最著名的八皇后问题，我会在文首给出答案，希望你能在理解回溯算法后回到这里看懂它：
9 |
10 | ## Go - 经典的八皇后问题
11 |
12 | 八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？
13 |
14 | 为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上
15 |
16 | 
17 |
18 | ```Golang
19 | var result [8]int
20 |
21 | func cal8queens(row int) {
22 | if row == 8 {
23 | printQuees(result)
24 | return
25 | }
26 |
27 | for col := 0; col < 8; col++ {
28 | if isOK(row, col) {
29 | result[row] = col
30 | cal8queens(row + 1)
31 | }
32 | }
33 | }
34 |
35 | func isOK(row, col int) bool {
36 | leftup, rightup := col-1, col+1
37 | for i := row - 1; i >= 0; i-- {
38 | if result[i] == col {
39 | return false
40 | }
41 | if leftup >= 0 && result[i] == leftup {
42 | return false
43 | }
44 | if rightup < 8 && result[i] == rightup {
45 | return false
46 | }
47 | leftup--
48 | rightup++
49 | }
50 | return true
51 | }
52 | ```
53 |
54 | ## Go - 回溯的核心思想
55 |
56 | 回溯就像时间宝石，能够支撑你：
57 |
58 | - 枚举所有的可能满足预期的选择
59 | - 在碰到不符合预期的解时倒退至上一个选择
60 | - 直到选择符合预期的解
61 |
62 | ## Go - 回溯算法的应用
63 |
64 | 我们已在 [Go - 贪心算法的应用](07-greedy.md#go---贪心算法的应用) 探讨过 0-1 背包问题，现在，再次从该问题中理解回溯算法：
65 |
66 | 场景二：物品是不可切割（或分块）的
67 |
68 | 背包能装 10kg 物品，从商店中选购如下几种零食：
69 | 1. s1: 10 RMB, 2kg
70 | 2. s2: 8 RMB, 5kg
71 | 3. s3: 20 RMB, 9kg
72 | 4. s4: 5 RMB, 3kg
73 |
74 | 如何购置才能让背包所装糖果的总值最高？
75 |
76 | ```Golang
77 | var max = 0
78 |
79 | func Backtracking(prices, weights []int, item, left, value int) int {
80 | // 背包剩余量为零或者已遍历所有物品
81 | if left == 0 || item == len(prices) {
82 | if max < value {
83 | max = value
84 | }
85 | return max
86 | }
87 | // 跳过当前物品
88 | max = Backtracking(prices, weights, item+1, left, value)
89 | // 在容量足够的情况下装下当前物品
90 | if left-weights[item] >= 0 {
91 | max = Backtracking(prices, weights, item+1, left-weights[item], value+prices[item])
92 | }
93 |
94 | return max
95 | }
96 | ```
97 |
--------------------------------------------------------------------------------
/docs/Algorithm/basic/10-dynamic-programming.md:
--------------------------------------------------------------------------------
1 | # 10. Dynamic Programming - 动态规划
2 |
3 | - [10. Dynamic Programming - 动态规划](#10-dynamic-programming---动态规划)
4 | - [Go - 动态规划的通用模型](#go---动态规划的通用模型)
5 | - [Go - 动态规划的三个特征](#go---动态规划的三个特征)
6 | - [Go - 动态规划的两种方法](#go---动态规划的两种方法)
7 | - [Go - 动态规划的应用](#go---动态规划的应用)
8 |
9 | 动态规划一般用来解决最优问题
10 |
11 | ## Go - 动态规划的通用模型
12 |
13 | 解决问题的过程中需要经历多个决策阶段，且每个决策阶段都对应着一组状态
14 |
15 | ## Go - 动态规划的三个特征
16 |
17 | 1. 最优子结构
18 | 2. 无后效性
19 | 3. 重复子问题
20 |
21 | ## Go - 动态规划的两种方法
22 |
23 | 1. 状态转移表法
24 | 2. 状态转移方程法
25 |
26 | ## Go - 动态规划的应用
27 |
28 | 认真思考过 [Go - 回溯算法的应用](09-backtracking.md#go---回溯算法的应用) 后，相信你会发现有很多子问题是重复的。
29 | 现在，我们来看看动态规划是如何优化 0-1 问题的：
30 |
31 | ```Golang
32 |
33 | func Dynamic(prices, weights []int, left int) (value int) {
34 | // lenSnack 表示决策阶段
35 | lenSnack := len(prices)
36 | // 初始化 states:
37 | // states[][] 表示总价值
38 | states := make([][]int, lenSnack)
39 | for i := 0; i < lenSnack; i++ {
40 | states[i] = make([]int, left+1)
41 | }
42 | if weights[0] <= left {
43 | states[0][weights[0]] = prices[0]
44 | }
45 | for i := 1; i < lenSnack; i++ {
46 | // 不选择第 i 个物品
47 | for j := 0; j <= left; j++ {
48 | if states[i-1][j] != 0 {
49 | states[i][j] = states[i-1][j]
50 | }
51 | }
52 | // 选择第 i 个物品
53 | for j := 0; j <= left-weights[i]; j++ {
54 | if states[i-1][j] >= 0 && states[i-1][j]+prices[i] > states[i][j+weights[i]] {
55 | states[i][j+weights[i]] = states[i-1][j] + prices[i]
56 | }
57 | }
58 | }
59 | // 找到最大的值
60 | for _, val := range states[lenSnack-1] {
61 | if val > value {
62 | value = val
63 | }
64 | }
65 | return value
66 | }
67 | ```
68 |
69 | 当然，回溯也可以使用在 [递归](02-recursion.md) 的优化方法——备忘表，以达到同样的目的
70 |
--------------------------------------------------------------------------------
/docs/Book-Summary/README.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Superego-CodeEngineer/GoGetit/9823ea9a11e6511463a1101da511f084243429e3/docs/Book-Summary/README.md
--------------------------------------------------------------------------------
/docs/Cloud-Native/README.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Superego-CodeEngineer/GoGetit/9823ea9a11e6511463a1101da511f084243429e3/docs/Cloud-Native/README.md
--------------------------------------------------------------------------------
/docs/Container/README.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Superego-CodeEngineer/GoGetit/9823ea9a11e6511463a1101da511f084243429e3/docs/Container/README.md
--------------------------------------------------------------------------------
/docs/Data-Structure/README.md:
--------------------------------------------------------------------------------
1 | # Data structure implement by GO
2 |
3 | ## 一、线性数据结构
4 | #### 1、数组
5 | #### 2、链表
6 | - 单链表
7 |
8 | 
9 | - 双链表
10 | 
11 | #### 3、栈
12 | 
13 | - 栈的应用：
14 | #### 4、队列
15 | - 单队列
16 | 
17 | - 循环队列
18 | - 队列的应用：
19 | ## 二、树
20 | 
21 | #### 1、树的基本概念
22 | 树的结点（node）：包含一个数据元素及若干指向子树的分支。
23 |
24 | 根节点（root node）：树的起始结点。
25 |
26 | 子结点（child node）：结点的子树的根称为该结点的孩子。
27 |
28 | 子孙结点：以某结点为根的子树中任一结点都称为该结点的子孙。
29 |
30 | 叶子结点：也叫终端结点，是度为 0 的结点。
31 |
32 | 树的深度：树中最大的结点层
33 | #### 2、树的应用
34 | #### 3、树的遍历
35 | 前序遍历
36 | 首先访问根，再先序遍历左（右）子树，最后先序遍历右（左）子树。
37 |
38 | 中序遍历
39 | 首先中序遍历左（右）子树，再访问根，最后中序遍历右（左）子树。
40 |
41 | 后序遍历
42 | 首先后序遍历左（右）子树，再后序遍历右（左）子树，最后访问根。
43 |
44 | #### 4、二叉树的基本概念
45 | - 查找
46 | - 删除：1. 2.
47 | - 添加
48 | #### 4. 平衡二叉树的基本概念(AVL)
49 | - 增删查改的维护
50 | - single/double rotation
51 | ## 三、堆
52 | #### 1、由优先队列引出堆的基本概念
53 | #### 2、最大堆
54 | 
55 | #### 3、最小堆
56 | 
57 | #### 3、堆排序
58 | ## 四、图
59 | #### 1、图的一些语术
60 | #### 2、图的储存方式
61 | #### 3、图的搜索
62 | - DFS
63 | - BFS
64 | ## 五、其他
65 |
66 |
--------------------------------------------------------------------------------
/docs/Databases/README.md:
--------------------------------------------------------------------------------
1 | # Go Fuck DataBase
2 |
3 | ## 一、Go - DataBase Usage
4 |
5 | ### 1、关系型数据库(类MySQL)
6 |
7 | ### 2、KV数据库(类Redis)
8 |
9 | ### 3、文档数据库(MongoDB)
10 |
11 | ### 4、列存储数据库(Hbase)
12 |
13 | ### 5、图数据库(Neo4j)
14 |
15 | ## 二、Go - DataBase Driver
16 |
17 | ## 三、Go - DataBase Implement
18 |
19 | ### 1、关系型数据库
20 |
21 | ### 2、时序数据库
22 |
23 | ### 3、KV数据库
24 |
25 | ## 四、Go - DataBase Helper
26 |
27 |
--------------------------------------------------------------------------------
/docs/Hot-Project/README.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Superego-CodeEngineer/GoGetit/9823ea9a11e6511463a1101da511f084243429e3/docs/Hot-Project/README.md
--------------------------------------------------------------------------------
/docs/Interview/README.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Superego-CodeEngineer/GoGetit/9823ea9a11e6511463a1101da511f084243429e3/docs/Interview/README.md
--------------------------------------------------------------------------------
/docs/Language/README.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Superego-CodeEngineer/GoGetit/9823ea9a11e6511463a1101da511f084243429e3/docs/Language/README.md
--------------------------------------------------------------------------------
/docs/Middleware/README.md:
--------------------------------------------------------------------------------
1 | # 消息队列
2 | ### Kafka
3 | 1. 核心参数
4 | 2. 持久化
5 | 3. 常见面试题：
6 | - **如何保证消息不重复消费**
7 | - 造成消息重复消费的原因
8 | - 根本原因：在消息处理后未及时提交 offset
9 | - 由于网络延迟、机器高 cpu 占用等原因导致 kafka 认为此消费者已经处于假死状态，进行了 rebalance
10 | - 解决方案
11 | 1. 关闭消息的自动提交，改为手动提交，在拉取到消息之后、处理消息之前提交offset，但是这样就造成消息丢失的可能性，一般基建比较好的公司在大数据部门的支持下，在凌晨（服务低潮期）
12 | 通过定时任务的方式进行补足
13 | 2. 最有效：数据处理的时候做觅等，比如redis的set、数据库的主键均具有天然的觅等性
14 | - **如何保证消息不丢失**
15 | - 关闭自动提交，在数据处理完之后手动提交 offset
16 | - **如何保证消息顺序消费**
17 | 1. kafka 的分区设置为，这种方式强烈不建议使用，仅仅是八股文的解决方案。我们在选取 kafka 这种 mq 的时候大部分原因由于kafka的超高吞吐。这么高的吞吐就是因为分区的思想，现在分区变成
18 | 一个，与 kafka 的设计背离。
19 | 2. 在业务当中很难有全局有序性，更多的是局部有序性，比如一个订单的从点击、加购物车、下单、付款，我只要保证我的这四个步骤有序即可。所以真正的场景
20 | 是将这四步有序，我们不妨将这四步的有序操作放在 kafka 上游，合成一条日志消息发到 kafka ，这样就保证了严格有序，也没有牺牲任何吞吐
21 | 3. 加入我就是碰上全局有序的场景，这样的话放到下游去做，在日志消息中有顺序维度比如时间，让下游在自己的存储中使用时排序
22 | - **kafka如何能保证高吞吐**
23 | 1. 分区
24 | 2. pull方式拉取数据
25 | - **如何预估分区数量和大小**
26 | - //todo
27 | > 消息队列面试的时候，建议要结合自己的业务场景来说明，不能光背八股，还要尽量考虑周全，尤其是边界情况
28 | ### RabbitMQ
29 | ### RocketMQ
30 | ### 综合对比
31 | |特性|Kafka|RabbitMQ|RocketMQ|
32 | |---|-----|---------|---------|
33 | |qps|百万|万|万|
34 | |事务支持|支持|支持|支持|
35 | |社区活跃|活跃|活跃|一般|
36 | |||||
37 | |||||
38 | |||||
39 | # 缓存
40 | ### 分布式缓存：Redis、Memcached 和 Zookeeper
41 | 1. Redis
42 | - **常见的五种数据结构及底层实现**
43 | - **bitmap的使用及优势场景**
44 | - **redis的"快"的原因**
45 | - **redis的持久化文件rbd和aof的原理及使用**
46 | - **redis三种集群模式**
47 | - **redis同步机制**
48 | - **redis流量和存储倾斜**
49 | - **布隆过滤器**
50 | - **redLock的优劣**
51 | 2. Memcached
52 | 3. Zookeeper
53 | ### 本地缓存：go-cache
--------------------------------------------------------------------------------
/docs/Middleware/static/kafka.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Superego-CodeEngineer/GoGetit/9823ea9a11e6511463a1101da511f084243429e3/docs/Middleware/static/kafka.png
--------------------------------------------------------------------------------
/docs/Networking/Basic-Networking/content.md:
--------------------------------------------------------------------------------
1 | 
23 | 
26 | 
29 | 
32 |