StarMirror/CS-Notes
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

auto commit

Browse Source
This commit is contained in:
CyC2018 2019-03-08 21:56:42 +08:00
parent ce05657a6c
commit 722b67a3c7
19 changed files with 67 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/notes/Java 基础.md
View File

@ -51,7 +51,7 @@
- float/32
- long/64
- double/64
- boolean/~
- boolean/\~
boolean 只有两个值：true、false，可以使用 1 bit 来存储，但是具体大小没有明确规定。JVM 会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false。JVM 并不直接支持 boolean 数组，而是使用 byte 数组来表示 int 数组来表示。
@ -93,7 +93,7 @@ public static Integer valueOf(int i) {
}
```
在 Java 8 中，Integer 缓存池的大小默认为 -128~127。
在 Java 8 中，Integer 缓存池的大小默认为 -128\~127。
```java
static final int low = -128;

2
docs/notes/Leetcode 题解 - 二分查找.md
View File

@ -112,7 +112,7 @@ Output: 2
Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.
```
一个数 x 的开方 sqrt 一定在 0 ~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 ~ x 之间查找 sqrt。
一个数 x 的开方 sqrt 一定在 0 \~ x 之间，并且满足 sqrt == x / sqrt。可以利用二分查找在 0 \~ x 之间查找 sqrt。
对于 x = 8，它的开方是 2.82842...，最后应该返回 2 而不是 3。在循环条件为 l <= h 并且循环退出时，h 总是比 l 小 1，也就是说 h = 2，l = 3，因此最后的返回值应该为 h 而不是 l。

12
docs/notes/Leetcode 题解 - 位运算.md
View File

@ -16,7 +16,7 @@
* [求一个数的补码](#求一个数的补码)
* [实现整数的加法](#实现整数的加法)
* [字符串数组最大乘积](#字符串数组最大乘积)
* [统计从 0 ~ n 每个数的二进制表示中 1 的个数](#统计从-0-~-n-每个数的二进制表示中-1-的个数)
* [统计从 0 \~ n 每个数的二进制表示中 1 的个数](#统计从-0-\~-n-每个数的二进制表示中-1-的个数)
<!-- GFM-TOC -->
@ -32,7 +32,7 @@ x ^ 1s = ~x x & 1s = x x | 1s = 1s
x ^ x = 0 x & x = x x | x = x
```
- 利用 x ^ 1s = ~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
- 利用 x ^ 1s = \~x 的特点，可以将位级表示翻转；利用 x ^ x = 0 的特点，可以将三个数中重复的两个数去除，只留下另一个数。
- 利用 x & 0s = 0 和 x & 1s = x 的特点，可以实现掩码操作。一个数 num 与 mask：00111100 进行位与操作，只保留 num 中与 mask 的 1 部分相对应的位。
- 利用 x | 0s = x 和 x | 1s = 1s 的特点，可以实现设值操作。一个数 num 与 mask：00111100 进行位或操作，将 num 中与 mask 的 1 部分相对应的位都设置为 1。
@ -40,7 +40,7 @@ x ^ x = 0 x & x = x x | x = x
- n&(n-1) 去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110100，减去 1 得到 10110011，这两个数相与得到 10110000。
- n&(-n) 得到 n 的位级表示中最低的那一位。-n 得到 n 的反码加 1，对于二进制表示 10110100，-n 得到 01001100，相与得到 00000100。
- n-n&(~n+1) 去除 n 的位级表示中最高的那一位。
- n-n&(\~n+1) 去除 n 的位级表示中最高的那一位。
移位运算：
@ -50,13 +50,13 @@ x ^ x = 0 x & x = x x | x = x
## 2. mask 计算
要获取 111111111，将 0 取反即可，~0。
要获取 111111111，将 0 取反即可，\~0。
要得到只有第 i 位为 1 的 mask，将 1 向左移动 i-1 位即可，1&lt;&lt;(i-1) 。例如 1&lt;&lt;4 得到只有第 5 位为 1 的 mask ：00010000。
要得到 1 到 i 位为 1 的 mask，1&lt;&lt;(i+1)-1 即可，例如将 1&lt;&lt;(4+1)-1 = 00010000-1 = 00001111。
要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 ~(1&lt;&lt;(i+1)-1)。
要得到 1 到 i 位为 0 的 mask，只需将 1 到 i 位为 1 的 mask 取反，即 \~(1&lt;&lt;(i+1)-1)。
## 3. Java 中的位操作
@ -409,7 +409,7 @@ public int maxProduct(String[] words) {
}
```
## 统计从 0 ~ n 每个数的二进制表示中 1 的个数
## 统计从 0 \~ n 每个数的二进制表示中 1 的个数
[338. Counting Bits (Medium)](https://leetcode.com/problems/counting-bits/description/)

2
docs/notes/Leetcode 题解 - 动态规划.md
View File

@ -246,7 +246,7 @@ sumRange(2, 5) -> -1
sumRange(0, 5) -> -3
```
求区间 i ~ j 的和，可以转换为 sum[j + 1] - sum[i]，其中 sum[i] 为 0 ~ i - 1 的和。
求区间 i \~ j 的和，可以转换为 sum[j + 1] - sum[i]，其中 sum[i] 为 0 \~ i - 1 的和。
```java
class NumArray {

2
docs/notes/Leetcode 题解 - 数组与矩阵.md
View File

@ -276,7 +276,7 @@ Output: [1, 3, 2]
Explanation: The [1, 3, 2] has three different positive integers ranging from 1 to 3, and the [2, 1] has exactly 2 distinct integers: 1 and 2.
```
题目描述：数组元素为 1~n 的整数，要求构建数组，使得相邻元素的差值不相同的个数为 k。
题目描述：数组元素为 1\~n 的整数，要求构建数组，使得相邻元素的差值不相同的个数为 k。
让前 k+1 个元素构建出 k 个不相同的差值，序列为：1 k+1 2 k 3 k-1 ... k/2 k/2+1.

