-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathsearch.xml
More file actions
2619 lines (2619 loc) · 443 KB
/
search.xml
File metadata and controls
2619 lines (2619 loc) · 443 KB
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?xml version="1.0" encoding="utf-8"?>
<search>
<entry>
<title>2022年3月学习记录</title>
<url>/posts/9df3cc93/</url>
<content><![CDATA[<h2 id="使用技巧">使用技巧</h2>
<h3 id="变量声明">变量声明</h3>
<p>声明变量时一定要赋值！！！！！<br>
未定义的一维数组放在 int main() 里会生成随机数！</p>
<h3 id="类型参数">类型参数</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="keyword">template</span><<span class="keyword">typename</span> T></span><br></pre></td></tr></table></figure>
<p>原来使用 int、float、char 等内置类型的地方，都可以用类型参数来代替。</p>
<p>int len = (int) sizeof(arr) / sizeof(*arr);<br>
计算动态数组长度公式：用数组占用空间除以指针占用空间</p>
<h3 id="get函数">get函数</h3>
<p>gets()函数在C++14中被完全删除了，编译时会报错：</p>
<p>‘gets’ was not declared in this scope</p>
<p>相关功能可以用fgets()函数代替。</p>
<h3 id="命名空间">命名空间</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><algorithm></span><br></pre></td></tr></table></figure>
<h2 id="算法相关">算法相关</h2>
<h3 id="递归算法">递归算法</h3>
<p>时间复杂程度：O(log2n)<br>
注意：一定要设置结束条件！！！<br>
使用方法：<br>
1.return 函数本身<br>
2.直接调用</p>
<h3 id="杨辉三角">杨辉三角</h3>
<p>公式一：<br>
<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi><mo stretchy="false">[</mo><mi>i</mi><mo stretchy="false">]</mo><mo stretchy="false">[</mo><mi>j</mi><mo stretchy="false">]</mo><mo>=</mo><mi>a</mi><mo stretchy="false">[</mo><mi>i</mi><mo>−</mo><mn>1</mn><mo stretchy="false">]</mo><mo stretchy="false">[</mo><mi>j</mi><mo stretchy="false">]</mo><mo>+</mo><mi>a</mi><mo stretchy="false">[</mo><mi>i</mi><mo>−</mo><mn>1</mn><mo stretchy="false">]</mo><mo stretchy="false">[</mo><mi>j</mi><mo>−</mo><mn>1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">a[i][j] = a[i - 1][j] + a[i - 1][j - 1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">a</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mclose">]</span><span class="mopen">[</span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span><span class="mclose">]</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">a</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">]</span><span class="mopen">[</span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span><span class="mclose">]</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">a</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">]</span><span class="mopen">[</span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">]</span></span></span></span></p>
<p>公式二：<br>
<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>s</mi><mi>u</mi><mi>m</mi><mo>=</mo><mi>s</mi><mi>u</mi><mi>m</mi><mo>∗</mo><mo stretchy="false">(</mo><mi>i</mi><mo>−</mo><mi>j</mi><mo>+</mo><mn>1</mn><mo stretchy="false">)</mo><mi mathvariant="normal">/</mi><mo stretchy="false">(</mo><mi>j</mi><mo>−</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">sum = sum * (i - j + 1)/(j - 1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">s</span><span class="mord mathnormal">u</span><span class="mord mathnormal">m</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.4653em;"></span><span class="mord mathnormal">s</span><span class="mord mathnormal">u</span><span class="mord mathnormal">m</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">∗</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.854em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">)</span><span class="mord">/</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.05724em;">j</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span></p>
<h3 id="信息学奥赛一本通在线题库">信息学奥赛一本通在线题库</h3>
<blockquote>
<p><a href="http://ybt.ssoier.cn:8088">http://ybt.ssoier.cn:8088</a></p>
</blockquote>
<h2 id="一些题目">一些题目</h2>
<div class="note info no-icon flat"><p>以下排序算法中，不需要进行关键字比较操作的算法是（ ）。<br>
A. 基数排序<br>
B. 冒泡排序<br>
C. 堆排序<br>
D. 直接插入排序</p>
</div>
<div class="note info no-icon flat"><p>设 x=true, y=true, z=false，以下逻辑运算表达式值为真的是（ ）。<br>
A. (y∨z)∧x∧z<br>
B. x∧(z∨y) ∧z<br>
C. (x∧y) ∧z<br>
D. (x∧y)∨(z∨x)</p>
</div>
<h2 id="参考资料">参考资料</h2>
<h3 id="真题">真题</h3>
<blockquote>
<p><a href="https://ti.luogu.com.cn">https://ti.luogu.com.cn</a></p>
</blockquote>
<h3 id="几种排序算法">几种排序算法</h3>
<blockquote>
<p><a href="https://www.cnblogs.com/rope/p/12119391.html">https://www.cnblogs.com/rope/p/12119391.html</a></p>
</blockquote>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
</tags>
</entry>
<entry>
<title>2022年4月学习记录 - 时间复杂度总结</title>
<url>/posts/9685fddf/</url>
<content><![CDATA[<div class="tabs" id="text"><ul class="nav-tabs"><li class="tab"><button type="button" data-href="#text-1">更新记录</button></li></ul><div class="tab-contents"><div class="tab-item-content" id="text-1"><div class="timeline"><div class='timeline-item headline'><div class='timeline-item-title'><div class='item-circle'><p>2022年4月学习记录 - 时间复杂度总结</p>
</div></div></div><div class='timeline-item'><div class='timeline-item-title'><div class='item-circle'><p>2022-12-15 链接修复</p>
</div></div><div class='timeline-item-content'><ol>
<li>链接修复：文章跳转链接修复</li>
</ol>
</div></div></div><button type="button" class="tab-to-top" aria-label="scroll to top"><i class="fas fa-arrow-up"></i></button></div></div></div>
<blockquote>
<p>本文只是时间复杂度的简单介绍，学习做题请前往<a href="/posts/bfc79706/">2022年9月学习记录 - 时间复杂度题目训练</a></p>
</blockquote>
<h2 id="时间复杂度">时间复杂度</h2>
<h3 id="常见的时间复杂度">常见的时间复杂度</h3>
<div class="note info simple"><p>1.常数阶O(1)<br>
2.对数阶O(log2n)<br>
3.线性阶O(n)<br>
4.线性对数阶O(nlog2n)<br>
5.平方阶O(n2)<br>
6.立方阶O(n3)<br>
7.k次方阶O(nk)<br>
8.指数阶O(2n)</p>
</div>
<h3 id="最坏时间和平均时间">最坏时间和平均时间</h3>
<p>最坏情况下的时间复杂度是算法在任何输入实例上运行时间的上界，这就保证了算法的运行时间不会比任何更长。</p>
<p>在最坏情况下的时间复杂度为T(n)=O(n)，它表示对于任何输入实例,该算法的运行时间不可能大于O(n)。</p>
<p>平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，算法的期望运行时间。</p>
<h3 id="计算方法">计算方法</h3>
<div class="note info simple"><p>求解算法的时间复杂度的具体步骤是：<br>
⑴ 找出算法中的基本语句：算法中执行次数最多的那条语句就是基本语句，通常是最内层循环的循环体。<br>
⑵ 计算基本语句的执行次数的数量级：只需计算基本语句执行次数的数量级，这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可，可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析，并且使注意力集中在最重要的一点上：增长率。<br>
⑶ 用大Ο记号表示算法的时间性能：将基本语句执行次数的数量级放入大Ο记号中。</p>
</div>
<h3 id="具体实例">具体实例</h3>
<h4 id="O-1">O(1)</h4>
<p>常数阶，即时间复杂度不随着规模n的增大而增大。如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="type">int</span> x=<span class="number">91</span>; </span><br><span class="line"><span class="type">int</span> y=<span class="number">100</span>;</span><br><span class="line"><span class="keyword">while</span>(y><span class="number">0</span>) {</span><br><span class="line"> <span class="keyword">if</span>(x><span class="number">100</span>) {</span><br><span class="line"> x=x<span class="number">-10</span>;</span><br><span class="line"> y--;</span><br><span class="line"> } <span class="keyword">else</span> {</span><br><span class="line"> x++;</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p>T(n)=O(1)</p>
<p>这个程序看起来有点吓人，总共循环运行了1000次，但是这段程序并没有n，因此它只是一个常数阶的函数</p>
<h4 id="O-n">O(n)</h4>
<p>一次阶时间复杂度。耗费的时间与规模n成一阶线性关系。</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="type">int</span> n;</span><br><span class="line">cin >> n;</span><br><span class="line"><span class="keyword">while</span> (n--) {</span><br><span class="line"> cout << n << endl;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h4 id="O-n-3">O(n^3)</h4>
<p>三阶线性关系。（n阶线性以此类推即可。）就好像矩阵相乘就永远是O（n^3 ）</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="type">int</span> total = <span class="number">0</span>;</span><br><span class="line"><span class="type">int</span> n;</span><br><span class="line">cin >> n;</span><br><span class="line"><span class="keyword">for</span> (<span class="type">int</span> i = <span class="number">0</span>; i != n; i++) {</span><br><span class="line"> <span class="keyword">for</span> (<span class="type">int</span> j = <span class="number">0</span>; j != i; j++) {</span><br><span class="line"> <span class="keyword">for</span> (<span class="type">int</span> k = <span class="number">0</span>; j != j; k++) {</span><br><span class="line"> total++;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p>内循环的执行次数虽然与问题规模n没有直接关系，但是却与外层循环的变量取值有关，而最外层循环的次数直接与n有关，因此可以从内层循环向外层分析语句的执行次数：则该程序段的时间复杂度为</p>
<p>T(n)=O(n^3 /6+低次项)=O(n^3)</p>
<h3 id="常见的算法时间复杂度由小到大">常见的算法时间复杂度由小到大</h3>
<p>Ο(1)＜Ο(log2(n))＜Ο(n)＜Ο(nlog2(n))＜Ο(n^2) ＜Ο(n^3) ＜…＜Ο(2^n) ＜Ο(n!)</p>
<h3 id="分析法则">分析法则</h3>
<p>在计算算法时间复杂度时有以下几个简单的程序分析法则:</p>
<div class="note info simple"><p>1.对于一些简单的输入输出语句或赋值语句,近似认为需要O(1)时间</p>
<p>2.对于顺序结构,需要依次执行一系列语句所用的时间可采用大O下”求和法则”</p>
<p>3.求和法则:是指若算法的2个部分时间复杂度分别为 T1(n)=O(f(n))和 T2(n)=O(g(n)),则 T1(n)+T2(n)=O(max(f(n), g(n)))</p>
<p>特别地,若T1(m)=O(f(m)), T2(n)=O(g(n)),则 T1(m)+T2(n)=O(f(m) + g(n))<br>
3.对于选择结构,如if语句,它的主要时间耗费是在执行then字句或else字句所用的时间,需注意的是检验条件也需要O(1)时间</p>
<p>4.对于循环结构,循环语句的运行时间主要体现在多次迭代中执行循环体以及检验循环条件的时间耗费,一般可用大O下”乘法法则”</p>
<p>乘法法则: 是指若算法的2个部分时间复杂度分别为 T1(n)=O(f(n))和 T2(n)=O(g(n)),则 T1*T2=O(f(n)*g(n))</p>
<p>5.对于复杂的算法,可以将它分成几个容易估算的部分,然后利用求和法则和乘法法则技术整个算法的时间复杂度</p>
</div>
<p>另外还有以下2个运算法则:</p>
<div class="note info simple"><p>(1) 若g(n)=O(f(n)),则O(f(n))+ O(g(n))= O(f(n))</p>
<p>(2) O(Cf(n)) = O(f(n)),其中C是一个正常数</p>
</div>
<h3 id="参考资料">参考资料</h3>
<p><a href="https://blog.csdn.net/stary_yan/article/details/51383480">[C++]时间复杂度&空间复杂度</a></p>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>时间复杂度</tag>
</tags>
</entry>
<entry>
<title>2022年5月学习记录</title>
<url>/posts/ce62a577/</url>
<content><![CDATA[<h2 id="OpenCV">OpenCV</h2>
<h3 id="参考资料">参考资料</h3>
<p><a href="https://blog.csdn.net/weixin_44297922/article/details/121496280">基于Opencv实现的简易汉字识别</a></p>
<p><a href="https://blog.csdn.net/iracer/article/details/116051674">OpenCV4机器学习算法原理与编程实战（附部分模型下载地址）</a></p>
<p><a href="https://blog.csdn.net/hacker_NO_007/article/details/123470483">戴口罩情境下的人脸识别demo</a></p>
<p><a href="https://zhuanlan.zhihu.com/p/107719641">开源人脸口罩检测数据+模型+代码+在线网页体验，通通都开源</a></p>
<h3 id="二维码识别">二维码识别</h3>
<p>Detect 只检测<br>
Decode 只解析<br>
DetectAndDecode 检测并解析</p>
<h2 id="卷积神经网络">卷积神经网络</h2>
<h3 id="参考资料-2">参考资料</h3>
<p>xxxxxxxxxx4 1long long gcd(long long a,long long b){2 cout<<“a=”<<a<<“,b=”<<b<<endl;3 return !(a%b)?b:gcd(b,a%b);4}C++</p>
<h3 id="forward-beackword-数据计算">forward/beackword 数据计算</h3>
<p>顺推和逆推</p>
<h2 id="卷积">卷积</h2>
<h3 id="关键词">关键词</h3>
<p>集散卷积</p>
<p>连续卷积</p>
<h3 id="参考资料：">参考资料：</h3>
<p><a href="https://blog.csdn.net/bitcarmanlee/article/details/54729807">最容易理解的对卷积(convolution)的解释</a></p>
<h2 id="交叉熵">交叉熵</h2>
<h3 id="关键词-2">关键词</h3>
<p>贝叶斯决策理论</p>
<p>拟然函数</p>
<p>概率密度函数</p>
<h3 id="参考资料：-2">参考资料：</h3>
<p><a href="https://zhuanlan.zhihu.com/p/115277553">损失函数：交叉熵详解</a></p>
<h2 id="VS编译错误总结">VS编译错误总结</h2>
<h3 id="LINK2005-和-C2352">LINK2005 和 C2352</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="keyword">class</span> <span class="title class_">Sample</span> {</span><br><span class="line"> <span class="keyword">public</span>:</span><br><span class="line"> <span class="function"><span class="type">static</span> <span class="type">void</span> <span class="title">test1</span><span class="params">()</span></span>;</span><br><span class="line">};</span><br><span class="line"></span><br><span class="line">Sample::<span class="built_in">test1</span>();</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
</tags>
</entry>
<entry>
<title>2022年6月学习记录</title>
<url>/posts/e7aa1185/</url>
<content><![CDATA[<h2 id="Dev-c">Dev-c++</h2>
<p>编译参数</p>
<figure class="highlight bat"><table><tr><td class="code"><pre><span class="line">-std=c++<span class="number">14</span> -Wall -fno-ms-extensions</span><br></pre></td></tr></table></figure>
<h2 id="CMake">CMake</h2>
<h2 id="解题公式">解题公式</h2>
<h3 id="巧用位移解题">巧用位移解题</h3>
<ul>
<li>2的n次幂 ===> (1<<n）</li>
</ul>
<h3 id="求最小公倍数">求最小公倍数</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="type">long</span> <span class="type">long</span> <span class="title">gcd</span><span class="params">(<span class="type">long</span> <span class="type">long</span> a,<span class="type">long</span> <span class="type">long</span> b)</span></span>{</span><br><span class="line"> cout<<<span class="string">"a="</span><<a<<<span class="string">",b="</span><<b<<endl;</span><br><span class="line"> <span class="keyword">return</span> !(a%b)?b:<span class="built_in">gcd</span>(b,a%b);</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
</tags>
</entry>
<entry>
<title>2022年7月学习记录</title>
<url>/posts/49c28014/</url>
<content><![CDATA[<h2 id="好公式">好公式</h2>
<p>将变量设为0</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="built_in">memset</span>(变量名,<span class="number">0</span>,<span class="built_in">sizeof</span>(变量名))</span><br></pre></td></tr></table></figure>
<h2 id="刷题ing">刷题ing</h2>
<h3 id="【模板】快速排序">【模板】快速排序</h3>
<p>其实就是 STL 的 sort</p>
<h4 id="题目链接">题目链接</h4>
<ul>
<li><a href="https://www.luogu.com.cn/problem/P1177">P1177 【模板】快速排序</a></li>
</ul>
<h4 id="动态演示">动态演示</h4>
<p><img src="/assets/image/posts/49c28014/QuickSort.gif" alt="QuickSort.gif"></p>
<h4 id="代码实现">代码实现</h4>
<p>使用 C++ STL sort</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><algorithm></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> n=<span class="number">0</span>;</span><br><span class="line"> cin>>n;</span><br><span class="line"> <span class="type">int</span> num[n+<span class="number">2</span>]={<span class="number">0</span>};</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<n;i++){</span><br><span class="line"> cin>>num[i];</span><br><span class="line"> } </span><br><span class="line"> <span class="built_in">sort</span>(num,num+n);</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<n;i++){</span><br><span class="line"> cout<<num[i]<<<span class="string">" "</span>;</span><br><span class="line"> } </span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p>手写快排</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="function"><span class="type">void</span> <span class="title">QuickSort</span><span class="params">(<span class="type">int</span>* num,<span class="type">int</span> l,<span class="type">int</span> r)</span></span>{</span><br><span class="line"> <span class="type">int</span> mid=num[(l+r)/<span class="number">2</span>];</span><br><span class="line"> <span class="type">int</span> i=l,j=r;</span><br><span class="line"> <span class="keyword">do</span>{</span><br><span class="line"> <span class="keyword">while</span>(num[i]<mid) i++;</span><br><span class="line"> <span class="keyword">while</span>(num[j]>mid) j--;</span><br><span class="line"> <span class="keyword">if</span>(i<=j)</span><br><span class="line"> {</span><br><span class="line"> <span class="built_in">swap</span>(num[i],num[j]);</span><br><span class="line"> i++;</span><br><span class="line"> j--;</span><br><span class="line"> }</span><br><span class="line"> }<span class="keyword">while</span>(i<=j);</span><br><span class="line"> <span class="keyword">if</span>(l<j) <span class="built_in">QuickSort</span>(num,l,j);</span><br><span class="line"> <span class="keyword">if</span>(i<r) <span class="built_in">QuickSort</span>(num,i,r);</span><br><span class="line">}</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> n=<span class="number">0</span>;</span><br><span class="line"> cin>>n;</span><br><span class="line"> <span class="type">int</span> num[n+<span class="number">2</span>]={<span class="number">0</span>};</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++){</span><br><span class="line"> cin>>num[i];</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">QuickSort</span>(num,<span class="number">1</span>,n);</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++){</span><br><span class="line"> cout<<num[i]<<<span class="string">" "</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="【模板】程序优化">【模板】程序优化</h3>
<h4 id="题目链接-2">题目链接</h4>
<ul>
<li><a href="https://www.luogu.com.cn/problem/P1923">P1923 【深基9.例4】求第 k 小的数</a></li>
</ul>
<h4 id="代码实现-2">代码实现</h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><algorithm></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="comment">//快读</span></span><br><span class="line"><span class="function"><span class="keyword">inline</span> <span class="type">int</span> <span class="title">read</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">char</span> ch=<span class="built_in">getchar</span>();</span><br><span class="line"> <span class="type">int</span> x=<span class="number">0</span>,f=<span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span>(ch<<span class="string">'0'</span>||ch><span class="string">'9'</span>){</span><br><span class="line"> <span class="keyword">if</span>(ch==<span class="string">'-'</span>) f=<span class="number">-1</span>;</span><br><span class="line"> ch=<span class="built_in">getchar</span>();</span><br><span class="line"> } </span><br><span class="line"> <span class="keyword">while</span>(<span class="string">'0'</span><=ch&&ch<=<span class="string">'9'</span>){</span><br><span class="line"> x=x*<span class="number">10</span>+ch-<span class="string">'0'</span>;</span><br><span class="line"> ch=<span class="built_in">getchar</span>();</span><br><span class="line"> } <span class="keyword">return</span> x*f;</span><br><span class="line">}</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> n,k;</span><br><span class="line"> n=<span class="built_in">read</span>();</span><br><span class="line"> k=<span class="built_in">read</span>();</span><br><span class="line"> <span class="type">int</span> num[n+<span class="number">2</span>]={<span class="number">0</span>}; </span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<n;i++){ </span><br><span class="line"> num[i]=<span class="built_in">read</span>();</span><br><span class="line"> }</span><br><span class="line"> <span class="built_in">nth_element</span>(num,num+k,num+n);</span><br><span class="line"> cout<<num[k];</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="【算法】深度优先探索">【算法】深度优先探索</h3>
<h4 id="代码实现-3">代码实现</h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">dfs</span><span class="params">(<span class="type">int</span> n,<span class="type">int</span> step=<span class="number">1</span>)</span></span>{</span><br><span class="line"> <span class="type">static</span> <span class="type">int</span> ans[<span class="number">11</span>],book[<span class="number">11</span>],sum=<span class="number">0</span>;</span><br><span class="line"> <span class="keyword">if</span>(step==n){</span><br><span class="line"> sum++;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++){</span><br><span class="line"> cout<<ans[i];</span><br><span class="line"> }</span><br><span class="line"> cout<<endl;</span><br><span class="line"> <span class="keyword">return</span> sum;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++){</span><br><span class="line"> <span class="keyword">if</span>(book[i]==<span class="number">0</span>){</span><br><span class="line"> ans[step]=i;</span><br><span class="line"> book[i]=<span class="number">1</span>;</span><br><span class="line"> <span class="built_in">dfs</span>(n,step+<span class="number">1</span>);</span><br><span class="line"> book[i]=<span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> sum;</span><br><span class="line">}</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> n=<span class="number">0</span>;</span><br><span class="line"> cin>>n;</span><br><span class="line"> cout<<<span class="built_in">dfs</span>(n)<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
</tags>
</entry>
<entry>
<title>2022年8月学习记录 - STL</title>
<url>/posts/b67e9d81/</url>
<content><![CDATA[<blockquote>
<p>系统学习</p>
<p>建议搭配 <a href="/posts/8956865">2022 年 8 月学习记录 - 队列、栈及其应用</a> 一起使用。</p>
</blockquote>
<h2 id="我的学习资料">我的学习资料</h2>
<blockquote>
<p>BiliBili：<a href="https://www.bilibili.com/video/BV1Rg41117YB">清华算协暑期培训 第二讲 STL & 基础数据结构</a></p>
</blockquote>
<h2 id="栈（Stack）">栈（Stack）</h2>
<p>特征：先进后出/后进先出</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// STL 实现</span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><stack></span></span></span><br><span class="line">std::stack<T> s;</span><br><span class="line">s.<span class="built_in">push</span>(x); <span class="comment">//插入元素</span></span><br><span class="line">s.<span class="built_in">pop</span>(); <span class="comment">//弹出元素</span></span><br><span class="line">s.<span class="built_in">top</span>(); <span class="comment">//查询头元素</span></span><br></pre></td></tr></table></figure>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 数组实现</span></span><br><span class="line"><span class="type">const</span> <span class="type">int</span> N = <span class="number">10</span>; <span class="comment">//栈的大小</span></span><br><span class="line">T stack[N];</span><br><span class="line"><span class="type">int</span> top=<span class="number">0</span>;</span><br><span class="line"><span class="comment">// 判断栈是否为空</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">empty</span><span class="params">(<span class="type">int</span> top)</span></span>{</span><br><span class="line"> <span class="keyword">return</span> top==<span class="number">0</span>;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 判断栈是否已满</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">full</span><span class="params">(<span class="type">int</span> top)</span></span>{</span><br><span class="line"> <span class="keyword">return</span> top==n;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 插入一个元素</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">push</span><span class="params">(T stack[],T x)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(full){</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> stack[top++]=x;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 弹出一个元素</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">pop</span><span class="params">(T stack[],T *x)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(empty){</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> x=stack[--top];</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 查询头元素</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">top</span><span class="params">(T stack[],T *x)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(sempty){</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> x=stack[top];</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="卡特兰数-Catalan">卡特兰数(Catalan)</h3>
<p>应用：括号序列、三角剖分、二叉树计算</p>
<h2 id="队列（Queue）">队列（Queue）</h2>
<p>特性：先进先出。</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// STL实现</span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><queue></span></span></span><br><span class="line">std::queue<T> q;</span><br><span class="line">q.<span class="built_in">push</span>(x); <span class="comment">//插入元素</span></span><br><span class="line">q.<span class="built_in">pop</span>(); <span class="comment">//弹出元素</span></span><br><span class="line">q.<span class="built_in">front</span>(); <span class="comment">//查询头元素</span></span><br><span class="line">q.<span class="built_in">back</span>(); <span class="comment">//查询尾元素</span></span><br></pre></td></tr></table></figure>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 数组实现</span></span><br><span class="line"><span class="type">const</span> <span class="type">int</span> N = <span class="number">10</span>; <span class="comment">//队列的大小</span></span><br><span class="line">T queue[N];</span><br><span class="line"><span class="type">int</span> head=<span class="number">0</span>,tail=<span class="number">0</span>;</span><br><span class="line"><span class="comment">// 返回队列大小</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">size</span><span class="params">(T queue[])</span></span>{</span><br><span class="line"> <span class="keyword">return</span> tail-head; </span><br><span class="line">}</span><br><span class="line"><span class="comment">// 判断队列是否为空</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">empty</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="keyword">return</span> head==tail;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 插入元素</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">push</span><span class="params">(T queue[],T x)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(){</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> queue[tail++]=x;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 弹出元素</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">pop</span><span class="params">(T queue[],T *x)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(empty){</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> x=queue[head++];</span><br><span class="line"> <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 查询头元素</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">front</span><span class="params">(<span class="type">int</span> *x)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(empty){</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> x=queue[head];</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 查询尾元素</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">back</span><span class="params">(<span class="type">int</span> *x)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(empty){</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> x=queue[tail];</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h2 id="向量（Vector）">向量（Vector）</h2>
<p>一句话概括：不定长的数组。</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// STL实现</span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><vertor></span></span></span><br><span class="line">std::vector<T> v;</span><br><span class="line">v.<span class="built_in">insert</span>(iter,x); <span class="comment">//在iter处插入元素</span></span><br><span class="line">v.<span class="built_in">push_back</span>(); <span class="comment">//在末尾插入元素</span></span><br><span class="line">v.<span class="built_in">erase</span>(iter); <span class="comment">//弹出iter处的元素</span></span><br><span class="line">v.<span class="built_in">pop_back</span>(); <span class="comment">//弹出尾元素</span></span><br></pre></td></tr></table></figure>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 数组实现</span></span><br><span class="line"><span class="type">int</span> *a = <span class="keyword">new</span> <span class="type">int</span> [N];</span><br></pre></td></tr></table></figure>
<h2 id="列表（List）与链表（linked-list）">列表（List）与链表（linked list）</h2>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// STL实现</span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><list></span></span></span><br><span class="line">std::list<T> l;</span><br><span class="line">l.<span class="built_in">front</span>(); <span class="comment">//查询头元素</span></span><br><span class="line">l.<span class="built_in">back</span>(); <span class="comment">//查询尾元素</span></span><br><span class="line">l.<span class="built_in">insert</span>(iter,x); <span class="comment">//在iter处插入元素</span></span><br><span class="line">l.<span class="built_in">push_back</span>(); <span class="comment">//在末尾插入元素</span></span><br><span class="line">l.<span class="built_in">push_front</span>(); <span class="comment">//在开头插入元素</span></span><br><span class="line">l.<span class="built_in">erase</span>(iter); <span class="comment">//弹出iter处的元素</span></span><br><span class="line">l.<span class="built_in">pop_back</span>(); <span class="comment">//弹出尾元素</span></span><br><span class="line">l.<span class="built_in">pop_front</span>(); <span class="comment">//弹出头元素</span></span><br></pre></td></tr></table></figure>
<h3 id="链表的结构">链表的结构</h3>
<h4 id="哨兵节点：">哨兵节点：</h4>
<p>头元素和尾元素的处理：可以不用考虑边界情况</p>
<ul>
<li>use it or 特判</li>
</ul>
<h4 id="单向链表：">单向链表：</h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="keyword">struct</span> <span class="title class_">Node</span> {</span><br><span class="line"> <span class="type">int</span> val;</span><br><span class="line"> Node *next;</span><br><span class="line">};</span><br><span class="line">std::forward_list (C++<span class="number">11</span>)</span><br></pre></td></tr></table></figure>
<h5 id="基本操作-插入">基本操作 - 插入</h5>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function">Node* <span class="title">insert</span><span class="params">(Node *pos,<span class="type">int</span> value)</span></span>{</span><br><span class="line"> Node *n = <span class="keyword">new</span> <span class="built_in">Node</span>(value);</span><br><span class="line"> n->next = pos->next;</span><br><span class="line"> post->next = n;</span><br><span class="line"> <span class="keyword">return</span> n;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 注：代码中的语句顺序不能调换</span></span><br></pre></td></tr></table></figure>
<h5 id="基本操作-删除">基本操作 - 删除</h5>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="type">void</span> <span class="title">erase</span><span class="params">(Node *pos)</span></span>{</span><br><span class="line"> Node *tmp = pos->next;</span><br><span class="line"> pos->next = pos->next->next;</span><br><span class="line"> <span class="keyword">delete</span> tmp;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h5 id="翻转-reverse">翻转 - reverse()</h5>
<p>将一个链表整体翻转</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line">std::forward_list::<span class="built_in">reverse</span>()</span><br></pre></td></tr></table></figure>
<h4 id="双向链表：">双向链表：</h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="keyword">struct</span> <span class="title class_">Node</span>{</span><br><span class="line"> <span class="type">int</span> val;</span><br><span class="line"> Node *prev,*next;</span><br><span class="line">};</span><br></pre></td></tr></table></figure>
<h5 id="基本操作-插入-2">基本操作 - 插入</h5>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function">Node* <span class="title">insert</span><span class="params">(Node *pos,<span class="type">int</span> value)</span></span>{</span><br><span class="line"> Node *n = <span class="keyword">new</span> <span class="built_in">Node</span>(value);</span><br><span class="line"> n->next = pos->next;</span><br><span class="line"> n->prev = pos;</span><br><span class="line"> pos->next->prev = n;</span><br><span class="line"> pos->next = n;</span><br><span class="line"> <span class="keyword">return</span> n;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 注：代码中的语句顺序不能调换</span></span><br></pre></td></tr></table></figure>
<h5 id="基本操作-删除-2">基本操作 - 删除</h5>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="type">void</span> <span class="title">erase</span><span class="params">(Node *pos)</span></span>{</span><br><span class="line"> pos->prev->next = pos->next;</span><br><span class="line"> pos->next->prev = pos->prev;</span><br><span class="line"> <span class="keyword">delete</span> pos;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 注：代码中的语句顺序可以调换</span></span><br><span class="line"><span class="comment">// STL 的 erase 方法会返回删除之后的原子之后的迭代器，这里为了简化代码就仅返回了 void</span></span><br></pre></td></tr></table></figure>
<h5 id="翻转-reverse-2">翻转 - reverse()</h5>
<p>将一个链表整体翻转</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line">std::list::<span class="built_in">reverse</span>()</span><br></pre></td></tr></table></figure>
<p>交换 prev 和 next （首尾特别处理）</p>
<h4 id="通用">通用</h4>
<h5 id="基本操作-遍历">基本操作 - 遍历</h5>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="keyword">for</span> (Node* x = head->next; x != tail; x = x->next);</span><br></pre></td></tr></table></figure>
<h4 id="一些技巧">一些技巧</h4>
<div class="note warning flat"><p>生产环境中请不要随意使用</p>
</div>
<h5 id="内存池">内存池</h5>
<p>优化 new 和 delete 的时间复杂度</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line">Node pool[MAXN];</span><br><span class="line"><span class="type">int</span> top;</span><br><span class="line"><span class="function">Node* <span class="title">newnode</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="keyword">return</span> &pool[top++];</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h5 id="数组下标模拟指针">数组下标模拟指针</h5>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="keyword">struct</span> <span class="title class_">Node</span>{</span><br><span class="line"> <span class="type">int</span> val,next;</span><br><span class="line">} pool[MAXN];</span><br><span class="line"><span class="type">int</span> top;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">newnode</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="keyword">return</span> top++;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h2 id="优先队列（Priority-Queue）">优先队列（Priority Queue）</h2>
<p>特征：“优先级”大的先离开</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><queue></span></span></span><br><span class="line">std::priority_queue<T> pq;</span><br><span class="line">pq.<span class="built_in">push</span>(x); <span class="comment">//插入一个元素</span></span><br><span class="line">pq.<span class="built_in">pop</span>(); <span class="comment">//弹出最大的元素</span></span><br><span class="line">pq.<span class="built_in">top</span>(); <span class="comment">//查询最大的元素</span></span><br><span class="line"></span><br><span class="line">std:greater<T> <span class="comment">//反向使用</span></span><br></pre></td></tr></table></figure>
<p>实现：二叉树</p>
<h2 id="其他-STL">其他 STL</h2>
<h4 id="容器类">容器类</h4>
<ol>
<li>
<p>set/map</p>
</li>
<li>
<p>deque</p>
</li>
</ol>
<h4 id="算法类">算法类</h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><algorithm></span></span></span><br></pre></td></tr></table></figure>
<ol>
<li>
<p>sort：排序</p>
</li>
<li>
<p>lower_bound：二分查找（<strong>大于等于</strong>）</p>
</li>
<li>
<p>upper_bound：二分查找（<strong>大于</strong>）</p>
</li>
<li>
<p>merge：归并</p>
</li>
</ol>
<h4 id="更多资料"><a href="https://cppreference.com">更多资料</a></h4>
<h2 id="一些应用">一些应用</h2>
<h4 id="单调栈-单调队列">单调栈 单调队列</h4>
<ul>
<li>
<p>例题给出 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span> 天的气温情况，对于每一天，求出前k天的气温最大值。</p>
</li>
<li>
<p>关键的观察：如果存在两个数满足 $ i<j∧a_i<a_j $ ,那么在<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi></mrow><annotation encoding="application/x-tex">a</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">a</span></span></span></span>被纳入考察之后，<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>a</mi></mrow><annotation encoding="application/x-tex">a</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">a</span></span></span></span> 就不可能成为最大值了。（<s>如果有人比你年轻还比你强</s>）</p>
</li>
<li>
<p>那么我们需要考虑的可能值是单调递减的。</p>
</li>
<li>
<p>从左到右扫描，每加入一个数，可以排除最末尾的一段数的可能性。</p>
</li>
<li>
<p>同时我们只需要维护前k天的情况，因此过期的数据也可排除。</p>
</li>
<li>
<p>我们需要实现 push_back,pop_back,pop_front。</p>
</li>
</ul>
<h4 id="表达式求值">表达式求值</h4>
<ul>
<li>
<p>为了简化问题，假设我们只有 $ + $ $ - $ $ * $ $ / $ $ () $ 这几种运算。</p>
</li>
<li>
<p>观察：<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mo>+</mo><mn>2</mn><mo>∗</mo><mn>3</mn></mrow><annotation encoding="application/x-tex">1+2*3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">∗</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">3</span></span></span></span> 和 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mo>∗</mo><mn>2</mn><mo>+</mo><mn>3</mn></mrow><annotation encoding="application/x-tex">1*2+3</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">∗</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">3</span></span></span></span> 。我们什么时候可以确定计算顺序？</p>
</li>
<li>
<p>第一个等式需要到最末尾，第二个等式在扫描到 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>+</mo></mrow><annotation encoding="application/x-tex">+</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord">+</span></span></span></span> 的时候就发现可以计算前面的内容。</p>
</li>
<li>
<p>无法判断的式子优先级大小递增。</p>
</li>
<li>
<p>类似单调队列的单调栈。同时需要维护没有计算的数。</p>
</li>
<li>
<p>将括号也纳入优先级比较的范围，或者每遇到一层括号，括号内优先级增加一档。</p>
</li>
</ul>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
<tag>STL</tag>
</tags>
</entry>
<entry>
<title>2022年8月学习记录 - 动态规划专练</title>
<url>/posts/86fa511b/</url>
<content><![CDATA[<div class="tabs" id="text"><ul class="nav-tabs"><li class="tab"><button type="button" data-href="#text-1">更新记录</button></li></ul><div class="tab-contents"><div class="tab-item-content" id="text-1"><div class="timeline"><div class='timeline-item headline'><div class='timeline-item-title'><div class='item-circle'><p>2022年8月学习记录 - 动态规划专练</p>
</div></div></div><div class='timeline-item'><div class='timeline-item-title'><div class='item-circle'><p>2022-12-10 文章脱敏</p>
</div></div><div class='timeline-item-content'><ol>
<li>文章脱敏：更改了部分字为错别字，用小括号扩出。</li>
</ol>
</div></div></div><button type="button" class="tab-to-top" aria-label="scroll to top"><i class="fas fa-arrow-up"></i></button></div></div></div>
<h2 id="我的资料">我的资料</h2>
<blockquote>
<p>NOI官网：<a href="https://www.noi.cn/pxsp/2020-09-15/717309.shtml">简单动态规划</a></p>
</blockquote>
<h2 id="动态规划">动态规划</h2>
<ul>
<li>阶段：据空间顺序或时间顺序对问题的求解划分阶段。</li>
<li>状态：描述事物的性质，不同事物有不同的性质，因而用不同的状态来刻画。对问题的求解状态的描述是分阶段的。</li>
<li>决策：对于一个阶段的某个状态，从该状态演变到下一阶段的某个状态的选择。</li>
<li>状态转移方程：用数学公式描述与阶段相关的状态间的演变规律。</li>
<li>最优子结构：以每一步都是最优的来保证全局是最优的。</li>
<li>无后效性：某阶段状态一旦确定。以后的决策就可以直接使用。舍弃的状态，不会在后续决策中被使用。</li>
<li>“动态”的含义：一个决策序列就是在变化的状态中产生出来的，故有“动态”的含义。</li>
</ul>
<h3 id="洛谷题单-动态规划的引入"><a href="https://www.luogu.com.cn/training/211">洛谷题单 动态规划的引入</a></h3>
<h4 id="P1216-USACO1-5-IOI1994-数字三角形-Number-Triangles"><a href="https://www.luogu.com.cn/problem/P1216">P1216 [USACO1.5][IOI1994]数字三角形 Number Triangles</a></h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><string.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> r=<span class="number">0</span>;</span><br><span class="line"> cin>>r;</span><br><span class="line"> <span class="type">int</span> map[r+<span class="number">2</span>][r+<span class="number">2</span>];</span><br><span class="line"> <span class="built_in">memset</span>(map,<span class="number">0</span>,<span class="built_in">sizeof</span>(map));</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<r;i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=<span class="number">0</span>;j<=i;j++){</span><br><span class="line"> cin>>map[i][j];</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=r<span class="number">-1</span>;i>=<span class="number">0</span>;i--){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=i;j>=<span class="number">0</span>;j--){</span><br><span class="line"> map[i][j]+=<span class="built_in">max</span>(map[i+<span class="number">1</span>][j],map[i+<span class="number">1</span>][j+<span class="number">1</span>]);</span><br><span class="line"> <span class="comment">//cout<<map[i][j]<<"(i="<<i<<",j="<<j<<") ";</span></span><br><span class="line"> }</span><br><span class="line"> <span class="comment">//cout<<endl;</span></span><br><span class="line"> }</span><br><span class="line"> cout<<map[<span class="number">0</span>][<span class="number">0</span>]<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p><img src="" alt="(单击上方的 < 展开代码)"></p>
<h4 id="P1434-SHOI2002-滑雪"><a href="https://www.luogu.com.cn/problem/P1434">P1434 [SHOI2002] 滑雪</a></h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><string.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="type">int</span> r=<span class="number">0</span>,c=<span class="number">0</span>,ans=<span class="number">0</span>;</span><br><span class="line"><span class="type">int</span> map[<span class="number">105</span>][<span class="number">105</span>],longest[<span class="number">105</span>][<span class="number">105</span>],height[<span class="number">105</span>][<span class="number">105</span>];</span><br><span class="line"><span class="type">int</span> dx[<span class="number">5</span>]={<span class="number">-1</span>,<span class="number">0</span>,<span class="number">1</span>,<span class="number">0</span>};</span><br><span class="line"><span class="type">int</span> dy[<span class="number">5</span>]={<span class="number">0</span>,<span class="number">1</span>,<span class="number">0</span>,<span class="number">-1</span>};</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">search</span><span class="params">(<span class="type">int</span> x,<span class="type">int</span> y)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(longest[x][y]<<span class="number">0</span>){</span><br><span class="line"> <span class="type">int</span> maxLength=<span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<<span class="number">4</span>;i++){</span><br><span class="line"> <span class="type">int</span> nx=x+dx[i];</span><br><span class="line"> <span class="type">int</span> ny=y+dy[i];</span><br><span class="line"> <span class="keyword">if</span>(nx>=<span class="number">0</span> && nx<=r && ny>=<span class="number">0</span> && ny<=c && map[x][y]<map[nx][ny]){</span><br><span class="line"> <span class="type">int</span> nextLength=<span class="built_in">search</span>(nx,ny);</span><br><span class="line"> <span class="keyword">if</span>(maxLength<nextLength){</span><br><span class="line"> maxLength=nextLength;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> longest[x][y]=maxLength+<span class="number">1</span>;</span><br><span class="line"> <span class="comment">//cout<<"x="<<x<<",y="<<y<<",maxLength="<<maxLength<<",longest="<<longest[x][y]<<endl;</span></span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> longest[x][y]; </span><br><span class="line">}</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="built_in">memset</span>(map,<span class="number">0</span>,<span class="built_in">sizeof</span>(map));</span><br><span class="line"> <span class="built_in">memset</span>(longest,<span class="number">-1</span>,<span class="built_in">sizeof</span>(longest));</span><br><span class="line"> <span class="built_in">memset</span>(height,<span class="number">0</span>,<span class="built_in">sizeof</span>(height));</span><br><span class="line"> cin>>r>>c;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<r;i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=<span class="number">0</span>;j<c;j++){</span><br><span class="line"> cin>>map[i][j];</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<r;i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=<span class="number">0</span>;j<c;j++){</span><br><span class="line"> <span class="comment">//cout<<search(i,j)<<"(i="<<i<<",j="<<j<<") ";</span></span><br><span class="line"> <span class="keyword">if</span>(ans<<span class="built_in">search</span>(i,j)){</span><br><span class="line"> ans=<span class="built_in">search</span>(i,j);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="comment">//cout<<endl;</span></span><br><span class="line"> }</span><br><span class="line"> cout<<ans<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p><img src="" alt="(单击上方的 < 展开代码)"></p>
<h4 id="P2196-NOIP1996-提高组-挖地-镭"><a href="https://www.luogu.com.cn/problem/P2196">P2196 [NOIP1996 提高组] 挖地(镭)</a></h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><string.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="keyword">struct</span> <span class="title class_">node</span>{</span><br><span class="line"> <span class="type">int</span> to,next;</span><br><span class="line">}edge[<span class="number">25</span>];</span><br><span class="line"><span class="type">int</span> head[<span class="number">25</span>],cnt=<span class="number">0</span>;</span><br><span class="line"><span class="function"><span class="type">void</span> <span class="title">add</span><span class="params">(<span class="type">int</span> u,<span class="type">int</span> v)</span></span>{</span><br><span class="line"> edge[++cnt].to=v;</span><br><span class="line"> edge[cnt].next=head[u];</span><br><span class="line"> head[u]=cnt;</span><br><span class="line"> <span class="keyword">return</span>;</span><br><span class="line">}</span><br><span class="line"><span class="type">int</span> dp[<span class="number">30</span>],pre[<span class="number">30</span>],s[<span class="number">30</span>];</span><br><span class="line"><span class="type">int</span> n,w[<span class="number">30</span>];</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">dfs</span><span class="params">(<span class="type">int</span> u,<span class="type">int</span> fa)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(dp[u]==<span class="number">0</span>){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=head[u];i!=<span class="number">0</span>;i=edge[i].next){</span><br><span class="line"> <span class="type">int</span> v=edge[i].to;</span><br><span class="line"> <span class="keyword">if</span>(v==fa) <span class="keyword">continue</span>;</span><br><span class="line"> dp[v]=<span class="built_in">dfs</span>(v,u);</span><br><span class="line"> <span class="keyword">if</span>(dp[u]<dp[v]){</span><br><span class="line"> dp[u]=dp[v];</span><br><span class="line"> pre[u]=v;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> dp[u]+=w[u];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> dp[u];</span><br><span class="line">}</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> n;</span><br><span class="line"> cin>>n;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++){</span><br><span class="line"> cin>>w[i];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<n;i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=i+<span class="number">1</span>;j<=n;j++){</span><br><span class="line"> <span class="type">int</span> x;</span><br><span class="line"> cin>>x;</span><br><span class="line"> <span class="keyword">if</span>(x><span class="number">0</span>) <span class="built_in">add</span>(i,j);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="type">int</span> ans=<span class="number">0</span>,k;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++){</span><br><span class="line"> <span class="built_in">memset</span>(dp,<span class="number">0</span>,<span class="built_in">sizeof</span>(dp));</span><br><span class="line"> <span class="type">int</span> tmp=<span class="built_in">dfs</span>(i,<span class="number">0</span>);</span><br><span class="line"> <span class="keyword">if</span>(ans<tmp){</span><br><span class="line"> ans=tmp;</span><br><span class="line"> <span class="built_in">swap</span>(pre,s);</span><br><span class="line"> k=i;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">while</span>(k!=<span class="number">0</span>){</span><br><span class="line"> cout<<k<<<span class="string">" "</span>;</span><br><span class="line"> k=s[k]; </span><br><span class="line"> }</span><br><span class="line"> cout<<endl<<ans<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p><img src="" alt="(单击上方的 < 展开代码)"></p>
<h4 id="P1048-NOIP2005-普及组-采药"><a href="https://www.luogu.com.cn/problem/P1048">P1048 [NOIP2005 普及组] 采药</a></h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><string.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> t,m;</span><br><span class="line"> cin>>t>>m;</span><br><span class="line"> <span class="type">int</span> dp[m+<span class="number">2</span>][t+<span class="number">2</span>],v[m+<span class="number">2</span>],w[m+<span class="number">2</span>];</span><br><span class="line"> <span class="built_in">memset</span>(dp,<span class="number">0</span>,<span class="built_in">sizeof</span>(dp));</span><br><span class="line"> <span class="built_in">memset</span>(v,<span class="number">0</span>,<span class="built_in">sizeof</span>(v));</span><br><span class="line"> <span class="built_in">memset</span>(w,<span class="number">0</span>,<span class="built_in">sTODOizeof</span>(w));</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=m;i++){</span><br><span class="line"> cin>>w[i]>>v[i];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=m;i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=t;j>=<span class="number">0</span>;j--){</span><br><span class="line"> <span class="keyword">if</span>(j>=w[i]){</span><br><span class="line"> dp[i][j]=<span class="built_in">max</span>(dp[i<span class="number">-1</span>][j-w[i]]+v[i],dp[i<span class="number">-1</span>][j]);</span><br><span class="line"> }<span class="keyword">else</span>{</span><br><span class="line"> dp[i][j]=dp[i<span class="number">-1</span>][j];</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> cout<<dp[m][t]<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p><img src="" alt="(单击上方的 < 展开代码)"></p>
<h4 id="P1616-疯狂的采药"><a href="https://www.luogu.com.cn/problem/P1616">P1616 疯狂的采药</a></h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><string.h></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">define</span> ll long long</span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> ll t=<span class="number">0</span>,m=<span class="number">0</span>;</span><br><span class="line"> cin>>t>>m;</span><br><span class="line"> ll dp[t+<span class="number">2</span>],w[m+<span class="number">2</span>],v[m+<span class="number">2</span>];</span><br><span class="line"> <span class="built_in">memset</span>(dp,<span class="number">0</span>,<span class="built_in">sizeof</span>(dp));</span><br><span class="line"> <span class="built_in">memset</span>(w,<span class="number">0</span>,<span class="built_in">sizeof</span>(w));</span><br><span class="line"> <span class="built_in">memset</span>(v,<span class="number">0</span>,<span class="built_in">sizeof</span>(v));</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=m;i++){</span><br><span class="line"> cin>>w[i]>>v[i];</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=m;i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=w[i];j<=t;j++){</span><br><span class="line"> dp[j]=<span class="built_in">max</span>(dp[j],dp[j-w[i]]+v[i]);</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> cout<<dp[t];</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p><img src="" alt="(单击上方的 < 展开代码)"></p>
<h4 id="P1802-5-倍经验日"><a href="https://www.luogu.com.cn/problem/P1802">P1802 5 倍经验日</a></h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">define</span> ll long long</span></span><br><span class="line"><span class="type">const</span> <span class="type">int</span> MAXN=<span class="number">1002</span>;</span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line">ll dp[MAXN]={<span class="number">0</span>};</span><br><span class="line"><span class="type">int</span> n=<span class="number">0</span>,x=<span class="number">0</span>;</span><br><span class="line"><span class="type">int</span> lose=<span class="number">0</span>,win=<span class="number">0</span>,use=<span class="number">0</span>;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="comment">//freopen("test/P1802_10.in","r",stdin);</span></span><br><span class="line"> cin>>n>>x;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++){</span><br><span class="line"> cin>>lose>>win>>use;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=x;j>=<span class="number">0</span>;j--){</span><br><span class="line"> <span class="keyword">if</span>(j>=use){</span><br><span class="line"> dp[j]=<span class="built_in">max</span>(dp[j]+lose,dp[j-use]+win);</span><br><span class="line"> }<span class="keyword">else</span>{</span><br><span class="line"> dp[j]+=lose;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> </span><br><span class="line"> cout<<(ll)(<span class="number">5</span>*dp[x])<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p><img src="" alt="(单击上方的 < 展开代码)"></p>
<h4 id="P1002-NOIP2002-普及组-过河卒"><a href="https://www.luogu.com.cn/problem/P1002">P1002 [NOIP2002 普及组] 过河卒</a></h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">define</span> ll long long</span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="type">const</span> <span class="type">int</span> dx[<span class="number">10</span>]={<span class="number">0</span>,<span class="number">1</span>,<span class="number">2</span>,<span class="number">2</span>,<span class="number">1</span>,<span class="number">-1</span>,<span class="number">-2</span>,<span class="number">-2</span>,<span class="number">-1</span>};</span><br><span class="line"><span class="type">const</span> <span class="type">int</span> dy[<span class="number">10</span>]={<span class="number">0</span>,<span class="number">-2</span>,<span class="number">-1</span>,<span class="number">1</span>,<span class="number">2</span>,<span class="number">2</span>,<span class="number">1</span>,<span class="number">-1</span>,<span class="number">-2</span>};</span><br><span class="line"><span class="type">int</span> bx,by,mx,my;</span><br><span class="line">ll map[<span class="number">25</span>][<span class="number">25</span>];</span><br><span class="line"><span class="type">bool</span> edge[<span class="number">25</span>][<span class="number">25</span>];</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> cin>>bx>>by>>mx>>my;</span><br><span class="line"> bx+=<span class="number">2</span>;</span><br><span class="line"> by+=<span class="number">2</span>;</span><br><span class="line"> mx+=<span class="number">2</span>;</span><br><span class="line"> my+=<span class="number">2</span>;</span><br><span class="line"> map[<span class="number">2</span>][<span class="number">1</span>]=<span class="number">1</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<<span class="number">10</span>;i++){</span><br><span class="line"> edge[mx+dx[i]][my+dy[i]]=<span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">2</span>;i<=bx;i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=<span class="number">2</span>;j<=by;j++){</span><br><span class="line"> <span class="keyword">if</span>(edge[i][j]) <span class="keyword">continue</span>;</span><br><span class="line"> map[i][j]=map[i<span class="number">-1</span>][j]+map[i][j<span class="number">-1</span>];</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<=bx;i++){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=<span class="number">0</span>;j<=by;j++){</span><br><span class="line"> <span class="comment">/*</span></span><br><span class="line"><span class="comment"> cout<<map[i][j];</span></span><br><span class="line"><span class="comment"> if(edge[i][j]){</span></span><br><span class="line"><span class="comment"> cout<<"("<<edge[i][j]<<")";</span></span><br><span class="line"><span class="comment"> }else if(i==bx&&j==by){</span></span><br><span class="line"><span class="comment"> cout<<"(0)";</span></span><br><span class="line"><span class="comment"> }else{</span></span><br><span class="line"><span class="comment"> cout<<" ";</span></span><br><span class="line"><span class="comment"> }</span></span><br><span class="line"><span class="comment"> cout<<" ";</span></span><br><span class="line"><span class="comment"> */</span></span><br><span class="line"> }</span><br><span class="line"> <span class="comment">//cout<<endl;</span></span><br><span class="line"> }</span><br><span class="line"> cout<<map[bx][by]<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p><img src="" alt="(单击上方的 < 展开代码)"></p>
<h3 id="洛谷题单-线性状态动态规划"><a href="https://www.luogu.com.cn/training/212">洛谷题单 线性状态动态规划</a></h3>
<h4 id="P1020-NOIP1999-普及组-导弹拦截"><a href="https://www.luogu.com.cn/problem/P1020">P1020 [NOIP1999 普及组] 导弹拦截</a></h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><string.h></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="type">int</span> a[<span class="number">500010</span>];</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> top=<span class="number">1</span>;</span><br><span class="line"> <span class="keyword">while</span>(cin>>a[top++]);</span><br><span class="line"> <span class="type">int</span> dp[top+<span class="number">2</span>];</span><br><span class="line"> <span class="built_in">memset</span>(dp,<span class="number">0</span>,<span class="built_in">sizeof</span>(dp));</span><br><span class="line"> top-=<span class="number">2</span>;</span><br><span class="line"> <span class="type">int</span> cnt=<span class="number">1</span>;</span><br><span class="line"> dp[<span class="number">1</span>]=a[<span class="number">1</span>];</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">2</span>;i<=top;i++){</span><br><span class="line"> <span class="keyword">if</span>(dp[cnt]>=a[i]){</span><br><span class="line"> dp[++cnt]=a[i];</span><br><span class="line"> }<span class="keyword">else</span>{</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=<span class="number">1</span>;<span class="number">1</span>;j++){</span><br><span class="line"> <span class="keyword">if</span>(dp[j]<a[i]){</span><br><span class="line"> dp[j]=a[i];</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> cout<<cnt<<endl;</span><br><span class="line"> cnt=<span class="number">1</span>;</span><br><span class="line"> dp[<span class="number">1</span>]=a[<span class="number">1</span>]; </span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">2</span>;i<=top;i++){</span><br><span class="line"> <span class="keyword">if</span>(dp[cnt]<a[i]){</span><br><span class="line"> dp[++cnt]=a[i];</span><br><span class="line"> }<span class="keyword">else</span>{</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=<span class="number">1</span>;<span class="number">1</span>;j++){</span><br><span class="line"> <span class="keyword">if</span>(dp[j]>=a[i]){</span><br><span class="line"> dp[j]=a[i];</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> } </span><br><span class="line"> }</span><br><span class="line"> cout<<cnt<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<p><img src="" alt="(单击上方的 < 展开代码)"></p>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
<tag>动态规划</tag>
<tag>DP</tag>
</tags>
</entry>
<entry>
<title>2022年8月学习记录 - 队列、栈及其应用</title>
<url>/posts/8956865/</url>
<content><![CDATA[<blockquote>
<p>其实以前学过了，但是感觉不熟悉，考前再系统学习一遍。</p>
<p>建议搭配 <a href="/posts/c728e72e/">2022年8月学习记录 - STL</a> 一起使用。</p>
</blockquote>
<h2 id="我的学习资料">我的学习资料</h2>
<blockquote>
<p>NOI官网：<a href="https://www.noi.cn/pxsp/2020-08-04/717304.shtml">队列、栈及其应用</a></p>
</blockquote>
<h2 id="队列">队列</h2>
<h3 id="队列的概念及基本术语">队列的概念及基本术语</h3>
<p>队头、队尾、入队、出队：与栈一样，队列(Queue)也是一种运算受限的特殊线性表。但它与栈“在同一端（栈顶）进进出出”不同，队列是从表的一端（队尾rear)入队，从表的另一端（队头front)出队。</p>
<p>栈让元素“先进后出”，而队列则让元素“先进先出”。假设有队列Q(al,a2,a3,…,an),则队列Q中的元素是按al,a2,a3,an的顺序依次入队，也只能按照al,a2,a3,…,an的顺序依次出队。因此，队列也被称作先进先出线性表(FIFO-First In First Out)。</p>
<p>在入队、出队的过程中，队列呈现如下几种状态：</p>
<ul>
<li>队空：队列中没有任何元素：</li>
<li>队满：队列空间已全被占用；</li>
<li>溢出：当队列己满，却还有元素要入队，就出现“上溢overflow”;</li>
<li>
<pre><code> 当队列己空，却还要做“出队”操作，就出现“下溢underflow”。
</code></pre>
</li>
<li>
<pre><code> 两种情况合在一起，统称为队列的“溢出”，也是“真溢出”。
</code></pre>
</li>
</ul>
<p>同栈的顺序存储结构一样，队列也可以用数组表示，并设置两个指针：队头指针front:和队尾指针rear。为简化操作，通常约定front指向队头元素的前一个位置，rear就指向队尾元素（也有front就指向队头元素，rear指向队尾元素的后一个位置)</p>
<h3 id="循环队列">循环队列</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">//法一</span></span><br><span class="line"><span class="keyword">if</span>(rear+<span class="number">1</span>==M) rear=<span class="number">0</span>;</span><br><span class="line"><span class="comment">//法二</span></span><br><span class="line"><span class="comment">//入队</span></span><br><span class="line">q[rear]=x;</span><br><span class="line">rear=(rear+<span class="number">1</span>)%M;</span><br><span class="line"><span class="comment">//出队</span></span><br><span class="line">x=q[front];</span><br><span class="line">front=(front+<span class="number">1</span>)%M;</span><br></pre></td></tr></table></figure>
<h2 id="栈">栈</h2>
<p>栈(stack)是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶(op),相应地，表头端称为栈底(bottom)。</p>
<ul>
<li>不含元素的空表称为空栈。</li>
</ul>
<p>栈的特征：</p>
<ul>
<li>
<p>栈中数据元素的进出</p>
</li>
<li>
<p>顺序是后进先出。(LIFO,Last In First Out)</p>
<p>(栈顶先出)</p>
</li>
</ul>
<p>栈的存储：</p>
<ul>
<li>顺序栈 -> 使用数组存储</li>
</ul>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 使用一维数组s作为栈的存储结构</span></span><br><span class="line"><span class="comment">// n是栈的最大容量，即栈中最多可存放的元素；</span></span><br><span class="line"><span class="comment">// top是栈顶指针，s[top]是栈顶元素；</span></span><br><span class="line">datatype s[n]; <span class="comment">// s[n+1]</span></span><br><span class="line"><span class="type">int</span> top;</span><br><span class="line"></span><br><span class="line"><span class="comment">// 判断栈是否为空</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">sempty</span><span class="params">(<span class="type">int</span> top)</span></span>{</span><br><span class="line"> <span class="keyword">return</span> top==<span class="number">0</span>;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 判断栈满的函数</span></span><br><span class="line"><span class="function"><span class="type">bool</span> <span class="title">sfull</span><span class="params">(<span class="type">int</span> top)</span></span>{</span><br><span class="line"> <span class="keyword">return</span> top==n;</span><br><span class="line">}</span><br><span class="line"></span><br><span class="line"><span class="comment">// 初始化栈(init)</span></span><br><span class="line">top=<span class="number">0</span>;</span><br><span class="line"><span class="comment">// 进栈(压栈,push)</span></span><br><span class="line"><span class="keyword">for</span>(!<span class="built_in">sfull</span>(top)){</span><br><span class="line"> top++;</span><br><span class="line"> s[top]=x;</span><br><span class="line">}<span class="keyword">else</span>{ <span class="comment">//上溢</span></span><br><span class="line"> cout<<<span class="string">"overflow"</span><<endl;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 出栈(退栈,pop)</span></span><br><span class="line"><span class="keyword">if</span>(!<span class="built_in">sempty</span>(top)){</span><br><span class="line"> x=s[top];</span><br><span class="line"> top--;</span><br><span class="line">}<span class="keyword">else</span>{ <span class="comment">//下溢</span></span><br><span class="line"> cout<<<span class="string">"underfloe"</span><<endl;</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 查看栈顶元素</span></span><br><span class="line"><span class="keyword">if</span>(!<span class="built_in">sempty</span>(top)){</span><br><span class="line"> x=s[top];</span><br><span class="line">}<span class="keyword">else</span>{ <span class="comment">//下溢</span></span><br><span class="line"> cout<<<span class="string">"underfloe"</span><<endl;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<ul>
<li>链式栈</li>
</ul>
<h2 id="洛谷题单-队列、栈及其应用"><a href="https://www.luogu.com.cn/training/211872">洛谷题单 队列、栈及其应用</a></h2>
<h3 id="U268237-周末舞会"><a href="https://www.luogu.com.cn/problem/U268237">U268237 周末舞会</a></h3>
<ul>
<li>法一：循环队列</li>
</ul>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> m=<span class="number">0</span>,n=<span class="number">0</span>,k=<span class="number">0</span>;</span><br><span class="line"> cin>>m>>n>>k; </span><br><span class="line"> <span class="type">int</span> a[m+<span class="number">2</span>],b[n+<span class="number">2</span>];</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=m;i++) a[i]=i;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++) b[i]=i;</span><br><span class="line"> <span class="type">int</span> f1=<span class="number">1</span>,r1=m,f2=<span class="number">1</span>,r2=n;</span><br><span class="line"> <span class="keyword">while</span>(k><span class="number">0</span>){</span><br><span class="line"> cout<<a[f1]<<<span class="string">" "</span><<b[f2]<<endl;</span><br><span class="line"> r1++; a[r1]=a[f1]; f1++;</span><br><span class="line"> r2++; b[r2]=b[f2]; f2++;</span><br><span class="line"> k--;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<ul>
<li>法二：暴力枚举</li>
</ul>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> n,m,k;</span><br><span class="line"> cin>>n>>m>>k;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<k;i++){</span><br><span class="line"> cout<<(i%n+<span class="number">1</span>)<<<span class="string">" "</span><<(i%m+<span class="number">1</span>)<<endl;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="U267778-纸牌问题"><a href="https://www.luogu.com.cn/problem/U267778">U267778 纸牌问题</a></h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span> <span class="string"><iostream></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="type">int</span> a[<span class="number">10000010</span>];</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> n=<span class="number">0</span>; </span><br><span class="line"> cin>>n;</span><br><span class="line"> <span class="keyword">if</span>(n<<span class="number">1</span>||n><span class="number">10000000</span>){</span><br><span class="line"> cout<<<span class="number">-1</span><<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<n;i++){</span><br><span class="line"> a[i]=i+<span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="type">int</span> front=<span class="number">0</span>,rear=n;</span><br><span class="line"> <span class="keyword">while</span>(front!=rear){</span><br><span class="line"> <span class="comment">//cout<<a[front]<<" "; </span></span><br><span class="line"> front=(front+<span class="number">1</span>)%(n+<span class="number">1</span>);</span><br><span class="line"> a[rear]=a[front];</span><br><span class="line"> front=(front+<span class="number">1</span>)%(n+<span class="number">1</span>);</span><br><span class="line"> rear=(rear+<span class="number">1</span>)%(n+<span class="number">1</span>);</span><br><span class="line"> }</span><br><span class="line"> cout<<a[(front<span class="number">-2</span>)%(n+<span class="number">1</span>)]<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="U267779-取牌游戏"><a href="https://www.luogu.com.cn/problem/U267779">U267779 取牌游戏</a></h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="type">const</span> <span class="type">int</span> MAXN = <span class="number">100010</span>;</span><br><span class="line"><span class="type">int</span> a[MAXN];</span><br><span class="line"><span class="type">int</span> result[MAXN];</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{ </span><br><span class="line"> <span class="type">int</span> K=<span class="number">0</span>, N=<span class="number">0</span>, P=<span class="number">0</span>;</span><br><span class="line"> cin >> N >> K >> P;</span><br><span class="line"> <span class="keyword">if</span>(P<<span class="number">1</span> || P><span class="number">10</span> || N<<span class="number">2</span> || N><span class="number">100</span> || K<N || K> <span class="number">100000</span>){</span><br><span class="line"> cout<<<span class="number">-1</span><<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="type">int</span> front = <span class="number">1</span>,rear = K;</span><br><span class="line"> <span class="keyword">for</span> (<span class="type">int</span> i = <span class="number">1</span>; i <= K; i++) a[i] = i;</span><br><span class="line"> <span class="type">int</span> x = <span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="type">int</span> i = <span class="number">1</span>; i <= K; i++){</span><br><span class="line"> x++;</span><br><span class="line"> <span class="keyword">if</span> (x % N == <span class="number">0</span>) result[a[front]] = a[front];</span><br><span class="line"> a[front] = <span class="literal">NULL</span>;</span><br><span class="line"> front = (front + <span class="number">1</span>) % MAXN;</span><br><span class="line"> <span class="keyword">if</span> (front == rear + <span class="number">1</span>)<span class="keyword">break</span>;</span><br><span class="line"> <span class="keyword">for</span> (<span class="type">int</span> j = <span class="number">1</span>; j <= P; j++){</span><br><span class="line"> rear = (rear + <span class="number">1</span>) % MAXN;</span><br><span class="line"> a[rear] = a[front];</span><br><span class="line"> a[front] = <span class="literal">NULL</span>;</span><br><span class="line"> front = (front + <span class="number">1</span>) % MAXN;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span> (<span class="type">int</span> i = <span class="number">1</span>; i <= K; i++) {</span><br><span class="line"> <span class="keyword">if</span>(result[i]) cout<<result[i]<<endl;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="U267780-魔法师与扑克牌游戏"><a href="https://www.luogu.com.cn/problem/U267780">U267780 魔法师与扑克牌游戏</a></h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> n=<span class="number">0</span>,j=<span class="number">1</span>;</span><br><span class="line"> cin>>n;</span><br><span class="line"> <span class="keyword">if</span>(n<=<span class="number">0</span>){</span><br><span class="line"> cout<<<span class="number">-1</span><<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="type">int</span> a[n+<span class="number">2</span>]={<span class="number">0</span>,<span class="number">1</span>};</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">2</span>;i<=n;i++){</span><br><span class="line"> <span class="type">int</span> p=i;</span><br><span class="line"> <span class="keyword">if</span>(i>n/<span class="number">2</span>&&i<n)p=(i+<span class="number">1</span>)%(n-i+<span class="number">1</span>)<span class="number">-1</span>;</span><br><span class="line"> <span class="keyword">if</span>(p!=<span class="number">-1</span>)<span class="keyword">for</span>(<span class="type">int</span> k=<span class="number">0</span>;k<=p;k++){</span><br><span class="line"> <span class="keyword">do</span>{</span><br><span class="line"> j++;</span><br><span class="line"> <span class="keyword">if</span>(j>n)j=<span class="number">1</span>;</span><br><span class="line"> }<span class="keyword">while</span>(a[j]!=<span class="number">0</span>);</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">if</span>(p==<span class="number">-1</span>){</span><br><span class="line"> <span class="keyword">do</span>{</span><br><span class="line"> j--;</span><br><span class="line"> <span class="keyword">if</span>(j<<span class="number">1</span>)j=n;</span><br><span class="line"> }<span class="keyword">while</span>(a[j]!=<span class="number">0</span>);</span><br><span class="line"> }</span><br><span class="line"> a[j]=i;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++)<span class="built_in">printf</span>(<span class="string">"%d "</span>,a[i]);</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">} </span><br></pre></td></tr></table></figure>
<h3 id="U267781-程序输入问题"><a href="https://www.luogu.com.cn/problem/U267781">U267781 程序输入问题</a></h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> std;</span><br><span class="line"><span class="type">int</span> m=<span class="number">0</span>,n=<span class="number">0</span>,top=<span class="number">0</span>;</span><br><span class="line"><span class="type">char</span> s[<span class="number">1002</span>];</span><br><span class="line">string str=<span class="string">""</span>;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="keyword">while</span>(<span class="built_in">getline</span>(cin,str)){</span><br><span class="line"> top=<span class="number">0</span>;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">0</span>;i<str.<span class="built_in">size</span>();i++){</span><br><span class="line"> <span class="keyword">switch</span>(str[i]){</span><br><span class="line"> <span class="keyword">case</span> <span class="string">'#'</span>:{</span><br><span class="line"> <span class="keyword">if</span>(top==<span class="number">0</span>){</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> top--;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">case</span> <span class="string">'@'</span>:{</span><br><span class="line"> top=<span class="number">0</span>;</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">default</span>:{</span><br><span class="line"> top++;</span><br><span class="line"> s[top]=str[i];</span><br><span class="line"> <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=top;i++){</span><br><span class="line"> cout<<s[i];</span><br><span class="line"> }</span><br><span class="line"> cout<<endl;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">} </span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
<tag>队列</tag>
<tag>栈</tag>
</tags>
</entry>
<entry>
<title>2022年8月学习记录</title>
<url>/posts/c728e72e/</url>
<content><![CDATA[<div class="tabs" id="text"><ul class="nav-tabs"><li class="tab"><button type="button" data-href="#text-1">更新记录</button></li></ul><div class="tab-contents"><div class="tab-item-content" id="text-1"><div class="timeline"><div class='timeline-item headline'><div class='timeline-item-title'><div class='item-circle'><p>2022年8月学习记录</p>
</div></div></div><div class='timeline-item'><div class='timeline-item-title'><div class='item-circle'><p>2022-12-15 链接修复</p>
</div></div><div class='timeline-item-content'><ol>
<li>链接修复：文章跳转链接修复</li>
</ol>
</div></div></div><button type="button" class="tab-to-top" aria-label="scroll to top"><i class="fas fa-arrow-up"></i></button></div></div></div>
<h2 id="算法">算法</h2>
<h3 id="倍增">倍增</h3>
<h4 id="快速幂">快速幂</h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 计算 a^b%p</span></span><br><span class="line"><span class="meta">#<span class="keyword">include</span><span class="string"><iostream></span></span></span><br><span class="line"><span class="meta">#<span class="keyword">define</span> ll long long</span></span><br><span class="line"><span class="keyword">using</span> namesapce std;</span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">main</span><span class="params">()</span></span>{</span><br><span class="line"> <span class="type">int</span> a,b,p,ans=<span class="number">1</span>;</span><br><span class="line"> cin>>a>>b>>p;</span><br><span class="line"> <span class="keyword">while</span>(b){</span><br><span class="line"> <span class="keyword">if</span>(b&<span class="number">1</span>) ans=(ll)ans*a%p;</span><br><span class="line"> a=(ll)a*a%p;</span><br><span class="line"> b>>=<span class="number">1</span>;</span><br><span class="line"> }</span><br><span class="line"> cout<<ans%p<<endl;</span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h4 id="快速乘">快速乘</h4>
<h4 id="矩阵快速幂">矩阵快速幂</h4>
<h4 id="RMQ问题">RMQ问题</h4>
<p>RMQ问题是一个(一组？)经典的可以用倍增来解决的问题</p>
<h5 id="ST表">ST表</h5>
<p>给定一个长度为n的序列A[1···n]，有q次询问，每次询问给出x，y，回答A[x···y]中的最大值。（也可以是最小值，此处以最大值为例）通常n,q<=100000）</p>
<p>利用倍增解决RMQ问题的算法：ST（Sparse Table）算法</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 生成ST表</span></span><br><span class="line"><span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i<=n;i++)st[i][<span class="number">0</span>]=A[i];</span><br><span class="line"><span class="keyword">for</span>(<span class="type">int</span> j=<span class="number">1</span>;(<span class="number">1</span><<j)<=n;j++)</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">1</span>;i+(<span class="number">1</span><<j)<span class="number">-1</span><=n;i++)</span><br><span class="line"> st[i][j]=<span class="built_in">max</span>(st[i][j<span class="number">-1</span>],st[i+(<span class="number">1</span><<j<span class="number">-1</span>)][j<span class="number">-1</span>]);</span><br></pre></td></tr></table></figure>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 计算A[x···y]中的最大值 O(1)</span></span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">query</span><span class="params">(<span class="type">int</span> x,<span class="type">int</span> y)</span></span>{</span><br><span class="line"> <span class="type">int</span> k=(<span class="type">int</span>)(<span class="built_in">log</span>(y-x+<span class="number">1</span>)/<span class="built_in">log</span>(<span class="number">2</span>));</span><br><span class="line"> <span class="type">int</span> m=<span class="built_in">max</span>(st[x][k]，st[y—(<span class="number">1</span><<k)+<span class="number">1</span>][k]);</span><br><span class="line"> <span class="keyword">return</span> m; </span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h5 id="树上最近公共祖先">树上最近公共祖先</h5>
<p>树上最近公共祖先，简称LCA，是关于树的一个非常基础的概念：<br>
给定一棵有根树，一个点到根节点的路径上的所有点称为该点的祖先若点u同时是点x，y的祖先，那么u称为x，y的公共祖先。的所有公共祖先中，深度最大的点称为x，y的最近公共祖先。<br>
另一种理解：x到y的路径上深度最小的点为x，y的最近公共祖先。</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// O(logn)</span></span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">LCA</span><span class="params">(<span class="type">int</span> x,<span class="type">int</span> y)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(d[x]<d[y]) <span class="built_in">swap</span>(x,y);</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">16</span>;i>=<span class="number">0</span>;i--)</span><br><span class="line"> <span class="keyword">if</span>(d[f[x][i]]>=d[y])</span><br><span class="line"> x=f[x][i];</span><br><span class="line"> <span class="keyword">if</span>(x==y) <span class="keyword">return</span> x;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i=<span class="number">16</span>;i>=<span class="number">0</span>;i--)</span><br><span class="line"> <span class="keyword">if</span>(f[x][i]!=f[y][i])</span><br><span class="line"> x=f[x][i],y=f[y][i];</span><br><span class="line"> <span class="keyword">return</span> f[x][<span class="number">0</span>];</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="简单数论">简单数论</h3>
<h4 id="欧几里得算法">欧几里得算法</h4>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// O(loga)</span></span><br><span class="line"></span><br><span class="line"><span class="comment">// 递归法</span></span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">gcd</span><span class="params">(<span class="type">int</span> a,<span class="type">int</span> b)</span></span>{</span><br><span class="line"> <span class="keyword">if</span> (b==<span class="number">0</span>) <span class="keyword">return</span> a;</span><br><span class="line"> <span class="keyword">return</span> <span class="built_in">gcd</span>(b,a%b);</span><br><span class="line">}</span><br><span class="line"><span class="comment">// 迭代法</span></span><br><span class="line"><span class="function"><span class="type">int</span> <span class="title">gcd</span><span class="params">(<span class="type">int</span> a,<span class="type">int</span> b)</span></span>{</span><br><span class="line"> <span class="keyword">while</span>(b!=<span class="number">0</span>){</span><br><span class="line"> <span class="type">int</span> t=a%b;</span><br><span class="line"> a=b;</span><br><span class="line"> b=t;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> a;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h5 id="拓展欧几里得">拓展欧几里得</h5>
<p>对于给定的两个整数a和b，必存在整数x和y，使得 a<em>x+b</em>y=gcd(a,b)</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 计算 a*x+b*y=gcd(a,b) 的特解</span></span><br><span class="line"><span class="function"><span class="type">void</span> <span class="title">Extended_Gcd</span><span class="params">(<span class="type">int</span> a,<span class="type">int</span> b,<span class="type">int</span> &d,<span class="type">int</span> &x,<span class="type">int</span> &y)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(<span class="number">0</span>==b){</span><br><span class="line"> d=a;</span><br><span class="line"> x=c/a;</span><br><span class="line"> y=<span class="number">0</span>;</span><br><span class="line"> }<span class="keyword">else</span>{</span><br><span class="line"> <span class="type">int</span> x1,y1;</span><br><span class="line"> <span class="built_in">Extened_God</span>(b,a,d,x1,x2);</span><br><span class="line"> x=y1;</span><br><span class="line"> y=x1-a/b*y1;</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h5 id="裴蜀定理">裴蜀定理</h5>
<p>方程 a<em>x+b</em>y=c 有整数解的充分必要条件是 c 是 gcd(a,c) 的倍数</p>
<h4 id="素数">素数</h4>
<p>输入N（N<=5*10^7）,输出1到N之间的所有素数。</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// O(nlnlnn)</span></span><br><span class="line"><span class="function"><span class="type">void</span> <span class="title">sieve</span><span class="params">(<span class="type">int</span> n)</span></span>{</span><br><span class="line"> <span class="built_in">memset</span>(isPrime,<span class="literal">true</span>,<span class="built_in">sizeof</span>(isPrime)); <span class="comment">//#include<string.h></span></span><br><span class="line"> <span class="keyword">for</span>{<span class="type">int</span> i=<span class="number">2</span>;i*i<n;i++}{</span><br><span class="line"> <span class="keyword">if</span>(isPrime[i]){</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=i*i;i<=n;i+=i){</span><br><span class="line"> isPrime[j]=<span class="literal">false</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h5 id="欧拉筛">欧拉筛</h5>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// O(n)</span></span><br><span class="line"><span class="function"><span class="type">void</span> <span class="title">Euler_sieve</span><span class="params">(<span class="type">int</span> n)</span></span>{</span><br><span class="line"> <span class="built_in">memset</span>(isPrime,<span class="literal">true</span>,<span class="built_in">sizeof</span>(isPrime)); <span class="comment">//#include<string.h></span></span><br><span class="line"> <span class="keyword">for</span>{<span class="type">int</span> i=<span class="number">2</span>;i<=n;i++}{</span><br><span class="line"> <span class="keyword">if</span>(isPrime[i]) prime[++prime[<span class="number">0</span>]]=i;</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> j=<span class="number">1</span>;i<=prime[<span class="number">0</span>] && i*prime[j]<=n;j++){</span><br><span class="line"> isPrime[i*prime[<span class="number">0</span>]]=<span class="literal">false</span>;</span><br><span class="line"> <span class="keyword">if</span>(<span class="number">0</span>==i%prinme[j]) <span class="keyword">break</span>;</span><br><span class="line"> }</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="动态规划">动态规划</h3>
<blockquote>
<p><a href="/posts/86fa511b/">2022年8月学习记录 - 动态规划专练</a></p>
</blockquote>
<h2 id="解题公式">解题公式</h2>
<h3 id="巧用位移解题">巧用位移解题</h3>
<ul>
<li>2的n次幂 ===> (1<<n）</li>
<li>n/2 ===> (n>>1)</li>
</ul>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
</tags>
</entry>
<entry>
<title>2022年9月学习记录 - 时间复杂度题目训练</title>
<url>/posts/bfc79706/</url>
<content><![CDATA[<blockquote>
<p>早在今年四月份的时候我就已经学习过时间复杂度了,但当时只是了解了以下，知道了这是什么东西，现在在做题时发现其实根本不会做题，所以现在来还债了。</p>
</blockquote>
<h2 id="我的学习资料">我的学习资料</h2>
<blockquote>
<p>CSDN：<a href="https://blog.csdn.net/K_Xin/article/details/108914891">王道数据结构选择题汇总</a></p>
<p>BiliBili：<a href="https://www.bilibili.com/video/BV1HT411A766">时间复杂度之2023王道课后题</a> (注：你完全可以在了解定义后看这个视频来学习时间复杂度)</p>
<p>(B站上找了一圈，发现这个视频时讲得最好的，除了声音有点小外没有其他缺点)</p>
</blockquote>
<h2 id="规则">规则</h2>
<p>加法规则：</p>
<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>T</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><msub><mi>T</mi><mn>1</mn></msub><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>+</mo><msub><mi>T</mi><mn>2</mn></msub><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo stretchy="false">)</mo><mo>+</mo><mi>O</mi><mo stretchy="false">(</mo><mi>g</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo stretchy="false">)</mo><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><mi>m</mi><mi>a</mi><mi>x</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo separator="true">,</mo><mi>g</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo stretchy="false">)</mo><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">T(n)=T_{1}(n)+T_{2}(n)=O(f(n))+O(g(n))=O(max( f(n),g(n) ) )
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.10764em;">f</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">))</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">))</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathnormal">ma</span><span class="mord mathnormal">x</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.10764em;">f</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)))</span></span></span></span></span></p>
<p>乘法规则：</p>
<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>T</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><msub><mi>T</mi><mn>1</mn></msub><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>×</mo><msub><mi>T</mi><mn>2</mn></msub><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo stretchy="false">)</mo><mo>×</mo><mi>O</mi><mo stretchy="false">(</mo><mi>g</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo stretchy="false">)</mo><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>×</mo><mi>g</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">T(n)=T_{1}(n)×T_{2}(n)=O(f(n))×O(g(n))=O(f(n)×g(n))
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">×</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.10764em;">f</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">))</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">×</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">))</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.10764em;">f</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">×</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">))</span></span></span></span></span></p>
<h2 id="常用级数">常用级数</h2>
<p>收敛级数：</p>
<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>T</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><mn>1</mn><mo>+</mo><mfrac><mn>1</mn><msup><mn>2</mn><mn>2</mn></msup></mfrac><mo>+</mo><mfrac><mn>1</mn><msup><mn>3</mn><mn>2</mn></msup></mfrac><mo>+</mo><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mo>+</mo><mfrac><mn>1</mn><msup><mi>n</mi><mn>2</mn></msup></mfrac><mo><</mo><mn>1</mn><mo>+</mo><mfrac><mn>1</mn><msup><mn>2</mn><mn>2</mn></msup></mfrac><mo>+</mo><mfrac><mn>1</mn><msup><mn>3</mn><mn>2</mn></msup></mfrac><mo>+</mo><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mo>=</mo><mfrac><msup><mi>π</mi><mn>2</mn></msup><mn>6</mn></mfrac><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">T(n) = 1+\frac{1}{2^2}+\frac{1}{3^2}+...+\frac{1}{n^2} < 1 +\frac{1}{2^2}+\frac{1}{3^2}+... = \frac{π^2}{6} = O(1)
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.0074em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3214em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7401em;"><span style="top:-2.989em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.0074em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3214em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord">3</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7401em;"><span style="top:-2.989em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord">...</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.0074em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3214em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7401em;"><span style="top:-2.989em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel"><</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.0074em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3214em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7401em;"><span style="top:-2.989em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.0074em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3214em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord">3</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7401em;"><span style="top:-2.989em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.3669em;"></span><span class="mord">...</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.1771em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.4911em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">6</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">π</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord">1</span><span class="mclose">)</span></span></span></span></span></p>
<p>调和级数：</p>
<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>T</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><mn>1</mn><mo>+</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo>+</mo><mfrac><mn>1</mn><mn>3</mn></mfrac><mo>+</mo><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mo>+</mo><mfrac><mn>1</mn><mi>n</mi></mfrac><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><mi>l</mi><mi>o</mi><mi>g</mi><mi>n</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">T(n) = 1+\frac{1}{2}+\frac{1}{3}+...+\frac{1}{n} = O(logn)
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.0074em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3214em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">2</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.0074em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3214em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">3</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord">...</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.0074em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3214em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">n</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">o</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord mathnormal">n</span><span class="mclose">)</span></span></span></span></span></p>
<p>对数级数：</p>
<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>T</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><mi>l</mi><mi>o</mi><mi>g</mi><mn>1</mn><mo>+</mo><mi>l</mi><mi>o</mi><mi>g</mi><mn>2</mn><mo>+</mo><mi>l</mi><mi>o</mi><mi>g</mi><mn>3</mn><mo>+</mo><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mo>+</mo><mi>l</mi><mi>o</mi><mi>g</mi><mi>n</mi><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><mi>n</mi><mi>l</mi><mi>o</mi><mi>g</mi><mi>n</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">T(n) = log1 + log2 + log3 +...+logn = O(nlogn)
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">o</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">o</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">o</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord">3</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord">...</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">o</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">o</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord mathnormal">n</span><span class="mclose">)</span></span></span></span></span></p>
<p>算术级数：</p>
<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>T</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><mn>1</mn><mo>+</mo><mn>2</mn><mo>+</mo><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mo>+</mo><mi>n</mi><mo>=</mo><mfrac><mrow><mi>n</mi><mo stretchy="false">(</mo><mi>n</mi><mo>+</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><mn>2</mn></mfrac><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><msup><mi>n</mi><mn>2</mn></msup><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">T(n) = 1 + 2 + ... + n = \frac{n(n+1)}{2} = O(n^2)
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord">...</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.113em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.427em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">2</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">n</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.1141em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span></span></p>
<p>幂方级数：</p>
<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>T</mi><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><msup><mn>1</mn><mn>2</mn></msup><mo>+</mo><msup><mn>2</mn><mn>2</mn></msup><mo>+</mo><msup><mn>3</mn><mn>2</mn></msup><mo>+</mo><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mo>+</mo><msup><mi>n</mi><mn>2</mn></msup><mo>=</mo><munderover><mo>∑</mo><mrow><mi>k</mi><mo>=</mo><mn>0</mn></mrow><mi>n</mi></munderover><msup><mi>k</mi><mn>2</mn></msup><mo>≈</mo><msubsup><mo>∫</mo><mn>0</mn><mi>n</mi></msubsup><msup><mi>x</mi><mn>2</mn></msup><mi>d</mi><mi>x</mi><mo>=</mo><mfrac><mn>1</mn><mn>3</mn></mfrac><msup><mi>n</mi><mn>3</mn></msup><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><msup><mi>n</mi><mn>3</mn></msup><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">T(n) = 1^2+2^2+3^2+...+n^2 = \sum_{k=0}^{n}k^2≈\int_{0}^{n}x^{2}dx=\frac{1}{3}n^{3}=O(n^{3})
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.9474em;vertical-align:-0.0833em;"></span><span class="mord"><span class="mord">1</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.9474em;vertical-align:-0.0833em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.9474em;vertical-align:-0.0833em;"></span><span class="mord"><span class="mord">3</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord">...</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8641em;"></span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.9535em;vertical-align:-1.3021em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.6514em;"><span style="top:-1.8479em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span><span class="mrel mtight">=</span><span class="mord mtight">0</span></span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span><span style="top:-4.3em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:1.3021em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">≈</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.3262em;vertical-align:-0.9119em;"></span><span class="mop"><span class="mop op-symbol large-op" style="margin-right:0.44445em;position:relative;top:-0.0011em;">∫</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.4143em;"><span style="top:-1.7881em;margin-left:-0.4445em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">0</span></span></span></span><span style="top:-3.8129em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.9119em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span><span class="mord mathnormal">d</span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.0074em;vertical-align:-0.686em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3214em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">3</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">3</span></span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.1141em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">3</span></span></span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span></span></p>
<p>几何级数：</p>
<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msub><mi>T</mi><mn>2</mn></msub><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo>=</mo><mn>1</mn><mo>+</mo><mn>2</mn><mo>+</mo><mn>4</mn><mo>+</mo><mn>8</mn><mo>+</mo><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mi mathvariant="normal">.</mi><mo>+</mo><msup><mn>2</mn><mi>n</mi></msup><mo>=</mo><munderover><mo>∑</mo><mrow><mi>k</mi><mo>=</mo><mn>0</mn></mrow><mi>n</mi></munderover><msup><mn>2</mn><mi>k</mi></msup><mo>=</mo><msup><mn>2</mn><mrow><mi>n</mi><mo>+</mo><mn>1</mn></mrow></msup><mo>−</mo><mn>1</mn><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><msup><mn>2</mn><mrow><mi>n</mi><mo>+</mo><mn>1</mn></mrow></msup><mo stretchy="false">)</mo><mo>=</mo><mi>O</mi><mo stretchy="false">(</mo><msup><mn>2</mn><mi>n</mi></msup><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">T_{2}(n) = 1+ 2 + 4+ 8+...+2^n =\sum_{k=0}^{n}2^k = 2^{n+1}-1 =O(2^{n+1})=O(2^n)
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">4</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">8</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord">...</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.7144em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7144em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.9535em;vertical-align:-1.3021em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.6514em;"><span style="top:-1.8479em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span><span class="mrel mtight">=</span><span class="mord mtight">0</span></span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span><span style="top:-4.3em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:1.3021em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8991em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.9474em;vertical-align:-0.0833em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.1141em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span></span></span></span></span></span></span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.02778em;">O</span><span class="mopen">(</span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7144em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span></span></p>
<h2 id="迭代程序">迭代程序</h2>
<p>迭代程序通常使用 <code>while</code> 循环或 <code>for</code> 循环表示，两者可以等价互换，而 <code>for</code> 循环便于计算时间复杂度，所以遇到 <code>while</code> 循环时统一转换为 <code>for</code> 循环以计算。</p>
<h2 id="递归程序">递归程序</h2>
<blockquote>
<p><strong>递归方程：</strong> 递归关系简单的方程，可借助递推关系归纳出 T(n)与T(n – 1)等的关系，不断用递推方程的右部替换左部，直至 T(1)</p>
</blockquote>
]]></content>
<categories>
<category>C++</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>时间复杂度</tag>
</tags>
</entry>
<entry>
<title>2023年学习记录 - 二叉树的性质和储存结构</title>
<url>/posts/sdb8uh4b/</url>
<content><![CDATA[<h2 id="声明">声明</h2>
<blockquote>
<p>本节内容来源于 BiliBili视频<a href="https://www.bilibili.com/video/BV1nJ411V7bd">数据结构与算法基础（青岛大学-王卓）</a> 的 P81 - P85，本博客仅作笔记整理和学习记录，部分图片来自视频截图。</p>
</blockquote>
<style>.bbplayer{width: 100%; max-width: 850px; margin: auto}</style><div class="bbplayer"><iframe class="bbplayer" id="mmedia-gGYByNVJRPGlPwFa" src="https://player.bilibili.com/player.html?bvid=BV1nJ411V7bd&page=81&high_quality=1&danmaku=true&autoplay=0" allowfullscreen="allowfullscreen" scrolling="no" border="0" frameborder="0" framespacing="0" sandbox="allow-top-navigation allow-same-origin allow-forms allow-scripts allow-popups"></iframe></div><script> document.getElementById("mmedia-gGYByNVJRPGlPwFa").style.height=document.getElementById("mmedia-gGYByNVJRPGlPwFa").scrollWidth*0.76+"px";
window.onresize = function(){
document.getElementById("mmedia-gGYByNVJRPGlPwFa").style.height=document.getElementById("mmedia-gGYByNVJRPGlPwFa").scrollWidth*0.76+"px";
}; </script>
<h2 id="二叉树的性质">二叉树的性质</h2>
<ol>
<li>在二叉树的第 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span> 层上至多有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mrow><mi>i</mi><mo>−</mo><mn>1</mn></mrow></msup></mrow><annotation encoding="application/x-tex">2^{i-1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8247em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8247em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span></span></span></span></span></span></span></span> 个结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>i</mi><mo>≥</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(i \geq 1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span>。（证明：<a href="https://www.bilibili.com/video/BV1nJ411V7bd/?p=81&share_source=copy_web&vd_source=af489a7bf5a65f9820f5ae199365145d&t=95">归纳法</a>）</li>
<li>深度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span> 的二叉树至多有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mi>k</mi></msup><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">2^k-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.9324em;vertical-align:-0.0833em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8491em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> 个结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>k</mi><mo>≥</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(k \geq 1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">≥</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span>。（证明：<a href="https://www.bilibili.com/video/BV1nJ411V7bd/?p=81&share_source=copy_web&vd_source=af489a7bf5a65f9820f5ae199365145d&t=416">性质1求和</a>）</li>
<li>对任何一棵二叉树 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>T</mi></mrow><annotation encoding="application/x-tex">T</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span></span></span></span>，如果其叶子数为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>n</mi><mn>0</mn></msub></mrow><annotation encoding="application/x-tex">n_0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> ，度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn></mrow><annotation encoding="application/x-tex">2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span></span></span></span> 的结点数为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>n</mi><mn>2</mn></msub></mrow><annotation encoding="application/x-tex">n_2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> ，则 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>n</mi><mn>0</mn></msub><mo>=</mo><msub><mi>n</mi><mn>2</mn></msub><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">n_0=n_2+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">n</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>。（证明：<a href="https://www.bilibili.com/video/BV1nJ411V7bd/?p=81&share_source=copy_web&vd_source=af489a7bf5a65f9820f5ae199365145d&t=677">边数证明</a>）</li>
<li>具有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span> 个结点的完全二叉树的深度为<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo stretchy="false">⌊</mo><mi>l</mi><mi>o</mi><msub><mi>g</mi><mn>2</mn></msub><mo stretchy="false">(</mo><mi>n</mi><mo stretchy="false">)</mo><mo stretchy="false">⌋</mo><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\lfloor log_2(n) \rfloor + 1
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">⌊</span><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="mord mathnormal">o</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mclose">)⌋</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span></span></p>
（证明：<a href="https://www.bilibili.com/video/BV1nJ411V7bd/?p=83&share_source=copy_web&vd_source=af489a7bf5a65f9820f5ae199365145d&t=172">n与k的关系</a>）</li>
<li>如果对一棵有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span> 个结点的完全二叉树的结点按层编号（从第 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> 层到第最后一层，每层从左到右），则对任一结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo stretchy="false">(</mo><mn>1</mn><mo>≤</mo><mi>i</mi><mo>≤</mo><mi>n</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">i(1 \leq i \leq n)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">i</span><span class="mopen">(</span><span class="mord">1</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7955em;vertical-align:-0.136em;"></span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">n</span><span class="mclose">)</span></span></span></span> ：
<ul>
<li>如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">i=1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>，则结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span> 是二叉树的根，无双亲；如果 $i > 1 $ ，则其双亲是结点：</li>
</ul>
<p><span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo stretchy="false">⌊</mo><mi>i</mi><mi mathvariant="normal">/</mi><mn>2</mn><mo stretchy="false">⌋</mo></mrow><annotation encoding="application/x-tex">\lfloor i / 2 \rfloor
</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">⌊</span><span class="mord mathnormal">i</span><span class="mord">/2</span><span class="mclose">⌋</span></span></span></span></span></p>
<ul>
<li>如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mi>i</mi><mo>></mo><mi>n</mi></mrow><annotation encoding="application/x-tex">2i>n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6986em;vertical-align:-0.0391em;"></span><span class="mord">2</span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span>，则结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span> 为叶子节点，无左孩子；否则其左孩子是结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mi>i</mi></mrow><annotation encoding="application/x-tex">2i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord">2</span><span class="mord mathnormal">i</span></span></span></span>。</li>
<li>如果 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mi>i</mi><mo>+</mo><mn>1</mn><mo>></mo><mi>n</mi></mrow><annotation encoding="application/x-tex">2i+1>n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7429em;vertical-align:-0.0833em;"></span><span class="mord">2</span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6835em;vertical-align:-0.0391em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span>，则结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span> 无右孩子；否则，其右孩子是结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mi>i</mi><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">2i+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7429em;vertical-align:-0.0833em;"></span><span class="mord">2</span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>。<br>
（证明思路：<a href="https://www.bilibili.com/video/BV1nJ411V7bd/?p=83&share_source=copy_web&vd_source=af489a7bf5a65f9820f5ae199365145d&t=444">归纳法</a>）</li>
</ul>
</li>
</ol>
<h3 id="满二叉树">满二叉树</h3>
<p>定义：一颗深度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span> 且有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mi>k</mi></msup><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">2^k-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.9324em;vertical-align:-0.0833em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8491em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> 个结点的二叉树称为满二叉树。</p>
<p>特点：</p>
<ol>
<li>每一层上的结点数都是最大结点数（即每层都满）。</li>
<li>叶子结点全部在最底层。</li>
<li>满二叉树在同样深度的二叉树中结点、叶子节点个数最多。</li>
</ol>
<p>编号规则：自上而下，自左而右。</p>
<h3 id="完全二叉树">完全二叉树</h3>
<p>深度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span> 的具有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span> 个结点的二叉树，当且仅当其中每一个结点都与深度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span> 的满二叉树中编号为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mtext> </mtext><mi>n</mi></mrow><annotation encoding="application/x-tex">1~n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span><span class="mspace nobreak"> </span><span class="mord mathnormal">n</span></span></span></span> 的结点一一对应时，称之为完全二叉树。</p>
<p><img src="/assets/image/posts/sdb8uh4b/%E6%BB%A1%E4%BA%8C%E5%8F%89%E6%A0%91%E5%92%8C%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91.png" alt="满二叉树和完全二叉树"></p>
<p>在满二叉树中，从最后一个结点开始，连续去掉任意个结点，即是一颗完全二叉树。</p>
<p>特点：</p>
<ol>
<li>叶子只可能扽不在层次最大的两层上。</li>
<li>对任一结点。如果其右子树的最大层次为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>，则其左子树的最大层次必为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span> 或 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">i+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7429em;vertical-align:-0.0833em;"></span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>。</li>
</ol>
<h2 id="二叉树的存储结构">二叉树的存储结构</h2>
<h3 id="二叉树的顺序存储存储">二叉树的顺序存储存储</h3>
<p>实现：按满二叉树的结点层次编号，依次存放二叉树中的数据元素。</p>
<p><img src="/assets/image/posts/sdb8uh4b/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E9%A1%BA%E5%BA%8F%E5%AD%98%E5%82%A8%E7%A4%BA%E6%84%8F%E5%9B%BE.png" alt="二叉树的顺序存储示意图"></p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 二叉树顺序存储表示</span></span><br><span class="line"><span class="meta">#<span class="keyword">define</span> MAXTSIZE 100</span></span><br><span class="line">Typedef TElemType SqBiTree[MAXTSIZE]</span><br><span class="line">SqBiTree bt;</span><br></pre></td></tr></table></figure>
<p><img src="/assets/image/posts/sdb8uh4b/%E4%B8%80%E8%88%AC%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%AD%98%E5%82%A8.png" alt="一般二叉树的存储"></p>
<p>二叉树的顺序存储缺点：<br>
最坏情况：深度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span> 的且只有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.03148em;">k</span></span></span></span> 个结点的单支树需要长度为 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mi>k</mi></msup><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">2^k-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.9324em;vertical-align:-0.0833em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8491em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> 的一维数组。</p>
<p>特点：</p>
<ul>
<li>结点间关系蕴含在其存储位置中。</li>
<li>浪费空间，适于存满二叉树和完全二叉树。</li>
</ul>
<h3 id="二叉树的链式存储">二叉树的链式存储</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 二叉树的链式存储定义</span></span><br><span class="line"><span class="keyword">typedef</span> <span class="keyword">struct</span> <span class="title class_">BiNode</span>{</span><br><span class="line"> TElemType data;</span><br><span class="line"> <span class="keyword">struct</span> <span class="title class_">BiNode</span> *lchild, *rchild;</span><br><span class="line">}BiNode, *BiTree;</span><br></pre></td></tr></table></figure>
<blockquote>
<p>在 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span> 个结点的二叉链表中，必有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mi>n</mi></mrow><annotation encoding="application/x-tex">2n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span><span class="mord mathnormal">n</span></span></span></span> 个链域，会有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">n-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> 个结点的链域存放指针，会有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">n+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> 个空指针域。</p>
</blockquote>
<p>Tip：空指针域可以在线索二叉树中被利用。</p>
<h3 id="三叉链表">三叉链表</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 三叉链表定义</span></span><br><span class="line"><span class="keyword">typedef</span> <span class="keyword">struct</span> <span class="title class_">TriTNode</span>{</span><br><span class="line"> TElemType data;</span><br><span class="line"> <span class="keyword">struct</span> <span class="title class_">TriTNode</span> *lchild, *parent, *rchild;</span><br><span class="line">}TriTNode, *TriTree;</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>C++</category>
<category>数据结构与算法基础</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
<tag>数据结构</tag>
<tag>二叉树</tag>
</tags>
</entry>
<entry>
<title>2023年学习记录 - 二叉树遍历算法分析及运用</title>
<url>/posts/hu7yg98s/</url>
<content><![CDATA[<h2 id="声明">声明</h2>
<blockquote>
<p>本节内容来源于 BiliBili视频<a href="https://www.bilibili.com/video/BV1nJ411V7bd">数据结构与算法基础（青岛大学-王卓）</a> 的 P89 - P93，本博客仅作笔记整理和学习记录，部分图片来自视频截图。</p>
</blockquote>
<style>.bbplayer{width: 100%; max-width: 850px; margin: auto}</style><div class="bbplayer"><iframe class="bbplayer" id="mmedia-wyEBeHpPuEGOAjJE" src="https://player.bilibili.com/player.html?bvid=BV1nJ411V7bd&page=89&high_quality=1&danmaku=true&autoplay=0" allowfullscreen="allowfullscreen" scrolling="no" border="0" frameborder="0" framespacing="0" sandbox="allow-top-navigation allow-same-origin allow-forms allow-scripts allow-popups"></iframe></div><script> document.getElementById("mmedia-wyEBeHpPuEGOAjJE").style.height=document.getElementById("mmedia-wyEBeHpPuEGOAjJE").scrollWidth*0.76+"px";
window.onresize = function(){
document.getElementById("mmedia-wyEBeHpPuEGOAjJE").style.height=document.getElementById("mmedia-wyEBeHpPuEGOAjJE").scrollWidth*0.76+"px";
}; </script>
<h2 id="二叉树递归算法">二叉树递归算法</h2>
<h3 id="先序遍历递归算法">先序遍历递归算法</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function">Status <span class="title">PreOrderTraverse</span><span class="params">(BiTree T)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(T==<span class="literal">NULL</span>) <span class="keyword">return</span> OK; <span class="comment">//空二叉树</span></span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> <span class="built_in">visit</span>(T); <span class="comment">//访问根节点</span></span><br><span class="line"> <span class="built_in">PreOrderTraverse</span>(T->lchild); <span class="comment">//递归遍历左子树</span></span><br><span class="line"> <span class="built_in">PreOrderTraverse</span>(T->rchild); <span class="comment">//递归遍历右子树</span></span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">//实现</span></span><br><span class="line"><span class="function"><span class="type">void</span> <span class="title">Pre</span><span class="params">(BiTree *T)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(T!=<span class="literal">NULL</span>){</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%d\t"</span>, T->data);</span><br><span class="line"> <span class="built_in">pre</span>(T->lchild);</span><br><span class="line"> <span class="built_in">pre</span>(T->rchild);</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="中序遍历递归算法">中序遍历递归算法</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function">Status <span class="title">InOrderTraverse</span><span class="params">(BiTree T)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(T==<span class="literal">NULL</span>) <span class="keyword">return</span> OK; <span class="comment">//空二叉树</span></span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> <span class="built_in">InOrderTraverse</span>(T->lchild); <span class="comment">//递归遍历左子树</span></span><br><span class="line"> <span class="built_in">visit</span>(T); <span class="comment">//访问根节点</span></span><br><span class="line"> <span class="built_in">InOrderTraverse</span>(T->rchild); <span class="comment">//递归遍历右子树</span></span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="后序遍历递归算法">后序遍历递归算法</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function">Status <span class="title">PostOrderTraverse</span><span class="params">(BiTree T)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(T==<span class="literal">NULL</span>) <span class="keyword">return</span> OK; <span class="comment">//空二叉树</span></span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> <span class="built_in">PostOrderTraverse</span>(T->lchild); <span class="comment">//递归遍历左子树</span></span><br><span class="line"> <span class="built_in">PostOrderTraverse</span>(T->rchild); <span class="comment">//递归遍历右子树</span></span><br><span class="line"> <span class="built_in">visit</span>(T); <span class="comment">//访问根节点</span></span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="遍历算法的分析">遍历算法的分析</h3>
<p><img src="/assets/image/posts/snd9tnx8/%E9%81%8D%E5%8E%86%E7%AE%97%E6%B3%95%E7%9A%84%E5%88%86%E6%9E%90.png" alt="遍历算法的分析"></p>
<p>时间效率: O(n)<br>
空间效率: O(n)</p>
<h2 id="二叉树非递归算法">二叉树非递归算法</h2>
<h3 id="中序遍历非递归算法">中序遍历非递归算法</h3>
<p>二叉树中序遍历的非递归算法的关键：在中序遍历过某结点的整个左子树后，如何找到该结点的根以及右子树。</p>
<p>基本思想:</p>
<ol>
<li>建立一个栈</li>
<li>根结点进栈，遍历左子树</li>
<li>根结点出栈，输出根结点，遍历右子树。</li>
</ol>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function">Status <span class="title">InOrderTraverse</span><span class="params">(BiTree T)</span></span>{</span><br><span class="line"> BiTree p;</span><br><span class="line"> <span class="built_in">InitStack</span>(S);</span><br><span class="line"> p=T;</span><br><span class="line"> <span class="keyword">while</span>(p || !<span class="built_in">StackEmpty</span>(S)){</span><br><span class="line"> <span class="keyword">if</span>(p) {</span><br><span class="line"> <span class="built_in">Push</span>(S,p);</span><br><span class="line"> p = p -> lchild;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span> {</span><br><span class="line"> <span class="built_in">Pop</span>(S,q);</span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%c"</span>, q->data);</span><br><span class="line"> p = q -> rchild;</span><br><span class="line"> }</span><br><span class="line"> }<span class="comment">//while</span></span><br><span class="line"> <span class="keyword">return</span> OK;</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h2 id="二叉树层次遍历算法">二叉树层次遍历算法</h2>
<p>算法设计思路:</p>
<p>使用一个队列:</p>
<ol>
<li>将根结点进队；</li>
<li>队不空时循环：从队列中出列一个结点*p，访问它：
<ol>
<li>若它有左孩子结点，将左孩子结点进队；</li>
<li>若它有右孩子结点，将右孩子结点进队。</li>
</ol>
</li>
</ol>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="keyword">typedef</span> <span class="keyword">struct</span>{</span><br><span class="line"> BTNode data[MaxSize];</span><br><span class="line"> <span class="type">int</span> front, rear;</span><br><span class="line">}SqQueue;</span><br></pre></td></tr></table></figure>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="type">void</span> <span class="title">LecelOrder</span><span class="params">(BTNode *b)</span></span>{</span><br><span class="line"> BTNode *p;</span><br><span class="line"> SqQueue *qu;</span><br><span class="line"> <span class="built_in">InitQueue</span>(qu); <span class="comment">//初始化队列</span></span><br><span class="line"> <span class="built_in">enQueue</span>(qu, b); <span class="comment">//根节点指针进入队列</span></span><br><span class="line"> <span class="keyword">while</span>(!<span class="built_in">QueueEmpty</span>(qu)){ <span class="comment">//队列不为空，则循环</span></span><br><span class="line"> <span class="built_in">deQueue</span>(qu, p); <span class="comment">//出队结点p</span></span><br><span class="line"> <span class="built_in">printf</span>(<span class="string">"%c"</span>, p -> data); <span class="comment">//访问结点p</span></span><br><span class="line"> <span class="keyword">if</span>(p->lchild!=<span class="literal">NULL</span>) <span class="built_in">enQueue</span>(qu, p->lchild);</span><br><span class="line"> <span class="keyword">if</span>(p->rchild!=<span class="literal">NULL</span>) <span class="built_in">enQueue</span>(qu, p->rchild);</span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h2 id="二叉树遍历算法的应用（以先序遍历为例）">二叉树遍历算法的应用（以先序遍历为例）</h2>
<h3 id="建立二叉树的二叉链表">建立二叉树的二叉链表</h3>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function">Status <span class="title">CreateBiTree</span><span class="params">(BiTree&T)</span></span>{ </span><br><span class="line"> <span class="built_in">scanf</span>(&ch); <span class="comment">//cin>>ch;</span></span><br><span class="line"> <span class="keyword">if</span>(ch== <span class="string">"#"</span>) T=<span class="literal">NULL</span>; </span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> <span class="keyword">if</span> (!(T = (BiTNode *)<span class="built_in">malloc</span>(<span class="built_in">sizeof</span>(BiTNode)))) <span class="built_in">exit</span>(OVERFLOW); <span class="comment">//T=new BiTNode; </span></span><br><span class="line"> T->data = ch； <span class="comment">//生成根结点</span></span><br><span class="line"> <span class="built_in">CreateBiTree</span>(T->lchild); <span class="comment">//构造左子树 </span></span><br><span class="line"> <span class="built_in">CreateBiTree</span>(T->rchild); <span class="comment">//构造右子树</span></span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">return</span> OK;</span><br><span class="line">}<span class="comment">//CreateBiTree </span></span><br></pre></td></tr></table></figure>
<h3 id="复制二叉树">复制二叉树</h3>
<p>算法思想：如果是空树，递归结束；否则，申请新结点空间，复制根结点递归复制左子树、递归复制右子树</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="type">int</span> <span class="title">Copy</span><span class="params">(BiTree T, BiTree &NewT)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(T==<span class="literal">NULL</span>){ <span class="comment">//如果是空树返回0</span></span><br><span class="line"> NewT = <span class="literal">NULL</span>; </span><br><span class="line"> <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> NewT = <span class="keyword">new</span> BiTNode;</span><br><span class="line"> NewT->data = T->data; </span><br><span class="line"> <span class="built_in">Copy</span>(T->IChild, NewT->Ichild);</span><br><span class="line"> <span class="built_in">Copy</span>(T->rChild, NewT->rchild); </span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="计算二叉树的深度">计算二叉树的深度</h3>
<p>算法思想：如果是空树，则深度为0；否则，递归计算左子树的深度记为m，递归计算右子树的深度记为n，二叉树的深度则为m与n的较大者加1。</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="type">int</span> <span class="title">Depth</span><span class="params">(BiTree T)</span></span>{ </span><br><span class="line"> <span class="keyword">if</span>(T==<span class="literal">NULL</span>) <span class="keyword">return</span> <span class="number">0</span>; <span class="comment">//如果是空树返回0</span></span><br><span class="line"> <span class="keyword">else</span>{</span><br><span class="line"> m = <span class="built_in">Depth</span>(T->IChild); </span><br><span class="line"> n = <span class="built_in">Depth</span>(T->rChild); </span><br><span class="line"> <span class="keyword">if</span>(m>n) <span class="keyword">return</span> (m+<span class="number">1</span>); </span><br><span class="line"> <span class="keyword">else</span> <span class="built_in">return</span>(n+<span class="number">1</span>); </span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="计算二叉树的结点总数">计算二叉树的结点总数</h3>
<p>算法思想：如果是空树，则节点个数为0；否则，节点个数为左子树的结点个数+右子树的结点个数再+1。</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="type">int</span> <span class="title">NodeCount</span><span class="params">(BiTree T)</span></span>{ </span><br><span class="line"> <span class="keyword">if</span>(T==<span class="literal">NULL</span>) <span class="keyword">return</span> <span class="number">0</span>; <span class="comment">//如果是空树返回0</span></span><br><span class="line"> <span class="keyword">else</span> <span class="built_in">return</span> (<span class="built_in">NodeCount</span>(T->lchild) + <span class="built_in">NodeCount</span>(T->rchild) + <span class="number">1</span>);</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h3 id="计算二叉树的叶子节点总数">计算二叉树的叶子节点总数</h3>
<p>算法思想：如果是空树，则叶子节点个数为0；否则，节点个数为左子树的叶子结点个数+右子树的叶子结点个数。</p>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="type">int</span> <span class="title">LeadCount</span><span class="params">(BiTree T)</span></span>{ </span><br><span class="line"> <span class="keyword">if</span>(T==<span class="literal">NULL</span>) <span class="keyword">return</span> <span class="number">0</span>; <span class="comment">//如果是空树返回0</span></span><br><span class="line"> <span class="keyword">if</span>(T->lchild == <span class="literal">NULL</span> && T->rchild == <span class="literal">NULL</span>) <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line"> <span class="keyword">else</span> <span class="built_in">return</span> (<span class="built_in">LeadCount</span>(T->lchild) + <span class="built_in">LeadCount</span>(T->rchild));</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
]]></content>
<categories>
<category>C++</category>
<category>数据结构与算法基础</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
<tag>数据结构</tag>
<tag>二叉树</tag>
</tags>
</entry>
<entry>
<title>2023年学习记录 - 哈夫曼树及其运用</title>
<url>/posts/nis73hu8/</url>
<content><![CDATA[<h2 id="声明">声明</h2>
<blockquote>
<p>本节内容来源于 BiliBili视频<a href="https://www.bilibili.com/video/BV1nJ411V7bd">数据结构与算法基础（青岛大学-王卓）</a> 的 P101 - P107，本博客仅作笔记整理和学习记录，部分图片来自视频截图。</p>
</blockquote>
<style>.bbplayer{width: 100%; max-width: 850px; margin: auto}</style><div class="bbplayer"><iframe class="bbplayer" id="mmedia-CLhPahsMISDbACRB" src="https://player.bilibili.com/player.html?bvid=BV1nJ411V7bd&page=101&high_quality=1&danmaku=true&autoplay=0" allowfullscreen="allowfullscreen" scrolling="no" border="0" frameborder="0" framespacing="0" sandbox="allow-top-navigation allow-same-origin allow-forms allow-scripts allow-popups"></iframe></div><script> document.getElementById("mmedia-CLhPahsMISDbACRB").style.height=document.getElementById("mmedia-CLhPahsMISDbACRB").scrollWidth*0.76+"px";
window.onresize = function(){
document.getElementById("mmedia-CLhPahsMISDbACRB").style.height=document.getElementById("mmedia-CLhPahsMISDbACRB").scrollWidth*0.76+"px";
}; </script>
<h2 id="哈夫曼树的基本概念">哈夫曼树的基本概念</h2>
<ul>
<li>路径：从树中一个结点到另一个结点之间的分支构成这两个结点间的路径。</li>
<li>结点的路径长度：两结点间路径上的分支数。</li>
<li>树的路径长度：从树根到每一个结点的路径长度之和。记作：TL</li>
<li>权（weight）：将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。</li>
<li>结点的带权路径长度：从根结点到该结点之间的路径长度与该结点的权的乘积。</li>
<li>树的带权路径长度：树中所有叶子结点的带权路径长度之和。记作：（其中w是权值，k是结点到根的路径长度）<br>
<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msubsup><mo>∑</mo><mrow><mi>k</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></msubsup><mrow><msub><mi>w</mi><mi>k</mi></msub><msub><mi>l</mi><mi>k</mi></msub></mrow></mrow><annotation encoding="application/x-tex">\sum_{k=1}^{n}{w_kl_k}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.104em;vertical-align:-0.2997em;"></span><span class="mop"><span class="mop op-symbol small-op" style="position:relative;top:0em;">∑</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8043em;"><span style="top:-2.4003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span><span class="mrel mtight">=</span><span class="mord mtight">1</span></span></span></span><span style="top:-3.2029em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">n</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.2997em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal" style="margin-right:0.02691em;">w</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3361em;"><span style="top:-2.55em;margin-left:-0.0269em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.01968em;">l</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3361em;"><span style="top:-2.55em;margin-left:-0.0197em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.03148em;">k</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span></li>
</ul>
<h2 id="哈夫曼树的性质">哈夫曼树的性质</h2>
<p>结点数目相同的二叉树中，完全二叉树是路径长度最短的二叉树。</p>
<ul>
<li>
<p>哈夫曼树：最优树<br>
带权路径长度（WPL）最短的树<br>
“带权路径长度最短”是在“度相同”的树中比较而得的结果，因此有最优二叉树、最优三叉树之称等等。</p>
</li>
<li>
<p>哈夫曼树：最优二叉树<br>
带权路径长度（WPL）最短的二叉树</p>
</li>
</ul>
<p>因为构造这种树的算法是由哈夫曼教授于1952年提出的，所以被称为哈夫曼树，相应的算法称为哈夫曼算法。</p>
<blockquote>
<p>满二叉树不一定是哈夫曼树<br>
哈夫曼树中权越大的叶子离根越近<br>
具有相同带权结点的哈夫曼树不惟一</p>
</blockquote>
<h2 id="哈夫曼算法">哈夫曼算法</h2>
<p>即：构造哈夫曼树的方法</p>
<ol>
<li>根据n个给定的权值 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>W</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>W</mi><mn>2</mn></msub><mo separator="true">,</mo><mtext>．．．</mtext><mo separator="true">,</mo><msub><mi>W</mi><mi>n</mi></msub></mrow><annotation encoding="application/x-tex">{W_1, W_2,．．．,W_n}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8778em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">W</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">W</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord cjk_fallback">．．．</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">W</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.1514em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> 构成n棵二叉树的森林<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mtext>＝</mtext><mrow><msub><mi>T</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>T</mi><mn>2</mn></msub><mo separator="true">,</mo><mtext>．．．</mtext><mo separator="true">,</mo><msub><mi>T</mi><mi>n</mi></msub></mrow></mrow><annotation encoding="application/x-tex">F＝{T_1,T_2,．．．,T_n}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8778em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.13889em;">F</span><span class="mord cjk_fallback">＝</span><span class="mord"><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord cjk_fallback">．．．</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.1514em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">n</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span>，其中T；只有一个带权为<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>w</mi></mrow><annotation encoding="application/x-tex">w</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal" style="margin-right:0.02691em;">w</span></span></span></span>的根结点。</li>
<li>在F中选取两棵根结点的权值最少的树作为左右子树，构造一棵新的二叉树，且设置新的二叉树的根结点的权值为其左右子树上根结点的权值之和。</li>
<li>在F中删除这两棵树，同时将新得到的二叉树加入森林中。</li>
<li>重复（2）和（3），直到森林中只有一棵树为止，这棵树即为哈夫曼树。</li>
</ol>
<p>口诀：</p>
<blockquote>
<p>构造森林全是根<br>
选用两小造新树<br>
删除两小添新人<br>
重复二三剩单根</p>
</blockquote>
<ul>
<li>包含n个叶子结点的哈夫曼树中共有<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mi>n</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">2n-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">2</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>个结点。</li>
<li>哈夫曼树的结点的度数为<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0</mn></mrow><annotation encoding="application/x-tex">0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span>或<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn></mrow><annotation encoding="application/x-tex">2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span></span></span></span>，没有度为<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn></mrow><annotation encoding="application/x-tex">1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>的结点。<br>
因为：包含n棵树的森林要经过<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext>—</mtext><mn>1</mn></mrow><annotation encoding="application/x-tex">n—1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord mathnormal">n</span><span class="mord">—1</span></span></span></span>次合并才能形成哈夫曼树，共产生<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext>—</mtext><mn>1</mn></mrow><annotation encoding="application/x-tex">n—1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord mathnormal">n</span><span class="mord">—1</span></span></span></span>个新结点。</li>
</ul>
<p><img src="/assets/image/posts/nis73hu8/%E6%9E%84%E9%80%A0%E5%93%88%E5%A4%AB%E6%9B%BC%E6%A0%91%E4%BE%8B1.png" alt="构造哈夫曼树例1"></p>
<p><img src="/assets/image/posts/nis73hu8/%E6%9E%84%E9%80%A0%E5%93%88%E5%A4%AB%E6%9B%BC%E6%A0%91%E4%BE%8B2.png" alt="构造哈夫曼树例2"></p>
<p>总结：</p>
<ol>
<li>在哈夫曼算法中，初始时有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span> 棵二叉树，要经过 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext>—</mtext><mn>1</mn></mrow><annotation encoding="application/x-tex">n—1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord mathnormal">n</span><span class="mord">—1</span></span></span></span> 次合并最终形成哈夫曼树。</li>
<li>经过 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext>—</mtext><mn>1</mn></mrow><annotation encoding="application/x-tex">n—1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord mathnormal">n</span><span class="mord">—1</span></span></span></span> 次合并产生 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext>—</mtext><mn>1</mn></mrow><annotation encoding="application/x-tex">n—1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord mathnormal">n</span><span class="mord">—1</span></span></span></span> 个新结点，且这 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext>—</mtext><mn>1</mn></mrow><annotation encoding="application/x-tex">n—1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord mathnormal">n</span><span class="mord">—1</span></span></span></span> 个新结点都是具有两个孩子的分支结点。</li>
</ol>
<p>可见：哈夫曼树中共有 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mo>+</mo><mi>n</mi><mo>−</mo><mn>1</mn><mo>=</mo><mn>2</mn><mi>n</mi><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">n+n-1=2n-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em;"></span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.7278em;vertical-align:-0.0833em;"></span><span class="mord">2</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> 个结点，且其所有的分支结点的度均不为1。</p>
<h2 id="哈夫曼树的构造算法">哈夫曼树的构造算法</h2>
<ol>
<li>初始化 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mn>1...2</mn><mi>n</mi><mo>−</mo><mn>1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HT[1...2n-1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord">1...2</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">]</span></span></span></span> : <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>I</mi><mi>c</mi><mi>h</mi><mo>=</mo><mi>r</mi><mi>c</mi><mi>h</mi><mo>=</mo><mi>p</mi><mi>a</mi><mi>r</mi><mi>e</mi><mi>n</mi><mi>t</mi><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">Ich=rch=parent=0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.07847em;">I</span><span class="mord mathnormal">c</span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">rc</span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8095em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mord mathnormal">a</span><span class="mord mathnormal">re</span><span class="mord mathnormal">n</span><span class="mord mathnormal">t</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span>；</li>
<li>输入初始 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span> 个叶子结点：设置 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mn>1...2</mn><mi>n</mi><mo>−</mo><mn>1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HT[1...2n-1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord">1...2</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">]</span></span></span></span> 的weight值；</li>
<li>进行以下 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext>—</mtext><mn>1</mn></mrow><annotation encoding="application/x-tex">n—1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord mathnormal">n</span><span class="mord">—1</span></span></span></span> 次合并，依次产生 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mtext>—</mtext><mn>1</mn></mrow><annotation encoding="application/x-tex">n—1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord mathnormal">n</span><span class="mord">—1</span></span></span></span> 个结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>i</mi><mo stretchy="false">]</mo><mo separator="true">,</mo><mi>i</mi><mtext>＝</mtext><mi>n</mi><mo>+</mo><mn>1...2</mn><mi>n</mi><mtext>—</mtext><mn>1</mn></mrow><annotation encoding="application/x-tex">HT[i],i＝n+1...2n—1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mclose">]</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">i</span><span class="mord cjk_fallback">＝</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1...2</span><span class="mord mathnormal">n</span><span class="mord">—1</span></span></span></span>：
<ol>
<li>在<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mn>1...</mn><mi>i</mi><mo>−</mo><mn>1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HT[1...i-1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord">1...</span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">]</span></span></span></span>中选两个未被选过（从 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mi>a</mi><mi>r</mi><mi>e</mi><mi>n</mi><mi>t</mi><mo>=</mo><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">parent==0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8095em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mord mathnormal">a</span><span class="mord mathnormal">re</span><span class="mord mathnormal">n</span><span class="mord mathnormal">t</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">==</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span> 的结点中选）的weight最小的两个结点 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>s</mi><mn>1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HT[s1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">s</span><span class="mord">1</span><span class="mclose">]</span></span></span></span> 和 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>s</mi><mn>2</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HT[s2]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">s</span><span class="mord">2</span><span class="mclose">]</span></span></span></span>，s1、s2为两个最小结点下标；</li>
<li>修改 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>s</mi><mn>1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HT[s1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">s</span><span class="mord">1</span><span class="mclose">]</span></span></span></span> 和 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>s</mi><mn>2</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HT[s2]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">s</span><span class="mord">2</span><span class="mclose">]</span></span></span></span> 的parent值:
<ul>
<li><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>s</mi><mn>1</mn><mo stretchy="false">]</mo><mi mathvariant="normal">.</mi><mi>p</mi><mi>a</mi><mi>r</mi><mi>e</mi><mi>n</mi><mi>t</mi><mo>=</mo><mi>i</mi></mrow><annotation encoding="application/x-tex">HT[s1].parent=i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">s</span><span class="mord">1</span><span class="mclose">]</span><span class="mord">.</span><span class="mord mathnormal">p</span><span class="mord mathnormal">a</span><span class="mord mathnormal">re</span><span class="mord mathnormal">n</span><span class="mord mathnormal">t</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>;</li>
<li><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>s</mi><mn>2</mn><mo stretchy="false">]</mo><mi mathvariant="normal">.</mi><mi>p</mi><mi>a</mi><mi>r</mi><mi>e</mi><mi>n</mi><mi>t</mi><mo>=</mo><mi>i</mi></mrow><annotation encoding="application/x-tex">HT[s2].parent=i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">s</span><span class="mord">2</span><span class="mclose">]</span><span class="mord">.</span><span class="mord mathnormal">p</span><span class="mord mathnormal">a</span><span class="mord mathnormal">re</span><span class="mord mathnormal">n</span><span class="mord mathnormal">t</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>;</li>
</ul>
</li>
<li>修改新产生的HT［i］：
<ul>
<li><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>i</mi><mo stretchy="false">]</mo><mi mathvariant="normal">.</mi><mi>w</mi><mi>e</mi><mi>i</mi><mi>g</mi><mi>h</mi><mi>t</mi><mo>=</mo><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>s</mi><mn>1</mn><mo stretchy="false">]</mo><mi mathvariant="normal">.</mi><mi>w</mi><mi>e</mi><mi>i</mi><mi>g</mi><mi>h</mi><mi>t</mi><mo>+</mo><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>s</mi><mn>2</mn><mo stretchy="false">]</mo><mi mathvariant="normal">.</mi><mi>w</mi><mi>e</mi><mi>i</mi><mi>g</mi><mi>h</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">HT[i].weight=HT[s1].weight + HT[s2].weight</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mclose">]</span><span class="mord">.</span><span class="mord mathnormal" style="margin-right:0.02691em;">w</span><span class="mord mathnormal">e</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord mathnormal">h</span><span class="mord mathnormal">t</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">s</span><span class="mord">1</span><span class="mclose">]</span><span class="mord">.</span><span class="mord mathnormal" style="margin-right:0.02691em;">w</span><span class="mord mathnormal">e</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord mathnormal">h</span><span class="mord mathnormal">t</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">s</span><span class="mord">2</span><span class="mclose">]</span><span class="mord">.</span><span class="mord mathnormal" style="margin-right:0.02691em;">w</span><span class="mord mathnormal">e</span><span class="mord mathnormal">i</span><span class="mord mathnormal" style="margin-right:0.03588em;">g</span><span class="mord mathnormal">h</span><span class="mord mathnormal">t</span></span></span></span>;</li>
<li><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>i</mi><mo stretchy="false">]</mo><mi mathvariant="normal">.</mi><mi>I</mi><mi>c</mi><mi>h</mi><mo>=</mo><mi>s</mi><mn>1</mn><mo separator="true">;</mo><mi>H</mi><mi>T</mi><mo stretchy="false">[</mo><mi>i</mi><mo stretchy="false">]</mo><mi mathvariant="normal">.</mi><mi>r</mi><mi>c</mi><mi>h</mi><mo>=</mo><mi>s</mi><mn>2</mn></mrow><annotation encoding="application/x-tex">HT[i].Ich=s1; HT[i].rch=s2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mclose">]</span><span class="mord">.</span><span class="mord mathnormal" style="margin-right:0.07847em;">I</span><span class="mord mathnormal">c</span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">s</span><span class="mord">1</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.13889em;">T</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mclose">]</span><span class="mord">.</span><span class="mord mathnormal">rc</span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord mathnormal">s</span><span class="mord">2</span></span></span></span>;</li>
</ul>
</li>
</ol>
</li>
</ol>
<ul>
<li>采用顺序存储结构：一维数组</li>
</ul>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line">HuffmanTree H;</span><br></pre></td></tr></table></figure>
<ul>
<li>结点类型定义</li>
</ul>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="keyword">typedef</span> <span class="keyword">struct</span> {</span><br><span class="line"> <span class="type">int</span> weight;</span><br><span class="line"> <span class="type">int</span> parent, lch, rch;</span><br><span class="line">}HTNode, *HuffmanTree;</span><br></pre></td></tr></table></figure>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="comment">// 构造哈夫曼树：哈夫曼算法</span></span><br><span class="line"><span class="function"><span class="type">void</span> <span class="title">CreatHuffmanTree</span><span class="params">(HuffmanTree HT, <span class="type">int</span> n)</span></span>{</span><br><span class="line"> <span class="keyword">if</span>(n <= <span class="number">1</span>) <span class="keyword">return</span>;</span><br><span class="line"> m = <span class="number">2</span>*n<span class="number">-1</span>; <span class="comment">//数组共2n-1个元素</span></span><br><span class="line"> HT = <span class="keyword">new</span> HTNode[m+<span class="number">1</span>]; <span class="comment">//0号单元未使用，HT[m]表示根节点</span></span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i = <span class="number">1</span>, i <= m; i++){ <span class="comment">//将2n-1个元素的lch, rch, parent 设置为0</span></span><br><span class="line"> HT[i].lch = <span class="number">0</span>;</span><br><span class="line"> HT[i].rch = <span class="number">0</span>;</span><br><span class="line"> HT[i].parent = <span class="number">0</span>;</span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i = <span class="number">1</span>; i <= n; i++){</span><br><span class="line"> cin >> HT[i].weight; <span class="comment">//输入前n个元素的weight值</span></span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i = n + <span class="number">1</span>; i <= m; i++){ <span class="comment">//合并产生n—1个结点——构造Huffman树</span></span><br><span class="line"> <span class="built_in">Select</span>(HT, i<span class="number">-1</span>, s1, s2); <span class="comment">//在HT[k](1≤k≤i—1)中选择两个其双亲域为0，</span></span><br><span class="line"> <span class="comment">//且权值最小的结点，并返回它们在HT中的序号s1和s2</span></span><br><span class="line"> HT[s1].parent = i; <span class="comment">//表示从F中删除s1，s2</span></span><br><span class="line"> HT[s2].parent = i;</span><br><span class="line"> HT[i].lch = s1; <span class="comment">//s1，s2分别作为i的左右孩子</span></span><br><span class="line"> HT[i].rch = s2;</span><br><span class="line"> HT[i].weight = HT[s1].weight + HT[s2].weight; <span class="comment">//i的权值为左右孩子权值之和</span></span><br><span class="line"> }</span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h2 id="哈夫曼编码">哈夫曼编码</h2>
<p>在远程通讯中，要将待传字符转换成由二进制的字符串：</p>
<ul>
<li>设要传送的字符串为：ABACCDA</li>
<li>若编码为：A-00 B-01 C-10 D-11</li>
<li>则实际传输的字符串为：00010010101100</li>
</ul>
<p>若将编码设计为长度不等的二进制编码，即让待传字符串中出现次数较多的字符采用尽可能短的编码，则转换的二进制字符串便可能减少。</p>
<ul>
<li>设要传送的字符串为：ABACCDA</li>
<li>若编码为：A-0 B-00 C-1 D-01</li>
<li>则实际传输的字符串为：000011010</li>
<li>出现了重码：0000 可以代表 AAAA、ABA、BB</li>
</ul>
<blockquote>
<p>关键：要设计长度不等的编码，则必须使任一字符的编码都不是另一个字符的编码的前缀。这种编码称做前缀编码。</p>
</blockquote>
<p>问题：什么样的前缀码能使得电文总长最短？——哈夫曼编码</p>
<p>方法：</p>
<ol>
<li>统计字符集中每个字符在电文中出现的平均概率（概率越大，要求编码越短）。</li>
<li>利用哈夫曼树的特点：权越大的叶子离根越近；将每个字符的概率值作为权值，构造哈夫曼树。则概率越大的结点，路径越短。</li>
<li>在哈夫曼树的每个分支上标上0或1：<br>
结点的左分支标0，右分支标1<br>
把从根到每个叶子的路径上的标号连接起来，作为该叶子代表的字符的编码。</li>
</ol>
<p><img src="/assets/image/posts/nis73hu8/%E5%93%88%E5%A4%AB%E6%9B%BC%E7%BC%96%E7%A0%81.png" alt="哈夫曼编码"></p>
<p>两个问题：</p>
<ol>
<li>为什么哈夫曼编码能够保证是前缀编码？<br>
因为没有一片树叶是另一片树叶的祖先，所以每个叶结点的编码就不可能是其它叶结点编码的前缀</li>
<li>为什么哈夫曼编码能够保证字符编码总长最短？<br>
因为哈夫曼树的带权路径长度最短，故字符编码的总长最短。</li>
</ol>
<p>性质：</p>
<ul>
<li>哈夫曼编码是前缀码</li>
<li>哈夫曼编码是最优前缀码</li>
</ul>
<h2 id="哈夫曼编码的算法实现">哈夫曼编码的算法实现</h2>
<figure class="highlight c++"><table><tr><td class="code"><pre><span class="line"><span class="function"><span class="type">void</span> <span class="title">CreatHuffmanCode</span><span class="params">(HuffmanTree HT, HuffmanCode &HC, <span class="type">int</span> n)</span></span>{</span><br><span class="line"> <span class="comment">//从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中</span></span><br><span class="line"> HC = <span class="keyword">new</span> <span class="type">char</span> *[n+<span class="number">1</span>]; <span class="comment">//分配n个字符编码的头指针矢量</span></span><br><span class="line"> cd = <span class="keyword">new</span> <span class="type">char</span> [n]; <span class="comment">//分配临时存放编码的动态数组空间</span></span><br><span class="line"> cd[n<span class="number">-1</span>] = <span class="string">'\0'</span>; <span class="comment">//编码结束符</span></span><br><span class="line"> <span class="comment">//逐个字符求哈夫曼编码</span></span><br><span class="line"> <span class="keyword">for</span>(<span class="type">int</span> i = <span class="number">1</span>; i <= n; i++){</span><br><span class="line"> start = n<span class="number">-1</span>;</span><br><span class="line"> c = i;</span><br><span class="line"> f = HT[i].parent;</span><br><span class="line"> <span class="keyword">while</span>(f!=<span class="number">0</span>){ <span class="comment">//从叶子结点开始向上回溯，直到根结点</span></span><br><span class="line"> start--; <span class="comment">//回溯一次start向前指一个位置</span></span><br><span class="line"> <span class="keyword">if</span>(HT[f].lchild == c) cd[start] = <span class="string">'0'</span>; <span class="comment">//结点c是f的左孩子，则生成代码0</span></span><br><span class="line"> <span class="keyword">else</span> cd[start] = <span class="string">'1'</span>; <span class="comment">//结点c是f的右孩子，则生成代码1</span></span><br><span class="line"> c = f; <span class="comment">//继续向上回溯</span></span><br><span class="line"> f = HT[f].parent;</span><br><span class="line"> } <span class="comment">//求出第i个字符的编码</span></span><br><span class="line"> HC[i] = <span class="keyword">new</span> <span class="type">char</span>[n-start]; <span class="comment">//为第i个字符串编码分配空间</span></span><br><span class="line"> <span class="built_in">strcpy</span>(HC[i], &cd[start]); <span class="comment">//将求得的编码从临时空间cd复制到HC的当前行中</span></span><br><span class="line"> }</span><br><span class="line"> <span class="keyword">delete</span> cd; <span class="comment">//释放临时空间</span></span><br><span class="line">}</span><br></pre></td></tr></table></figure>
<h2 id="文件的编码和解码">文件的编码和解码</h2>
<p><img src="/assets/image/posts/nis73hu8/%E8%8B%B1%E8%AF%AD%E4%B8%AD%E5%90%84%E5%AD%97%E6%AF%8D%E5%87%BA%E7%8E%B0%E9%A2%91%E7%8E%87.png" alt="英语中各字母出现频率"></p>
<p>编码:</p>
<ol>
<li>输入各字符及其权值</li>
<li>构造哈夫曼树——<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>C</mi><mo stretchy="false">[</mo><mi>i</mi><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HC[i]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.07153em;">C</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mclose">]</span></span></span></span></li>
<li>进行哈夫曼编码——<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>C</mi><mo stretchy="false">[</mo><mi>i</mi><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HC[i]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.07153em;">C</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mclose">]</span></span></span></span></li>
<li>查 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi><mi>C</mi><mo stretchy="false">[</mo><mi>i</mi><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">HC[i]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.08125em;">H</span><span class="mord mathnormal" style="margin-right:0.07153em;">C</span><span class="mopen">[</span><span class="mord mathnormal">i</span><span class="mclose">]</span></span></span></span>，得到各字符的哈夫曼编码</li>
</ol>
<p>解码:</p>
<ol>
<li>构造哈夫曼树</li>
<li>依次读入二进制码</li>
<li>读入0，则走向左孩子；读入1，则走向右孩子④ 一旦到达某叶子时，即可译出字符</li>
<li>然后再从根出发继续译码，指导结束</li>
</ol>
]]></content>
<categories>
<category>C++</category>
<category>数据结构与算法基础</category>
</categories>
<tags>
<tag>C++</tag>
<tag>学习</tag>
<tag>算法</tag>
<tag>数据结构</tag>
<tag>树</tag>
<tag>哈夫曼树</tag>
</tags>
</entry>
<entry>
<title>2023年学习记录 - 图的定义和术语</title>
<url>/posts/tude98j8/</url>
<content><![CDATA[<h2 id="声明">声明</h2>
<blockquote>
<p>本节内容来源于 BiliBili视频<a href="https://www.bilibili.com/video/BV1nJ411V7bd">数据结构与算法基础（青岛大学-王卓）</a> 的 P108 - P110，本博客仅作笔记整理和学习记录，部分图片来自视频截图。</p>
</blockquote>
<style>.bbplayer{width: 100%; max-width: 850px; margin: auto}</style><div class="bbplayer"><iframe class="bbplayer" id="mmedia-dXEaksRbgXMFRWeT" src="https://player.bilibili.com/player.html?bvid=BV1nJ411V7bd&page=108&high_quality=1&danmaku=true&autoplay=0" allowfullscreen="allowfullscreen" scrolling="no" border="0" frameborder="0" framespacing="0" sandbox="allow-top-navigation allow-same-origin allow-forms allow-scripts allow-popups"></iframe></div><script> document.getElementById("mmedia-dXEaksRbgXMFRWeT").style.height=document.getElementById("mmedia-dXEaksRbgXMFRWeT").scrollWidth*0.76+"px";
window.onresize = function(){
document.getElementById("mmedia-dXEaksRbgXMFRWeT").style.height=document.getElementById("mmedia-dXEaksRbgXMFRWeT").scrollWidth*0.76+"px";
}; </script>