StarMirror/cpp-interview
1
0
Fork 0
mirror of https://github.com/huihut/interview.git synced 2024-03-22 13:10:48 +08:00
Code Issues Projects Releases Wiki Activity

使用<details><summary>隐藏不重要的代码和图片

Browse Source
This commit is contained in:
Menghui Xie 2018-06-19 19:54:08 +08:00
parent 871ddee41b
commit edfbd94460
1 changed files with 228 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

285
README.md
View File

@ -30,7 +30,18 @@
## C/C++ ## C/C++
<details><summary><h3>const</h3></summary><br> ### const
#### 作用
1. 修饰变量，说明该变量不可以被改变；
2. 修饰指针，分为指向常量的指针和指针常量；
3. 常量引用，经常用于形参类型，即避免了拷贝，又避免了函数对值的修改；
4. 修饰成员函数，说明该成员函数内不能修改成员变量。
#### 使用
<details><summary>const 使用</summary>
```cpp ```cpp
// 类 // 类
@ -77,17 +88,8 @@ const int* function6(); // 返回一个指向常量的指针变量，使用
int* const function7(); // 返回一个指向变量的常指针，使用：int* const p = function7(); int* const function7(); // 返回一个指向变量的常指针，使用：int* const p = function7();
``` ```
#### 作用
1. 修饰变量，说明该变量不可以被改变；
2. 修饰指针，分为指向常量的指针和指针常量；
3. 常量引用，经常用于形参类型，即避免了拷贝，又避免了函数对值的修改；
4. 修饰成员函数，说明该成员函数内不能修改成员变量。
</details> </details>
### volatile ### volatile
```cpp ```cpp
@ -132,6 +134,9 @@ volatile int i = 10;
#### 使用 #### 使用
<details><summary>inline 使用</summary>
```cpp ```cpp
// 声明1（加 inline，建议使用） // 声明1（加 inline，建议使用）
inline int functionName(int first, int secend,...); inline int functionName(int first, int secend,...);
@ -143,6 +148,8 @@ int functionName(int first, int secend,...);
inline int functionName(int first, int secend,...) {/****/}; inline int functionName(int first, int secend,...) {/****/};
``` ```
</details>
#### 编译器对inline函数的处理步骤 #### 编译器对inline函数的处理步骤
1. 将 inline 函数体复制到 inline 函数调用点处； 1. 将 inline 函数体复制到 inline 函数调用点处；
@ -173,6 +180,9 @@ inline int functionName(int first, int secend,...) {/****/};
* 内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。 * 内联是在编译器建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时（运行期）不可以内联。
* `inline virtual` 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 `Base::who()`），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。 * `inline virtual` 唯一可以内联的时候是：编译器知道所调用的对象是哪个类（如 `Base::who()`），这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
<details><summary>虚函数内联使用</summary>
```cpp ```cpp
#include <iostream> #include <iostream>
using namespace std; using namespace std;
@ -213,6 +223,8 @@ int main()
} }
``` ```
</details>
### assert() ### assert()
断言，是宏，而非函数。assert 宏的原型定义在`<assert.h>`（C）、`<cassert>`（C++）中，其作用是如果它的条件返回错误，则终止程序执行。 断言，是宏，而非函数。assert 宏的原型定义在`<assert.h>`（C）、`<cassert>`（C++）中，其作用是如果它的条件返回错误，则终止程序执行。
@ -232,7 +244,8 @@ assert( p != NULL );
设定结构体、联合以及类成员变量以 n 字节方式对齐 设定结构体、联合以及类成员变量以 n 字节方式对齐
如 <details><summary>#pragma pack(n) 使用</summary>
```cpp ```cpp
#pragma pack(push) // 保存对齐状态 #pragma pack(push) // 保存对齐状态
@ -248,6 +261,8 @@ struct test
#pragma pack(pop) // 恢复对齐状态 #pragma pack(pop) // 恢复对齐状态
``` ```
</details>
### extern "C" ### extern "C"
* 被 extern 限定的函数或变量是 extern 类型的 * 被 extern 限定的函数或变量是 extern 类型的
@ -255,6 +270,8 @@ struct test
`extern "C"` 的作用是让 C++ 编译器将 `extern "C"` 声明的代码当作 C 语言代码处理，可以避免 C++ 因符号修饰导致代码不能和C语言库中的符号进行链接的问题。 `extern "C"` 的作用是让 C++ 编译器将 `extern "C"` 声明的代码当作 C 语言代码处理，可以避免 C++ 因符号修饰导致代码不能和C语言库中的符号进行链接的问题。
<details><summary>extern "C" 使用</summary>
```cpp ```cpp
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -267,6 +284,8 @@ void *memset(void *, int, size_t);
#endif #endif
``` ```
</details>
### struct 和 typedef struct ### struct 和 typedef struct
#### C 中 #### C 中
@ -346,7 +365,7 @@ int main() {
explicit 修饰的构造函数可用来防止隐式转换 explicit 修饰的构造函数可用来防止隐式转换
如下 <details><summary>explicit 使用</summary>
```cpp ```cpp
class Test1 class Test1
@ -380,6 +399,8 @@ int main()
} }
``` ```
</details>
### friend 友元类和友元函数 ### friend 友元类和友元函数
* 能访问私有成员 * 能访问私有成员
@ -388,23 +409,37 @@ int main()
* 友元关系的单向性 * 友元关系的单向性
* 友元声明的形式及数量不受限制 * 友元声明的形式及数量不受限制
### using 引入命名空间成员 ### using
#### using 声明
一条 `using 声明` 语句一次只引入命名空间的一个成员。它使得我们可以清楚知道程序中所引用的到底是哪个名字。如：
```cpp ```cpp
using namespace_name::name using namespace_name::name;
``` ```
#### 尽量不要使用 `using namespace std;` 污染命名空间 #### using 指示
`using 指示` 使得某个特定命名空间中所有名字都可见，这样我们就无需再为它们添加任何前缀限定符了。如：
```cpp
using namespace_name name;
```
#### 尽量少使用 `using 指示` 污染命名空间
> 一般说来，使用 using 命令比使用 using 编译命令更安全，这是由于它**只导入了制定的名称**。如果该名称与局部名称发生冲突，编译器将**发出指示**。using编译命令导入所有的名称，包括可能并不需要的名称。如果与局部名称发生冲突，则**局部名称将覆盖名称空间版本**，而编译器**并不会发出警告**。另外，名称空间的开放性意味着名称空间的名称可能分散在多个地方，这使得难以准确知道添加了哪些名称。 > 一般说来，使用 using 命令比使用 using 编译命令更安全，这是由于它**只导入了制定的名称**。如果该名称与局部名称发生冲突，编译器将**发出指示**。using编译命令导入所有的名称，包括可能并不需要的名称。如果与局部名称发生冲突，则**局部名称将覆盖名称空间版本**，而编译器**并不会发出警告**。另外，名称空间的开放性意味着名称空间的名称可能分散在多个地方，这使得难以准确知道添加了哪些名称。
尽量不要使用 <details><summary>using 使用</summary>
尽量少使用 `using 指示`
```cpp ```cpp
using namespace std; using namespace std;
``` ```
应该使用 应该多使用 `using 声明`
```cpp ```cpp
int x; int x;
@ -423,23 +458,40 @@ cin >> x;
cout << x << endl; cout << x << endl;
``` ```
</details>
### :: 范围解析运算符 ### :: 范围解析运算符
`::` 可以加在类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间 #### 分类
如 1. 全局作用域符（`::name`）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间
2. 类作用域符（`class::name`）：用于表示指定类型的作用域范围是具体某个类的
3. 命名空间作用域符（`namespace::name`）:用于表示指定类型的作用域范围是具体某个命名空间的
<details><summary>:: 使用</summary>
```cpp ```cpp
int count = 0; // global count int count = 0; // 全局（::）的 count
class A {
public:
static int count; // 类 A 的 count（A::count）
};
int main() { int main() {
int count = 0; // local count ::count = 1; // 设置全局的 count 的值为 1
::count = 1; // set global count to 1
count = 2; // set local count to 2 A::count = 2; // 设置类 A 的 count 为 2
return 0;
int count = 0; // 局部的 count
count = 3; // 设置局部的 count 的值为 3
return 0;
} }
``` ```
</details>
### 宏 ### 宏
* 宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对 “参数” 进行的是一对一的替换。 * 宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对 “参数” 进行的是一对一的替换。
@ -509,6 +561,8 @@ public:
* 构造函数不能是虚函数（因为在调用构造函数时，虚表指针并没有在对象的内存空间中，必须要构造函数调用完成后才会形成虚表指针） * 构造函数不能是虚函数（因为在调用构造函数时，虚表指针并没有在对象的内存空间中，必须要构造函数调用完成后才会形成虚表指针）
* 内联函数不能是表现多态性时的虚函数，解释见：[虚函数（virtual）可以是内联函数（inline）吗？](https://github.com/huihut/interview#%E8%99%9A%E5%87%BD%E6%95%B0virtual%E5%8F%AF%E4%BB%A5%E6%98%AF%E5%86%85%E8%81%94%E5%87%BD%E6%95%B0inline%E5%90%97) * 内联函数不能是表现多态性时的虚函数，解释见：[虚函数（virtual）可以是内联函数（inline）吗？](https://github.com/huihut/interview#%E8%99%9A%E5%87%BD%E6%95%B0virtual%E5%8F%AF%E4%BB%A5%E6%98%AF%E5%86%85%E8%81%94%E5%87%BD%E6%95%B0inline%E5%90%97)
<details><summary>动态多态使用</summary>
```cpp ```cpp
class Shape // 形状类 class Shape // 形状类
{ {
@ -545,7 +599,13 @@ int main()
} }
``` ```
* 虚析构函数 </details>
### 虚析构函数
虚析构函数是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象。
<details><summary>虚析构函数使用</summary>
```cpp ```cpp
class Shape class Shape
@ -571,33 +631,16 @@ int main()
} }
``` ```
* 纯虚函数 （含有纯虚函数的类叫做抽象类） </details>
### 纯虚函数
纯虚函数是一种特殊的虚函数，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。
```cpp ```cpp
virtual int A() = 0; virtual int A() = 0;
``` ```
### 抽象类、接口类、聚合类
* 抽象类：含有纯虚函数的类
* 接口类：仅含有纯虚函数的抽象类
* 聚合类：用户可以直接访问其成员，并且具有特殊的初始化语法形式。满足如下特点：
* 所有成员都是 public
* 没有有定于任何构造函数
* 没有类内初始化
* 没有基类，也没有 virtual 函数
* 如：
```cpp
// 定义
struct Date
{
int ival;
string s;
}
// 初始化
Data vall = { 0, "Anna" };
```
### 虚函数、纯虚函数 ### 虚函数、纯虚函数
[CSDN . C++ 中的虚函数、纯虚函数区别和联系](https://blog.csdn.net/u012260238/article/details/53610462) [CSDN . C++ 中的虚函数、纯虚函数区别和联系](https://blog.csdn.net/u012260238/article/details/53610462)
@ -612,9 +655,7 @@ virtual int A() = 0;
* 虚函数指针：在含有虚函数类的对象中，指向虚函数表，在运行时确定。 * 虚函数指针：在含有虚函数类的对象中，指向虚函数表，在运行时确定。
* 虚函数表：在程序只读数据段（`.rodata section`，见：[目标文件存储结构](#%E7%9B%AE%E6%A0%87%E6%96%87%E4%BB%B6%E5%AD%98%E5%82%A8%E7%BB%93%E6%9E%84)），存放虚函数指针，如果派生类实现了基类的某个虚函数，则在虚表中覆盖原本基类的那个虚函数指针，在编译时根据类的声明创建。 * 虚函数表：在程序只读数据段（`.rodata section`，见：[目标文件存储结构](#%E7%9B%AE%E6%A0%87%E6%96%87%E4%BB%B6%E5%AD%98%E5%82%A8%E7%BB%93%E6%9E%84)），存放虚函数指针，如果派生类实现了基类的某个虚函数，则在虚表中覆盖原本基类的那个虚函数指针，在编译时根据类的声明创建。
### 虚继承、虚函数 ### 虚继承
#### 虚继承
虚继承用于解决多继承条件下的菱形继承问题（浪费存储空间、存在二义性）。 虚继承用于解决多继承条件下的菱形继承问题（浪费存储空间、存在二义性）。
@ -622,7 +663,7 @@ virtual int A() = 0;
实际上，vbptr 指的是虚基类表指针（virtual base table pointer），该指针指向了一个虚基类表（virtual table），虚表中记录了虚基类与本类的偏移地址；通过偏移地址，这样就找到了虚基类成员，而虚继承也不用像普通多继承那样维持着公共基类（虚基类）的两份同样的拷贝，节省了存储空间。 实际上，vbptr 指的是虚基类表指针（virtual base table pointer），该指针指向了一个虚基类表（virtual table），虚表中记录了虚基类与本类的偏移地址；通过偏移地址，这样就找到了虚基类成员，而虚继承也不用像普通多继承那样维持着公共基类（虚基类）的两份同样的拷贝，节省了存储空间。
#### 虚继承与虚函数 ### 虚继承、虚函数
* 相同之处：都利用了虚指针（均占用类的存储空间）和虚表（均不占用类的存储空间） * 相同之处：都利用了虚指针（均占用类的存储空间）和虚表（均不占用类的存储空间）
* 不同之处： * 不同之处：
@ -633,6 +674,16 @@ virtual int A() = 0;
* 虚函数不占用存储空间 * 虚函数不占用存储空间
* 虚函数表存储的是虚函数地址 * 虚函数表存储的是虚函数地址
### 抽象类、接口类、聚合类
* 抽象类：含有纯虚函数的类
* 接口类：仅含有纯虚函数的抽象类
* 聚合类：用户可以直接访问其成员，并且具有特殊的初始化语法形式。满足如下特点：
* 所有成员都是 public
* 没有有定于任何构造函数
* 没有类内初始化
* 没有基类，也没有 virtual 函数
### 内存分配和管理 ### 内存分配和管理
#### malloc、calloc、realloc、alloca #### malloc、calloc、realloc、alloca
@ -644,6 +695,10 @@ virtual int A() = 0;
#### malloc、free #### malloc、free
用于分配、释放内存
<details><summary>malloc、free 使用</summary>
申请内存，确认是否申请成功 申请内存，确认是否申请成功
```cpp ```cpp
@ -658,12 +713,18 @@ free(p);
p = nullptr; p = nullptr;
``` ```
</details>
#### new、delete #### new、delete
1. new/new[]：完成两件事，先底层调用 malloc 分了配内存，然后调用构造函数（创建对象）。 1. new/new[]：完成两件事，先底层调用 malloc 分了配内存，然后调用构造函数（创建对象）。
2. delete/delete[]：也完成两件事，先调用析构函数（清理资源），然后底层调用 free 释放空间。 2. delete/delete[]：也完成两件事，先调用析构函数（清理资源），然后底层调用 free 释放空间。
3. new 在申请内存时会自动计算所需字节数，而 malloc 则需我们自己输入申请内存空间的字节数。 3. new 在申请内存时会自动计算所需字节数，而 malloc 则需我们自己输入申请内存空间的字节数。
<details><summary>new、delete 使用</summary>
申请内存，确认是否申请成功
```cpp ```cpp
int main() int main()
{ {
@ -673,7 +734,9 @@ int main()
} }
``` ```
##### delete this 合法吗？ </details>
### delete this 合法吗？
[Is it legal (and moral) for a member function to say delete this?](https://isocpp.org/wiki/faq/freestore-mgmt#delete-this) [Is it legal (and moral) for a member function to say delete this?](https://isocpp.org/wiki/faq/freestore-mgmt#delete-this)
@ -684,17 +747,17 @@ int main()
3. 必须保证成员函数的 `delete this ` 后面没有调用 this 了 3. 必须保证成员函数的 `delete this ` 后面没有调用 this 了
4. 必须保证 `delete this` 后没有人使用了 4. 必须保证 `delete this` 后没有人使用了
#### 如何定义一个只能在堆上（栈上）生成对象的类？ ### 如何定义一个只能在堆上（栈上）生成对象的类？
[如何定义一个只能在堆上（栈上）生成对象的类?](https://www.nowcoder.com/questionTerminal/0a584aa13f804f3ea72b442a065a7618) [如何定义一个只能在堆上（栈上）生成对象的类?](https://www.nowcoder.com/questionTerminal/0a584aa13f804f3ea72b442a065a7618)
##### 只能在堆上 #### 只能在堆上
方法：将析构函数设置为私有 方法：将析构函数设置为私有
原因：C++ 是静态绑定语言，编译器管理栈上对象的生命周期，编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性。若析构函数不可访问，则不能在栈上创建对象。 原因：C++ 是静态绑定语言，编译器管理栈上对象的生命周期，编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性。若析构函数不可访问，则不能在栈上创建对象。
##### 只能在栈上 #### 只能在栈上
方法：将 new 和 delete 重载为私有 方法：将 new 和 delete 重载为私有
@ -787,6 +850,8 @@ unique_ptr 是 C++11 才开始提供的类型，是一种在异常时可以帮
* 由于强制转换为引用类型失败，dynamic_cast 运算符引发 bad_cast 异常。 * 由于强制转换为引用类型失败，dynamic_cast 运算符引发 bad_cast 异常。
<details><summary>bad_cast 使用</summary>
```cpp ```cpp
try { try {
Circle& ref_circle = dynamic_cast<Circle&>(ref_shape); Circle& ref_circle = dynamic_cast<Circle&>(ref_shape);
@ -796,6 +861,8 @@ catch (bad_cast b) {
} }
``` ```
</details>
### 运行时类型信息 (RTTI) ### 运行时类型信息 (RTTI)
#### dynamic_cast #### dynamic_cast
@ -814,7 +881,7 @@ catch (bad_cast b) {
* type_info 类描述编译器在程序中生成的类型信息。 此类的对象可以有效存储指向类型的名称的指针。 type_info 类还可存储适合比较两个类型是否相等或比较其排列顺序的编码值。 类型的编码规则和排列顺序是未指定的，并且可能因程序而异。 * type_info 类描述编译器在程序中生成的类型信息。 此类的对象可以有效存储指向类型的名称的指针。 type_info 类还可存储适合比较两个类型是否相等或比较其排列顺序的编码值。 类型的编码规则和排列顺序是未指定的，并且可能因程序而异。
* 头文件：`typeinfo` * 头文件：`typeinfo`
#### 例子 <details><summary>typeid、type_info 使用</summary>
```cpp ```cpp
class Flyable // 能飞的 class Flyable // 能飞的
@ -866,6 +933,8 @@ class doSomething(Flyable *obj) // 做些事情
}; };
``` ```
</details>
### Effective C++ ### Effective C++
1. 视 C++ 为一个语言联邦（C、Object-Oriented C++、Template C++、STL） 1. 视 C++ 为一个语言联邦（C、Object-Oriented C++、Template C++、STL）
@ -900,10 +969,14 @@ class doSomething(Flyable *obj) // 做些事情
### Google C++ Style Guide ### Google C++ Style Guide
<details><summary>Google C++ Style Guide 图</summary>
![Google C++ Style Guide](http://img.blog.csdn.net/20140713220242000) ![Google C++ Style Guide](http://img.blog.csdn.net/20140713220242000)
> 图片来源于：[CSDN . 一张图总结Google C++编程规范(Google C++ Style Guide)](http://blog.csdn.net/voidccc/article/details/37599203) > 图片来源于：[CSDN . 一张图总结Google C++编程规范(Google C++ Style Guide)](http://blog.csdn.net/voidccc/article/details/37599203)
</details>
## STL ## STL
### 索引 ### 索引
@ -943,6 +1016,8 @@ hash_multimap|hash表|无序|可重复|
[SqStack.cpp](DataStructure/SqStack.cpp) [SqStack.cpp](DataStructure/SqStack.cpp)
<details><summary>顺序栈数据结构和图片</summary>
```cpp ```cpp
typedef struct { typedef struct {
ElemType *elem; ElemType *elem;
@ -954,8 +1029,12 @@ typedef struct {
![](images/SqStack.png) ![](images/SqStack.png)
</details>
#### 队列（Sequence Queue） #### 队列（Sequence Queue）
<details><summary>队列数据结构</summary>
```cpp ```cpp
typedef struct { typedef struct {
ElemType * elem; ElemType * elem;
@ -965,22 +1044,34 @@ typedef struct {
}SqQueue; }SqQueue;
``` ```
</details>
##### 非循环队列 ##### 非循环队列
<details><summary>非循环队列图片</summary>
![](images/SqQueue.png) ![](images/SqQueue.png)
`SqQueue.rear++` `SqQueue.rear++`
</details>
##### 循环队列 ##### 循环队列
<details><summary>循环队列图片</summary>
![](images/SqLoopStack.png) ![](images/SqLoopStack.png)
`SqQueue.rear = (SqQueue.rear + 1) % SqQueue.maxSize` `SqQueue.rear = (SqQueue.rear + 1) % SqQueue.maxSize`
</details>
#### 顺序表（Sequence List） #### 顺序表（Sequence List）
[SqList.cpp](DataStructure/SqList.cpp) [SqList.cpp](DataStructure/SqList.cpp)
<details><summary>顺序表数据结构和图片</summary>
```cpp ```cpp
typedef struct { typedef struct {
ElemType *elem; ElemType *elem;
@ -992,12 +1083,17 @@ typedef struct {
![](images/SqList.png) ![](images/SqList.png)
</details>
### 链式结构 ### 链式结构
[LinkList.cpp](DataStructure/LinkList.cpp) [LinkList.cpp](DataStructure/LinkList.cpp)
[LinkList_with_head.cpp](DataStructure/LinkList_with_head.cpp) [LinkList_with_head.cpp](DataStructure/LinkList_with_head.cpp)
<details><summary>链式数据结构</summary>
```cpp ```cpp
typedef struct LNode { typedef struct LNode {
ElemType data; ElemType data;
@ -1005,24 +1101,43 @@ typedef struct LNode {
} LNode, *LinkList; } LNode, *LinkList;
``` ```
</details>
#### 链队列（Link Queue） #### 链队列（Link Queue）
<details><summary>链队列图片</summary>
![](images/LinkQueue.png) ![](images/LinkQueue.png)
</details>
#### 线性表的链式表示 #### 线性表的链式表示
##### 单链表（Link List） ##### 单链表（Link List）
<details><summary>单链表图片</summary>
![](images/LinkList.png) ![](images/LinkList.png)
</details>
##### 双向链表（Du-Link-List） ##### 双向链表（Du-Link-List）
<details><summary>双向链表图片</summary>
![](images/DuLinkList.png) ![](images/DuLinkList.png)
</details>
##### 循环链表（Cir-Link-List） ##### 循环链表（Cir-Link-List）
<details><summary>循环链表图片</summary>
![](images/CirLinkList.png) ![](images/CirLinkList.png)
</details>
### 哈希表 ### 哈希表
[HashTable.cpp](DataStructure/HashTable.cpp) [HashTable.cpp](DataStructure/HashTable.cpp)
@ -1049,8 +1164,9 @@ typedef struct LNode {
#### 线性探测的哈希表数据结构 #### 线性探测的哈希表数据结构
```cpp <details><summary>线性探测的哈希表数据结构和图片</summary>
```cpp
typedef char KeyType; typedef char KeyType;
typedef struct { typedef struct {
@ -1064,8 +1180,12 @@ typedef struct {
bool *tag; bool *tag;
}HashTable; }HashTable;
``` ```
![](images/HashTable.png) ![](images/HashTable.png)
</details>
### 递归 ### 递归
#### 概念 #### 概念
@ -1091,6 +1211,8 @@ typedef struct {
##### 头尾链表存储表示 ##### 头尾链表存储表示
<details><summary>广义表的头尾链表存储表示和图片</summary>
```cpp ```cpp
// 广义表的头尾链表存储表示 // 广义表的头尾链表存储表示
typedef enum {ATOM, LIST} ElemTag; typedef enum {ATOM, LIST} ElemTag;
@ -1112,8 +1234,12 @@ typedef struct GLNode {
![](images/GeneralizedList1.png) ![](images/GeneralizedList1.png)
</details>
##### 扩展线性链表存储表示 ##### 扩展线性链表存储表示
<details><summary>扩展线性链表存储表示和图片</summary>
```cpp ```cpp
// 广义表的扩展线性链表存储表示 // 广义表的扩展线性链表存储表示
typedef enum {ATOM, LIST} ElemTag; typedef enum {ATOM, LIST} ElemTag;
@ -1133,6 +1259,8 @@ typedef struct GLNode1 {
![](images/GeneralizedList2.png) ![](images/GeneralizedList2.png)
</details>
### 二叉树 ### 二叉树
[BinaryTree.cpp](DataStructure/BinaryTree.cpp) [BinaryTree.cpp](DataStructure/BinaryTree.cpp)
@ -1150,6 +1278,8 @@ typedef struct GLNode1 {
#### 存储结构 #### 存储结构
<details><summary>二叉树数据结构</summary>
```cpp ```cpp
typedef struct BiTNode typedef struct BiTNode
{ {
@ -1158,14 +1288,25 @@ typedef struct BiTNode
}BiTNode, *BiTree; }BiTNode, *BiTree;
``` ```
</details>
##### 顺序存储 ##### 顺序存储
<details><summary>二叉树顺序存储图片</summary>
![](images/SqBinaryTree.png) ![](images/SqBinaryTree.png)
</details>
##### 链式存储 ##### 链式存储
<details><summary>二叉树链式存储图片</summary>
![](images/LinkBinaryTree.png) ![](images/LinkBinaryTree.png)
</details>
#### 遍历方式 #### 遍历方式
* 先序遍历 * 先序遍历
@ -1207,8 +1348,12 @@ typedef struct BiTNode
* 平衡二叉树必定是二叉搜索树，反之则不一定 * 平衡二叉树必定是二叉搜索树，反之则不一定
* 最小二叉平衡树的节点的公式：`F(n)=F(n-1)+F(n-2)+1` （1 是根节点，F(n-1) 是左子树的节点数量，F(n-2) 是右子树的节点数量） * 最小二叉平衡树的节点的公式：`F(n)=F(n-1)+F(n-2)+1` （1 是根节点，F(n-1) 是左子树的节点数量，F(n-2) 是右子树的节点数量）
<details><summary>平衡二叉树图片</summary>
![](images/Self-balancingBinarySearchTree.png) ![](images/Self-balancingBinarySearchTree.png)
</details>
##### 最小失衡树 ##### 最小失衡树
平衡二叉树插入新结点导致失衡的子树 平衡二叉树插入新结点导致失衡的子树
@ -1247,8 +1392,12 @@ typedef struct BiTNode
#### B 树（B-tree）、B+ 树（B+-tree） #### B 树（B-tree）、B+ 树（B+-tree）
<details><summary>B 树、B+ 树图片</summary>
![B 树（B-tree）、B+ 树（B+-tree）](https://i.stack.imgur.com/l6UyF.png) ![B 树（B-tree）、B+ 树（B+-tree）](https://i.stack.imgur.com/l6UyF.png)
</details>
##### 特点 ##### 特点
* 一般化的二叉查找树（binary search tree） * 一般化的二叉查找树（binary search tree）
@ -1276,8 +1425,12 @@ typedef struct BiTNode
#### 八叉树 #### 八叉树
<details><summary>八叉树图片</summary>
![](https://upload.wikimedia.org/wikipedia/commons/thumb/3/35/Octree2.png/400px-Octree2.png) ![](https://upload.wikimedia.org/wikipedia/commons/thumb/3/35/Octree2.png/400px-Octree2.png)
</details>
八叉树（octree），或称八元树，是一种用于描述三维空间（划分空间）的树状数据结构。八叉树的每个节点表示一个正方体的体积元素，每个节点有八个子节点，这八个子节点所表示的体积元素加在一起就等于父节点的体积。一般中心点作为节点的分叉中心。 八叉树（octree），或称八元树，是一种用于描述三维空间（划分空间）的树状数据结构。八叉树的每个节点表示一个正方体的体积元素，每个节点有八个子节点，这八个子节点所表示的体积元素加在一起就等于父节点的体积。一般中心点作为节点的分叉中心。
##### 用途 ##### 用途
@ -1524,11 +1677,18 @@ B树/B+树 |O(log<sub>2</sub>n) | |
大端|12|34|56|78 大端|12|34|56|78
小端|78|56|34|12 小端|78|56|34|12
<details><summary>大端小端图片</summary>
![大端序](images/CPU-Big-Endian.svg.png) ![大端序](images/CPU-Big-Endian.svg.png)
![小端序](images/CPU-Little-Endian.svg.png) ![小端序](images/CPU-Little-Endian.svg.png)
</details>
##### 判断大端小端 ##### 判断大端小端
<details><summary>判断大端小端</summary>
可以这样判断自己 CPU 字节序是大端还是小端： 可以这样判断自己 CPU 字节序是大端还是小端：
```cpp ```cpp
@ -1547,6 +1707,9 @@ int main()
return 0; return 0;
} }
``` ```
</details>
##### 各架构处理器的字节序 ##### 各架构处理器的字节序
* x86（Intel、AMD）、MOS Technology 6502、Z80、VAX、PDP-11 等处理器为小端序； * x86（Intel、AMD）、MOS Technology 6502、Z80、VAX、PDP-11 等处理器为小端序；
@ -1860,8 +2023,12 @@ TCP 是一个基于字节流的传输服务（UDP 基于报文的），“流”
#### TCP 有限状态机 #### TCP 有限状态机
<details><summary>TCP 有限状态机图片</summary>
![TCP 的有限状态机](images/TCP的有限状态机.png) ![TCP 的有限状态机](images/TCP的有限状态机.png)
</details>
### 应用层 ### 应用层
#### DNS #### DNS
@ -2199,6 +2366,8 @@ Linux 下的共享库就是普通的 ELF 共享对象。
### Windows 的动态链接库（Dynamic-Link Library） ### Windows 的动态链接库（Dynamic-Link Library）
<details><summary>Windows 动态链接库例子</summary>
DLL 头文件 DLL 头文件
```cpp ```cpp
#ifdef __cplusplus #ifdef __cplusplus
@ -2234,6 +2403,8 @@ MODULE_API int module_init()
} }
``` ```
</details>
### 运行库（Runtime Library） ### 运行库（Runtime Library）
#### 典型程序运行步骤 #### 典型程序运行步骤