2
docs/notes/Leetcode 题解 - 树.md
View File

@ -649,7 +649,7 @@ Output:
1
```
题目描述：只保留值在 L ~ R 之间的节点
题目描述：只保留值在 L \~ R 之间的节点
```java
public TreeNode trimBST(TreeNode root, int L, int R) {

2
docs/notes/Linux.md
View File

@ -1242,6 +1242,6 @@ options 参数主要有 WNOHANG 和 WUNTRACED 两个选项，WNOHANG 可以使 w
- [硬盘](https://zh.wikipedia.org/wiki/%E7%A1%AC%E7%9B%98)
- [Difference between SAS and SATA](http://www.differencebetween.info/difference-between-sas-and-sata)
- [BIOS](https://zh.wikipedia.org/wiki/BIOS)
- [File system design case studies](https://www.cs.rutgers.edu/~pxk/416/notes/13-fs-studies.html)
- [File system design case studies](https://www.cs.rutgers.edu/\~pxk/416/notes/13-fs-studies.html)
- [Programming Project #4](https://classes.soe.ucsc.edu/cmps111/Fall08/proj4.shtml)
- [FILE SYSTEM DESIGN](http://web.cs.ucla.edu/classes/fall14/cs111/scribe/11a/index.html)

2
docs/notes/Redis.md
View File

@ -557,7 +557,7 @@ Sentinel（哨兵）可以监听集群中的服务器，并在主服务器进入
假设有 4 个 Reids 实例 R0，R1，R2，R3，还有很多表示用户的键 user:1，user:2，... ，有不同的方式来选择一个指定的键存储在哪个实例中。
- 最简单的方式是范围分片，例如用户 id 从 0~1000 的存储到实例 R0 中，用户 id 从 1001~2000 的存储到实例 R1 中，等等。但是这样需要维护一张映射范围表，维护操作代价很高。
- 最简单的方式是范围分片，例如用户 id 从 0\~1000 的存储到实例 R0 中，用户 id 从 1001\~2000 的存储到实例 R1 中，等等。但是这样需要维护一张映射范围表，维护操作代价很高。
- 还有一种方式是哈希分片，使用 CRC32 哈希函数将键转换为一个数字，再对实例数量求模就能知道应该存储的实例。
根据执行分片的位置，可以分为三种分片方式：

2
docs/notes/SQL.md
View File

@ -162,7 +162,7 @@ FROM mytable
LIMIT 0, 5;
```
返回第 3 ~ 5 行：
返回第 3 \~ 5 行：
```sql
SELECT *

2
docs/notes/分布式.md
View File

@ -281,7 +281,7 @@ Raft 也是分布式一致性协议，主要是用来竞选主节点。
## 单个 Candidate 的竞选
有三种节点：Follower、Candidate 和 Leader。Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间，一般为 150ms~300ms，如果在这个时间内没有收到 Leader 的心跳包，就会变成 Candidate，进入竞选阶段。
有三种节点：Follower、Candidate 和 Leader。Leader 会周期性的发送心跳包给 Follower。每个 Follower 都设置了一个随机的竞选超时时间，一般为 150ms\~300ms，如果在这个时间内没有收到 Leader 的心跳包，就会变成 Candidate，进入竞选阶段。
- 下图展示一个分布式系统的最初阶段，此时只有 Follower 没有 Leader。Node A 等待一个随机的竞选超时时间之后，没收到 Leader 发来的心跳包，因此进入竞选阶段。

2
docs/notes/剑指 Offer 题解 - 10~19.md
View File

@ -591,7 +591,7 @@ private void printNumber(char[] number) {
<div align="center"> <img src="pics/280f7728-594f-4811-a03a-fa8d32c013da.png" width="600"/> </div><br>
综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N ~ 2，因此该算法的平均时间复杂度为 O(1)。
综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N \~ 2，因此该算法的平均时间复杂度为 O(1)。
```java
public ListNode deleteNode(ListNode head, ListNode tobeDelete) {

2
docs/notes/剑指 Offer 题解 - 40~49.md
View File

@ -382,7 +382,7 @@ public int getMost(int[][] values) {
## 题目描述
输入一个字符串（只包含 a~z 的字符），求其最长不含重复字符的子字符串的长度。例如对于 arabcacfr，最长不含重复字符的子字符串为 acfr，长度为 4。
输入一个字符串（只包含 a\~z 的字符），求其最长不含重复字符的子字符串的长度。例如对于 arabcacfr，最长不含重复字符的子字符串为 acfr，长度为 4。
## 解题思路

22
docs/notes/剑指 Offer 题解 - 目录.md
View File

@ -1,15 +1,21 @@
<!-- GFM-TOC -->
* [目录](#目录)
* [参考文献](#参考文献)
<!-- GFM-TOC -->
# 目录
部分绘图文件可以在这里免费下载：[剑指 Offer](https://www.processon.com/view/5a3e4c7be4b0909c1aa18b49)，后续会慢慢把所有题目都配上 GIF 演示图。
- [0~9](剑指%20Offer%20题解%20-%200~9.md)
- [10~19](剑指%20Offer%20题解%20-%2010~19.md)
- [20~29](剑指%20Offer%20题解%20-%2020~29.md)
- [30~39](剑指%20Offer%20题解%20-%2030~39.md)
- [40~49](剑指%20Offer%20题解%20-%2040~49.md)
- [50~59](剑指%20Offer%20题解%20-%2050~59.md)
- [60~68](剑指%20Offer%20题解%20-%2060~68.md)
- [0\~9](剑指%20Offer%20题解%20-%200\~9.md)
- [10\~19](剑指%20Offer%20题解%20-%2010\~19.md)
- [20\~29](剑指%20Offer%20题解%20-%2020\~29.md)
- [30\~39](剑指%20Offer%20题解%20-%2030\~39.md)
- [40\~49](剑指%20Offer%20题解%20-%2040\~49.md)
- [50\~59](剑指%20Offer%20题解%20-%2050\~59.md)
- [60\~68](剑指%20Offer%20题解%20-%2060\~68.md)
参考文献：何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.
# 参考文献
何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.

23
docs/notes/剑指 Offer 题解 - 目录1.md
View File

@ -1,16 +1,21 @@
<!-- GFM-TOC -->
- 1
* [目录](#目录)
* [参考文献](#参考文献)
<!-- GFM-TOC -->
# 目录
部分绘图文件可以在这里免费下载：[剑指 Offer](https://www.processon.com/view/5a3e4c7be4b0909c1aa18b49)，后续会慢慢把所有题目都配上 GIF 演示图。
- [0~9](notes/剑指%20Offer%20题解%20-%200~9.md)
- [10~19](notes/剑指%20Offer%20题解%20-%2010~19.md)
- [20~29](notes/剑指%20Offer%20题解%20-%2020~29.md)
- [30~39](notes/剑指%20Offer%20题解%20-%2030~39.md)
- [40~49](notes/剑指%20Offer%20题解%20-%2040~49.md)
- [50~59](notes/剑指%20Offer%20题解%20-%2050~59.md)
- [60~68](notes/剑指%20Offer%20题解%20-%2060~68.md)
- [0\~9](notes/剑指%20Offer%20题解%20-%200\~9.md)
- [10\~19](notes/剑指%20Offer%20题解%20-%2010\~19.md)
- [20\~29](notes/剑指%20Offer%20题解%20-%2020\~29.md)
- [30\~39](notes/剑指%20Offer%20题解%20-%2030\~39.md)
- [40\~49](notes/剑指%20Offer%20题解%20-%2040\~49.md)
- [50\~59](notes/剑指%20Offer%20题解%20-%2050\~59.md)
- [60\~68](notes/剑指%20Offer%20题解%20-%2060\~68.md)
参考文献：何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.
# 参考文献
何海涛. 剑指 Offer[M]. 电子工业出版社, 2012.

2
docs/notes/正则表达式.md
View File

@ -130,7 +130,7 @@ abc[^0-9]
**abc.def<span>@</span>qq.com**
- **{n}** 匹配 n 个字符
- **{m, n}** 匹配 m~n 个字符
- **{m, n}** 匹配 m\~n 个字符
- **{m,}** 至少匹配 m 个字符
\* 和 + 都是贪婪型元字符，会匹配最多的内容。在后面加 ? 可以转换为懒惰型元字符，例如 \*?、+? 和 {m, n}? 。

26
docs/notes/算法.md
View File

@ -48,7 +48,7 @@
### 1. 近似
N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 ~ N<sup>3</sup>/6。使用 ~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数。
N<sup>3</sup>/6-N<sup>2</sup>/2+N/3 \~ N<sup>3</sup>/6。使用 \~f(N) 来表示所有随着 N 的增大除以 f(N) 的结果趋近于 1 的函数。
### 2. 增长数量级
@ -96,7 +96,7 @@ public interface ThreeSum {
### 1. ThreeSumSlow
该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N<sup>3</sup>/6-N<sup>2</sup>/2+N/3，因此它的近似执行次数为 ~N<sup>3</sup>/6，增长数量级为 O(N<sup>3</sup>)。
该算法的内循环为 `if (nums[i] + nums[j] + nums[k] == 0)` 语句，总共执行的次数为 N(N-1)(N-2) = N<sup>3</sup>/6-N<sup>2</sup>/2+N/3，因此它的近似执行次数为 \~N<sup>3</sup>/6，增长数量级为 O(N<sup>3</sup>)。
```java
public class ThreeSumSlow implements ThreeSum {
@ -206,9 +206,9 @@ public class ThreeSumTwoPointer implements ThreeSum {
## 倍率实验
如果 T(N) ~ aN<sup>b</sup>logN，那么 T(2N)/T(N) ~ 2<sup>b</sup>。
如果 T(N) \~ aN<sup>b</sup>logN，那么 T(2N)/T(N) \~ 2<sup>b</sup>。
例如对于暴力的 ThreeSum 算法，近似时间为 ~N<sup>3</sup>/6。进行如下实验：多次运行该算法，每次取的 N 值为前一次的两倍，统计每次执行的时间，并统计本次运行时间与前一次运行时间的比值，得到如下结果：
例如对于暴力的 ThreeSum 算法，近似时间为 \~N<sup>3</sup>/6。进行如下实验：多次运行该算法，每次取的 N 值为前一次的两倍，统计每次执行的时间，并统计本次运行时间与前一次运行时间的比值，得到如下结果：
| N | Time(ms) | Ratio |
| :---: | :---: | :---: |
@ -219,7 +219,7 @@ public class ThreeSumTwoPointer implements ThreeSum {
| 8000 | 33575 | 8.2 |
| 16000 | 268909 | 8.0 |
可以看到，T(2N)/T(N) ~ 2<sup>3</sup>，因此可以确定 T(N) ~ aN<sup>3</sup>logN。
可以看到，T(2N)/T(N) \~ 2<sup>3</sup>，因此可以确定 T(N) \~ aN<sup>3</sup>logN。
```java
public class RatioTest {
@ -291,7 +291,7 @@ public abstract class Sort<T extends Comparable<T>> {
选择出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
选择排序需要 ~N<sup>2</sup>/2 次比较和 ~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
选择排序需要 \~N<sup>2</sup>/2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
<div align="center"> <img src="pics/21550397584141.gif"/> </div><br>
@ -350,8 +350,8 @@ public class Bubble<T extends Comparable<T>> extends Sort<T> {
插入排序的复杂度取决于数组的初始顺序，如果数组已经部分有序了，逆序较少，那么插入排序会很快。
- 平均情况下插入排序需要 ~N<sup>2</sup>/4 比较以及 ~N<sup>2</sup>/4 次交换；
- 最坏的情况下需要 ~N<sup>2</sup>/2 比较以及 ~N<sup>2</sup>/2 次交换，最坏的情况是数组是倒序的；
- 平均情况下插入排序需要 \~N<sup>2</sup>/4 比较以及 \~N<sup>2</sup>/4 次交换；
- 最坏的情况下需要 \~N<sup>2</sup>/2 比较以及 \~N<sup>2</sup>/2 次交换，最坏的情况是数组是倒序的；
- 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
以下演示了在一轮循环中，将元素 2 插入到左侧已经排序的数组中。
@ -804,14 +804,14 @@ public class HeapSort<T extends Comparable<T>> extends Sort<T> {
| :---: | :---: |:---: | :---: | :---: |
| 选择排序 | × | N<sup>2</sup> | 1 | |
| 冒泡排序 | √ | N<sup>2</sup> | 1 | |
| 插入排序 | √ | N ~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
| 插入排序 | √ | N \~ N<sup>2</sup> | 1 | 时间复杂度和初始顺序有关 |
| 希尔排序 | × | N 的若干倍乘于递增序列的长度 | 1 | 改进版插入排序 |
| 快速排序 | × | NlogN | logN | |
| 三向切分快速排序 | × | N ~ NlogN | logN | 适用于有大量重复主键|
| 三向切分快速排序 | × | N \~ NlogN | logN | 适用于有大量重复主键|
| 归并排序 | √ | NlogN | N | |
| 堆排序 | × | NlogN | 1 | 无法利用局部性原理|
快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 ~cNlogN，这里的 c 比其它线性对数级别的排序算法都要小。
快速排序是最快的通用排序算法，它的内循环的指令很少，而且它还能利用缓存，因为它总是顺序地访问数据。它的运行时间近似为 \~cNlogN，这里的 c 比其它线性对数级别的排序算法都要小。
使用三向切分快速排序，实际应用中可能出现的某些分布的输入能够达到线性级别，而其它排序算法仍然需要线性对数时间。
@ -2040,7 +2040,7 @@ public class Transaction {
查找需要分两步，首先查找 Key 所在的链表，然后在链表中顺序查找。
对于 N 个键，M 条链表 (N>M)，如果哈希函数能够满足均匀性的条件，每条链表的大小趋向于 N/M，因此未命中的查找和插入操作所需要的比较次数为 ~N/M。
对于 N 个键，M 条链表 (N>M)，如果哈希函数能够满足均匀性的条件，每条链表的大小趋向于 N/M，因此未命中的查找和插入操作所需要的比较次数为 \~N/M。
<div align="center"> <img src="pics/9_200.png"/> </div><br>
@ -2149,7 +2149,7 @@ public void delete(Key key) {
#### 3.5 调整数组大小
线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2~5 位置就是一个聚簇。
线性探测法的成本取决于连续条目的长度，连续条目也叫聚簇。当聚簇很长时，在查找和插入时也需要进行很多次探测。例如下图中 2\~5 位置就是一个聚簇。
<div align="center"> <img src="pics/11_200.png"/> </div><br>

2
docs/notes/缓存.md
View File

@ -247,7 +247,7 @@ CDN 主要有以下优点：
## 顺序分布
将数据划分为多个连续的部分，按数据的 ID 或者时间分布到不同节点上。例如 User 表的 ID 范围为 1 ~ 7000，使用顺序分布可以将其划分成多个子表，对应的主键范围为 1 ~ 1000，1001 ~ 2000，...，6001 ~ 7000。
将数据划分为多个连续的部分，按数据的 ID 或者时间分布到不同节点上。例如 User 表的 ID 范围为 1 \~ 7000，使用顺序分布可以将其划分成多个子表，对应的主键范围为 1 \~ 1000，1001 \~ 2000，...，6001 \~ 7000。
顺序分布相比于哈希分布的主要优点如下：

4
docs/notes/计算机操作系统.md
View File

@ -837,7 +837,7 @@ FIFO 常用于客户-服务器应用程序中，FIFO 用作汇聚点，在客户
为了更好的管理内存，操作系统将内存抽象成地址空间。每个程序拥有自己的地址空间，这个地址空间被分割成多个块，每一块称为一页。这些页被映射到物理内存，但不需要映射到连续的物理内存，也不需要所有页都必须在物理内存中。当程序引用到不在物理内存中的页时，由硬件执行必要的映射，将缺失的部分装入物理内存并重新执行失败的指令。
从上面的描述中可以看出，虚拟内存允许程序不用将地址空间中的每一页都映射到物理内存，也就是说一个程序不需要全部调入内存就可以运行，这使得有限的内存运行大程序成为可能。例如有一台计算机可以产生 16 位地址，那么一个程序的地址空间范围是 0~64K。该计算机只有 32KB 的物理内存，虚拟内存技术允许该计算机运行一个 64K 大小的程序。
从上面的描述中可以看出，虚拟内存允许程序不用将地址空间中的每一页都映射到物理内存，也就是说一个程序不需要全部调入内存就可以运行，这使得有限的内存运行大程序成为可能。例如有一台计算机可以产生 16 位地址，那么一个程序的地址空间范围是 0\~64K。该计算机只有 32KB 的物理内存，虚拟内存技术允许该计算机运行一个 64K 大小的程序。
<div align="center"> <img src="pics/7b281b1e-0595-402b-ae35-8c91084c33c1.png"/> </div><br>
@ -1072,7 +1072,7 @@ gcc -o hello hello.c
- Bryant, R. E., & O’Hallaron, D. R. (2004). 深入理解计算机系统.
- 史蒂文斯. UNIX 环境高级编程 [M]. 人民邮电出版社, 2014.
- [Operating System Notes](https://applied-programming.github.io/Operating-Systems-Notes/)
- [Operating-System Structures](https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/2_Structures.html)
- [Operating-System Structures](https://www.cs.uic.edu/\~jbell/CourseNotes/OperatingSystems/2_Structures.html)
- [Processes](http://cse.csusb.edu/tongyu/courses/cs460/notes/process.php)
- [Inter Process Communication Presentation[1]](https://www.slideshare.net/rkolahalam/inter-process-communication-presentation1)
- [Decoding UCS Invicta – Part 1](https://blogs.cisco.com/datacenter/decoding-ucs-invicta-part-1)

8
docs/notes/计算机网络.md
View File

@ -476,9 +476,9 @@ Traceroute 发送的 IP 数据报封装的是无法交付的 UDP 用户数据报
有三个专用地址块：
- 10.0.0.0 ~ 10.255.255.255
- 172.16.0.0 ~ 172.31.255.255
- 192.168.0.0 ~ 192.168.255.255
- 10.0.0.0 \~ 10.255.255.255
- 172.16.0.0 \~ 172.31.255.255
- 192.168.0.0 \~ 192.168.255.255
VPN 使用公用的互联网作为本机构各专用网之间的通信载体。专用指机构内的主机只与本机构内的其它主机通信；虚拟指好像是，而实际上并不是，它有经过公用的互联网。
@ -747,7 +747,7 @@ FTP 使用 TCP 进行连接，它需要两个连接来传送一个文件：
根据数据连接是否是服务器端主动建立，FTP 有主动和被动两种模式：
- 主动模式：服务器端主动建立数据连接，其中服务器端的端口号为 20，客户端的端口号随机，但是必须大于 1024，因为 0~1023 是熟知端口号。
- 主动模式：服务器端主动建立数据连接，其中服务器端的端口号为 20，客户端的端口号随机，但是必须大于 1024，因为 0\~1023 是熟知端口号。
<div align="center"> <img src="pics/03f47940-3843-4b51-9e42-5dcaff44858b.jpg"/> </div><br>