diff --git a/.gitattributes b/.gitattributes
deleted file mode 100644
index b634d85..0000000
--- a/.gitattributes
+++ /dev/null
@@ -1 +0,0 @@
-*.pdf filter=lfs diff=lfs merge=lfs -text
diff --git a/408Exam/README.md b/408Exam/README.md
new file mode 100644
index 0000000..af277ea
--- /dev/null
+++ b/408Exam/README.md
@@ -0,0 +1,4 @@
+# 408 真题
+
+下载链接：
+http://caiyun.feixin.10086.cn/dl/1A5CvuwAc1oIk  提取密码:9vSD
\ No newline at end of file
diff --git a/ComputerNetwork/PPT/计网第一章.pdf b/ComputerNetwork/PPT/计网第一章.pdf
new file mode 100644
index 0000000..dd68afe
--- /dev/null
+++ b/ComputerNetwork/PPT/计网第一章.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c48abad020cfb3dcb229b5f8fd233be0e14d54b01e19192b32abf1eb9bd62ef9
+size 22143201
diff --git a/ComputerNetwork/PPT/计网第三章.pdf b/ComputerNetwork/PPT/计网第三章.pdf
new file mode 100644
index 0000000..a1dfe7d
--- /dev/null
+++ b/ComputerNetwork/PPT/计网第三章.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a350af213ce1757610b06ad4ce284602deaaa98945ce94ccd49ce91ba756b9e
+size 21956743
diff --git a/ComputerNetwork/PPT/计网第二章.pdf b/ComputerNetwork/PPT/计网第二章.pdf
new file mode 100644
index 0000000..5a2c244
--- /dev/null
+++ b/ComputerNetwork/PPT/计网第二章.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7df0ffcd730ad9410502953eeddd3649807a6d95edc7a491f2a3758436185086
+size 7914736
diff --git a/ComputerNetwork/PPT/计网第五章.pdf b/ComputerNetwork/PPT/计网第五章.pdf
new file mode 100644
index 0000000..3363e37
--- /dev/null
+++ b/ComputerNetwork/PPT/计网第五章.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28a52a55ab2bf92faf31d6f2f1f2e74e4bc80db4fc9902bcd0dba076937bfa8d
+size 3398570
diff --git a/ComputerNetwork/PPT/计网第六章.pdf b/ComputerNetwork/PPT/计网第六章.pdf
new file mode 100644
index 0000000..5ef13ad
--- /dev/null
+++ b/ComputerNetwork/PPT/计网第六章.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1f0f256fd6dcb013ecdeadb9fb4d3a92999bfad64a9cd030f8a134486ca3b6e
+size 5393553
diff --git a/ComputerNetwork/PPT/计网第四章.pdf b/ComputerNetwork/PPT/计网第四章.pdf
new file mode 100644
index 0000000..735a25c
--- /dev/null
+++ b/ComputerNetwork/PPT/计网第四章.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f46e7c51c30c4c12b4ff18b9b3e5480f32415b1d70024e0386ea70cb61a4557
+size 11820188
diff --git a/ComputerNetwork/README.md b/ComputerNetwork/README.md
new file mode 100644
index 0000000..1294be3
--- /dev/null
+++ b/ComputerNetwork/README.md
@@ -0,0 +1 @@
+# 计算机网络(ComputerNetwork)
diff --git a/ComputerOrganization/CO_0_Introduction/Doc_0_0_计算机系统概述.md b/ComputerOrganization/CO_0_Introduction/Doc_0_0_计算机系统概述.md
new file mode 100644
index 0000000..4e8d6a3
--- /dev/null
+++ b/ComputerOrganization/CO_0_Introduction/Doc_0_0_计算机系统概述.md
@@ -0,0 +1,24 @@
+# 计算机系统概述
+
+## 什么是计算机系统
+
+计算机系统=硬件+软件
+
+![image-20200726202448571](https://tva1.sinaimg.cn/large/007S8ZIlly1gh4n8vx9dij31640qwh6a.jpg)
+
+### 软件的划分
+
+![image-20200726202536999](https://tva1.sinaimg.cn/large/007S8ZIlly1gh4n9oi5scj31hi0lsx6b.jpg)
+
+### 硬件的发展
+
+![image-20200726203231845](https://tva1.sinaimg.cn/large/007S8ZIlly1gh4ngvp5whj31k70u04qq.jpg)
+
+微处理器的发展
+
+![image-20200726203323797](https://tva1.sinaimg.cn/large/007S8ZIlly1gh4nhrx8ffj31md0u0hdt.jpg)
+
+![image-20200726203516013](https://tva1.sinaimg.cn/large/007S8ZIlly1gh4njq1ov4j31c40leaua.jpg)
+
+### 软件的发展
+
diff --git a/ComputerOrganization/CO_0_Introduction/README.md b/ComputerOrganization/CO_0_Introduction/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/ComputerOrganization/PPT/1.0_你好，我是计算机组成原理.pdf b/ComputerOrganization/PPT/1.0_你好，我是计算机组成原理.pdf
new file mode 100755
index 0000000..bda6e94
--- /dev/null
+++ b/ComputerOrganization/PPT/1.0_你好，我是计算机组成原理.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e76cf2a1616435c91c0734281dc80be0fa68d0c76db0ef776d37eead6421c63b
+size 13176541
diff --git a/ComputerOrganization/PPT/1.1_计算机的发展.pdf b/ComputerOrganization/PPT/1.1_计算机的发展.pdf
new file mode 100755
index 0000000..7df840b
--- /dev/null
+++ b/ComputerOrganization/PPT/1.1_计算机的发展.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2fe8084207ff9308672cb9e93711278f030868f2db6a1c7185e20d0420e37d92
+size 12940761
diff --git a/ComputerOrganization/PPT/1.2.1_计算机硬件的基本组成.pdf b/ComputerOrganization/PPT/1.2.1_计算机硬件的基本组成.pdf
new file mode 100755
index 0000000..1e727a7
--- /dev/null
+++ b/ComputerOrganization/PPT/1.2.1_计算机硬件的基本组成.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d27cd562e6cd4acf2bfb49fc5b5a4a055e56615d2158336ebe942aeb001efb29
+size 1799124
diff --git a/ComputerOrganization/PPT/1.2.2_认识各个硬件部件.pdf b/ComputerOrganization/PPT/1.2.2_认识各个硬件部件.pdf
new file mode 100755
index 0000000..c2dbe22
--- /dev/null
+++ b/ComputerOrganization/PPT/1.2.2_认识各个硬件部件.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a295cc1644495f5e56b2d4ad9846afe0503320ccfa1da51436cc39900fb04edb
+size 2256203
diff --git a/ComputerOrganization/PPT/1.2.3_计算机系统的层次结构.pdf b/ComputerOrganization/PPT/1.2.3_计算机系统的层次结构.pdf
new file mode 100755
index 0000000..7000bea
--- /dev/null
+++ b/ComputerOrganization/PPT/1.2.3_计算机系统的层次结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:082dc899ab79fef6b2e84f65d1ba227f976e309166a9731e4b720d2e0571f0ac
+size 2158326
diff --git a/ComputerOrganization/PPT/1.3_计算机的性能指标.pdf b/ComputerOrganization/PPT/1.3_计算机的性能指标.pdf
new file mode 100755
index 0000000..74089dc
--- /dev/null
+++ b/ComputerOrganization/PPT/1.3_计算机的性能指标.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:228d1ca68005f7d599fff1ee98e5c37d046e0d68a83376d0d6afbd14f5e873eb
+size 1637047
diff --git a/ComputerOrganization/PPT/2.1.1_进位计数制.pdf b/ComputerOrganization/PPT/2.1.1_进位计数制.pdf
new file mode 100755
index 0000000..b73b99e
--- /dev/null
+++ b/ComputerOrganization/PPT/2.1.1_进位计数制.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b311808de0e132fc002cf8ea9d44d20953d434764d2face37617046df8b7dd4
+size 3638964
diff --git a/ComputerOrganization/PPT/2.1.2_BCD码.pdf b/ComputerOrganization/PPT/2.1.2_BCD码.pdf
new file mode 100755
index 0000000..fd9df70
--- /dev/null
+++ b/ComputerOrganization/PPT/2.1.2_BCD码.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68e68fec4e5f58cc8210784a6db280ec82045dc678016f9c04aa4486ab2aef33
+size 504302
diff --git a/ComputerOrganization/PPT/2.1.3_字符与字符串.pdf b/ComputerOrganization/PPT/2.1.3_字符与字符串.pdf
new file mode 100755
index 0000000..3fe7b5a
--- /dev/null
+++ b/ComputerOrganization/PPT/2.1.3_字符与字符串.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5865273486cb71aa6fbf15542f9800d746f72f17a512b5e8206a2e1ce4233f24
+size 2153394
diff --git a/ComputerOrganization/PPT/2.1.4_奇偶校验码.pdf b/ComputerOrganization/PPT/2.1.4_奇偶校验码.pdf
new file mode 100755
index 0000000..e6951c3
--- /dev/null
+++ b/ComputerOrganization/PPT/2.1.4_奇偶校验码.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03aabecdb7f2104fe885f4bc91be99f3077b107ea004909521c9d6ca1e7a65db
+size 694690
diff --git a/ComputerOrganization/PPT/2.1.5_海明校验码.pdf b/ComputerOrganization/PPT/2.1.5_海明校验码.pdf
new file mode 100755
index 0000000..af2ea92
--- /dev/null
+++ b/ComputerOrganization/PPT/2.1.5_海明校验码.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:306ebd75e1398d4fd5a05052e11264339bff8d6dde7dad263f6e49eb40469103
+size 1061875
diff --git a/ComputerOrganization/PPT/2.1.6_循环冗余校验码.pdf b/ComputerOrganization/PPT/2.1.6_循环冗余校验码.pdf
new file mode 100755
index 0000000..42b887b
--- /dev/null
+++ b/ComputerOrganization/PPT/2.1.6_循环冗余校验码.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7dfe5c30f1972f39755faf8c13e7168572fbfd13acc80f29d830143d50d74195
+size 531935
diff --git a/ComputerOrganization/README.md b/ComputerOrganization/README.md
new file mode 100644
index 0000000..7dbe9fb
--- /dev/null
+++ b/ComputerOrganization/README.md
@@ -0,0 +1,6 @@
+# 计算机组成原理(ComputerOrganization)
+
+
+
+
+
diff --git a/DataStructure/DS_0_Introduction/DS_0_0_love.cpp b/DataStructure/DS_0_Introduction/DS_0_0_love.cpp
new file mode 100644
index 0000000..44da26f
--- /dev/null
+++ b/DataStructure/DS_0_Introduction/DS_0_0_love.cpp
@@ -0,0 +1,77 @@
+//
+// Created by kim on 2020/6/17.
+//
+
+#include <stdio.h>
+
+//下面四种函数的时间复杂度值得分析一二
+
+//逐步递增型爱你
+void LoveYou0(int n){
+    int i=1;
+    while (i<=n){
+        printf("I love you %d \n",i);
+        i++;
+    }
+    printf("I love you more than %d\n",n);
+}
+
+//嵌套循环型爱你
+void loveYou1(int n){
+    int i=1;
+    while (i<=n){
+        i++;
+        printf("I love you %d\n",i);
+        for (int j = 1; j <n ; j++) {
+            printf("I love you too\n");
+        }
+    }
+    printf("I love you more than %d\n",n);
+}
+//指数递增型爱你
+void loveYou2(int n){
+    int i=1;
+    while (i<=n){
+        printf("I love you %d\n",i);
+        i=i*2;
+    }
+    printf("I love you more than %d\n ",n);
+}
+
+//搜索数字型爱你
+void loveYou3(int flag[],int n){
+    printf("I Am kim\n");
+    for (int i = 0; i < n; i++) {
+        //我觉这里应该是数组长度
+        if (flag[i]==n){
+            printf("I love you %d\n",n);
+            break;//找到之后就跳出循环
+        }
+    }
+}
+//递归型爱你
+void loveYou4(int n){
+    int a,b,c;
+    if (n>1){
+        loveYou4(n-1);
+    }
+    printf("I love you %d\n",n);
+}//递归调用会带来多余的内存开销
+
+//测试函数
+void Test(){
+    LoveYou0(30);
+    loveYou1(30);
+    loveYou2(30);
+
+    int array[5]={2,10,100,1000,10000};
+    //声明一个数组并初始化
+    loveYou3(array,10);
+    loveYou4(4);
+
+}
+
+int main(){
+    Test();
+    return 0;
+}
diff --git a/DataStructure/DS_0_Introduction/Doc_0_0_数据结构基本概念.md b/DataStructure/DS_0_Introduction/Doc_0_0_数据结构基本概念.md
new file mode 100644
index 0000000..d612bac
--- /dev/null
+++ b/DataStructure/DS_0_Introduction/Doc_0_0_数据结构基本概念.md
@@ -0,0 +1,123 @@
+# 绪论第一节
+
+![image-20200616203728181](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuetqfhjsj30ol0eh432.jpg)
+
+## 基本概念
+
+### 什么是数据？
+
+数据是**信息的载体**，是客观描述事物属性的数、字符及**所有能输入到计算机中并被计算机程序识别和处理的符号**的集合。数据是计算机程序加工的原料。
+
+### 数据元素、数据项
+
+**数据元素**是数据的基本单位，通常作为一个整体进行考虑和处理。
+
+一个数据元素可由若干**数据项**组成，数据项是构成数据元素的不可分割的最小单位。
+
+### 数据结构、数据对象
+
+结构——各个元素之间的关系
+
+**数据结构**是互相之间存在一个或多种**特定关系**的数据元素的集合。
+
+**数据对象**是具有**相同性质**的数据元素的集合，是一个数据的子集。
+
+## 三要素
+
+![image-20200616204952204](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuf6l2hecj30mu08a77r.jpg)
+
+### 逻辑结构
+
+即，数据元素之间的逻辑关系是什么？
+
+![image-20200616205141919](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuf8hwsrsj30ij07w40n.jpg)
+
+#### 集合
+
+![image-20200616205508144](https://tva1.sinaimg.cn/large/007S8ZIlly1gfufc2oz43j30g90chgpg.jpg)
+
+各个数据元素同属一个集合，别无其它关系
+
+#### 线性结构
+
+![image-20200616205527638](https://tva1.sinaimg.cn/large/007S8ZIlly1gfufcetgb3j30fn0a7n14.jpg)
+
+数据元素之间是一对一的关系，除了第一个元素，所有元素都有唯一前驱，除了最后一个元素，所有元素都有唯一后继
+
+#### 树形结构
+
+![image-20200616205648476](https://tva1.sinaimg.cn/large/007S8ZIlly1gfufdsxoxdj307u0dp774.jpg)
+
+数据元素之间是一对多的关系
+
+#### 图结构
+
+![image-20200616205732165](https://tva1.sinaimg.cn/large/007S8ZIlly1gfufeklp71j309a0cx775.jpg)
+
+数据元素之间是多对多的关系
+
+### 物理结构
+
+即，物理结构，如何用计算机表示数据元素的逻辑关系？
+
+#### 顺序存储
+
+![image-20200616205941135](https://tva1.sinaimg.cn/large/007S8ZIlly1gfufgt6r70j30o80d4wjn.jpg)
+
+**把逻辑上相邻的元素存储在物理地址上也相邻的存储单元中**，元素之间的关系由存储单元的领接关系来体现。
+
+#### 链式存储
+
+![image-20200616210302754](https://tva1.sinaimg.cn/large/007S8ZIlly1gfufkbheq8j30u70d944u.jpg)
+
+#### 索引存储
+
+![image-20200616210349944](https://tva1.sinaimg.cn/large/007S8ZIlly1gfufl3zghqj30rw0fgdn6.jpg)
+
+#### 散列存储
+
+![image-20200616210434678](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuflw76d2j30tf0aw438.jpg)
+
+#### 总结
+
+![image-20200616210508542](https://tva1.sinaimg.cn/large/007S8ZIlly1gfufmh5xb4j30oh09742a.jpg)
+
+1. 若采用顺序存储，则各个数据元素在物理上必须是连续的；若采用非顺存储，则各个数据元素在物理上是可以离散的
+2. 数据的存储结构会影响存储空间的分配的方便程度
+3. 数据的存储机构会影响对数据运算的速度
+
+### 数据的运算
+
+施加在数据上的运算包括运算的定义和实现。运算的定义是针对逻辑结构的，正对运算的功能；运算的实现是针对存储结构的，指的是运算实现的具体操作步骤。
+
+## 数据类型、抽象数据类型
+
+### 数据类型
+
+数据类型是一个值的集合和定义在此集合的一组操作的总称。
+
+1. 原子类型，其值不可再分的数据类型
+2. 结构类型，其值可以再分解为若干成分（分量）的数据类型
+
+![image-20200616211417412](https://tva1.sinaimg.cn/large/007S8ZIlly1gfufw04oidj30rk05w0vw.jpg)
+
+### 抽象数据类型
+
+Abstract Data Type （ADT）是抽象数据组织及与之相关的操作。
+
+ADT 是用数学化的语言定义数据的逻辑结构、定义运算。与其具体的实现无关（类似于定义类吗？可能）
+
+## 总结
+
+![image-20200616212103345](https://tva1.sinaimg.cn/large/007S8ZIlly1gfug31fiwgj30s00gq7f0.jpg)
+
+![image-20200616212152228](https://tva1.sinaimg.cn/large/007S8ZIlly1gfug3w4k7sj30vy0fbqcu.jpg)
+
+在探讨一种数据结构时：
+
+1. 定义逻辑结构（数据原元素之间的关系）
+2. 定义数据的运算（针对现实需求，应该对这种逻辑结构进行什么样的运算）
+3. 确定某种存储结构，实现数据结构，并实现一些对数据结构的基本运算
+
+![image-20200616212530957](https://tva1.sinaimg.cn/large/007S8ZIlly1gfug7om407j30o90gxago.jpg)
+
diff --git a/DataStructure/DS_0_Introduction/Doc_0_1_算法基本概念.md b/DataStructure/DS_0_Introduction/Doc_0_1_算法基本概念.md
new file mode 100644
index 0000000..6cf8743
--- /dev/null
+++ b/DataStructure/DS_0_Introduction/Doc_0_1_算法基本概念.md
@@ -0,0 +1,134 @@
+
+
+# 绪论第二节——算法
+
+## 基本概念
+
+![image-20200616214853491](https://tva1.sinaimg.cn/large/007S8ZIlly1gfugvzxnvwj30kp06q76j.jpg)
+
+### 什么是算法？
+
+程序=数据结构+算法
+
+![image-20200616215006166](https://tva1.sinaimg.cn/large/007S8ZIlly1gfugx9fo26j30mb07fn0y.jpg)
+
+###算法的特性
+
+1. 有穷性：一个算法必须总在执行有穷步之后结束，且每一步都可在有穷时间内完成。
+
+   注：算法必须是有穷的，二程序可以是无穷的。
+
+   ![image-20200616215340371](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuh0zabt5j30ir06k77k.jpg)
+
+2. 确定性：算法每一条指令必须有确切的含义，对于相同的输入只能得出相同的输出
+
+3. 可行性：算法描述的操作都可以通过已经实现的基本运算执行有限次来实现。
+
+4. 输入：一个算法有0个或多个输入，这些输入取自某个特定对象的集合。
+
+5. 输出：一个算法有一个或多个输出，这些输出是与输入有着某种特定关系的量。
+
+   五个特性，缺一不可
+
+####“好”算法的特质
+
+1. 正确性：算法应能正确地解决求解问题。
+2. 可读性：算法应具有良好的可读性，帮助人们理解。
+3. 健壮性：输入非法数据时，算法能适当地做出反应或进行处理，而不会产生莫名其妙的输出结果。
+4. 高效率与底存储量需求：执行速度快，时间复杂度低。不费内存，空间复杂度低。
+
+###总结
+
+![image-20200616220536590](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuhdekssej30sl0jdqf5.jpg)
+
+## 算法效率的度量
+
+![image-20200616220923527](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuhhbotwbj30ld057wgp.jpg)
+
+### 如何评估算法时间开销？
+
+**让算法先运行，事后统计运行时间？**
+
+存在的问题？
+
+* 和机器性能有关，比如：超级计算机VS单片机
+* 和编程语言有关，越高级的语言执行效率越低，没错，就是越低
+* 和编译程序产生的机器指令质量有关
+* 有些算法是不能事后统计的，比如，导弹控制算法。
+
+评价一个算法优劣时，需要排除与算法本身无关的外界因素，能否事先估计？
+
+### 算法时间复杂度
+
+事前预估算法时间开销T(n)与问题规模n的关系（T 表示 time）
+
+如何计算T，例子：
+
+![image-20200616234743261](https://tva1.sinaimg.cn/large/007S8ZIlly1gfukbpctznj31k70u0hdt.jpg)
+
+#### 问题1:是否可以忽略表达式某些部分？
+
+![image-20200616235203889](https://tva1.sinaimg.cn/large/007S8ZIlly1gfukg635rdj31ik0u0u0x.jpg)
+
+1.  加法规则：多项相加，只保留最高阶的项，且系数变为1
+
+    ![image-20200616235558501](https://tva1.sinaimg.cn/large/007S8ZIlly1gfukk8om4cj321y0cedxg.jpg)
+
+2.  乘法规则：多项相乘，都保留
+
+    ![image-20200616235856976](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuknbut9qj31ga0bigsj.jpg)
+
+##### 算法时间复杂度阶数顺序
+
+![image-20200617000121744](https://tva1.sinaimg.cn/large/007S8ZIlly1gfukpu8233j31da06atdu.jpg)
+
+![image-20200617000310666](https://tva1.sinaimg.cn/large/007S8ZIlly1gfukrq8z28j31eu0u04qp.jpg)
+
+#### 如果有好几千行代码，需要一行一行数？
+
+1.  顺序执行的代码只会影响常数项，可以忽略
+2.  只需要挑循环中的一个基本操作，分析它的执行次数和n的关系就好
+3.  如果有多层嵌套循环，只需要关注最深层的循环循环了几次
+
+#### 小练习
+
+![image-20200617001603926](https://tva1.sinaimg.cn/large/007S8ZIlly1gful55dhkwj31m50u0qv5.jpg)
+
+![image-20200617001659516](https://tva1.sinaimg.cn/large/007S8ZIlly1gful64i4plj31ih0u0b29.jpg)
+
+![image-20200617001353856](https://tva1.sinaimg.cn/large/007S8ZIlly1gful2voqyhj31lu0u0qv5.jpg)
+
+#### 总结
+
+![image-20200617001826231](https://tva1.sinaimg.cn/large/007S8ZIlly1gful7lx0gkj31u20u01kx.jpg)
+
+算法的性能问题只有在n很大时才会暴露出来。
+
+### 算法空间复杂度
+
+#### 原地工作算法
+
+![image-20200617002424730](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuldv14wbj31o20u07wh.jpg)
+
+分析空间复杂度时，只需关注与问题规模相关的变量就好（讲人话，就是，看程序中的变量就好）
+
+![image-20200617002625466](https://tva1.sinaimg.cn/large/007S8ZIlly1gfulfxjzfoj31s00u0e4m.jpg)
+
+加法法则
+
+![image-20200617002941853](https://tva1.sinaimg.cn/large/007S8ZIlly1gfuljbdlnbj31kn0u07wh.jpg)
+
+#### 函数递归调用带来的内存开销
+
+![image-20200617003249255](https://tva1.sinaimg.cn/large/007S8ZIlly1gfulmkft4xj31ln0u0e81.jpg)
+
+在这种情况下，空间复杂度等于递归调用的深度。
+
+![image-20200617003702543](https://tva1.sinaimg.cn/large/007S8ZIlly1gfulqyn7d0j31nm0u04qp.jpg)
+
+递归调用的过程中，每一次开辟的内存空间也可以不一致，如上例。
+
+#### 总结
+
+![image-20200617003857723](https://tva1.sinaimg.cn/large/007S8ZIlly1gfulsypll3j31th0u01kx.jpg)
+
diff --git a/DataStructure/DS_0_Introduction/Doc_0_2_错题总结.md b/DataStructure/DS_0_Introduction/Doc_0_2_错题总结.md
new file mode 100644
index 0000000..70e4f5a
--- /dev/null
+++ b/DataStructure/DS_0_Introduction/Doc_0_2_错题总结.md
@@ -0,0 +1,58 @@
+# 错题总结
+
+## 绪论
+
+### 1.1数据结构
+
+![image-20200620141611126](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyqa8kf1rj30yh060wfv.jpg)
+
+![image-20200620141729678](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyqbk41kvj31f206b0v6.jpg)
+
+
+
+![image-20200620141623755](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyqaevwtfj30ue06l0tv.jpg)
+
+![image-20200620141744664](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyqbtib1sj31fz089jur.jpg)
+
+
+
+![image-20200620141644083](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyqarkhbsj313j06b403.jpg)
+
+![image-20200620141822782](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyqchm5t8j31g406ign4.jpg)
+
+
+
+![image-20200620141659734](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyqb1il2zj30zj05u401.jpg)
+
+![image-20200620141857733](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyqd350p8j31ed0dhn3s.jpg)
+
+
+
+### 1.2算法
+
+![image-20200620144456037](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyr43sg3dj312c069myh.jpg)
+
+![image-20200620144443934](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyr3wgujdj30xs076whm.jpg)
+
+
+
+![image-20200620144648263](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyr6226oaj31d4088tbd.jpg)
+
+![image-20200620144742685](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyr6zu9jcj30yc05z41a.jpg)
+
+
+
+![image-20200620144922849](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyr8qk4j9j31760fkgq1.jpg)
+
+![image-20200620145032775](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyr9y47p5j30vj07q0wy.jpg)
+
+
+
+![image-20200620145234727](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyrc2fq5oj31aw038my9.jpg)
+
+![image-20200620145244254](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyrc7ypikj30xu0bdta5.jpg)
+
+![image-20200620145307619](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyrcn4hzfj30sl05y763.jpg)
+
+
+
diff --git a/DataStructure/DS_0_Introduction/README.md b/DataStructure/DS_0_Introduction/README.md
new file mode 100644
index 0000000..d20b581
--- /dev/null
+++ b/DataStructure/DS_0_Introduction/README.md
@@ -0,0 +1,12 @@
+# 绪论
+
+## 目录
+
+* [数据结构基本概念](Doc_0_0_数据结构基本概念.md)
+* [算法基本概念](Doc_0_1_算法基本概念.md)
+* [课后习题错题总结](Doc_0_2_错题总结.md)
+
+## 课件目录
+
+
+
diff --git a/DataStructure/DS_1_LinearList/DS_1_0_SqList.cpp b/DataStructure/DS_1_LinearList/DS_1_0_SqList.cpp
new file mode 100644
index 0000000..98f45cf
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/DS_1_0_SqList.cpp
@@ -0,0 +1,200 @@
+//
+// Created by kim on 2020/6/17.
+//
+
+//顺序表——静态分配的实现方式
+#include <stdio.h>
+#define MaxSize 10
+
+typedef struct {
+    int data[MaxSize];
+    int length;
+}SqList;
+
+//函数声明
+void PrintSqList(SqList L);
+
+//
+
+
+//初始化
+void InitList(SqList &L){
+    for (int i = 0; i < MaxSize; i++) {
+        L.data[i]=0;//将所有元素的初始值默认设置为0
+        //这一步其实可以省略，但是省略之后，有可能受到内存中"脏数据"的影响
+    }
+    L.length=0;
+
+}
+//判空
+bool Empty(SqList L){
+    return (L.length==0);
+}
+
+//插入
+bool ListInsert(SqList &L,int i,int e){
+    //判断插入的位置是否合法，
+    if (i<1||i>L.length+1)
+        return false;
+    //判断表是否存满了
+    if (L.length>=MaxSize)
+        return false;
+
+    //后面的元素后移
+    for (int j = L.length; j >=i ; j--) {
+        L.data[j]=L.data[j-1];
+    }
+    L.data[i-1]=e;
+    L.length++;
+    return true;
+}
+
+//删除
+bool ListDelete(SqList &L,int i,int &e){
+    //判断i的位置是否合法
+    if(i<0||i>L.length){
+        return false;
+    }
+    //取出将要被删除的数
+    e=L.data[i-1];
+    //将其后的数据前移
+    for (int j = i; j <=L.length ; j++) {
+        L.data[j-1]=L.data[j];
+    }
+    //线性表长度减一
+    L.length--;
+    return true;
+}
+
+//查找
+//按位查找
+int GetElem(SqList L,int i){
+    //判断是否越界
+    if (i<0||i>L.length)
+        return -1;
+    return L.data[i-1];
+}
+
+//按值查找
+int LocateElem(SqList L,int e){
+    //循环出查找
+    for (int i = 0; i <L.length ; i++) {
+        if (L.data[i]==e)
+            return i+1; //返回位序
+    }
+    return -1;
+}
+
+//改
+//先查找后改值
+//由此分为两种方式，先按位查找后改值；或先按值查找后改值
+//先按值查找后改值
+bool LocateChangeElem(SqList &L,int e,int em){
+    //按值查找得到位序
+    int bitOrder =LocateElem(L,e);
+    //改值
+    if (bitOrder !=-1){
+        L.data[bitOrder]=em;
+        return true;
+    } else{
+        return false;
+    }
+}
+//先按位序查找后改值
+bool getChangeElem(SqList &L,int i,int em){
+    //注意由于是改值涉及修改原数据，所以需要用引用传递的方式
+    //给的位序,首先判断i是否合法
+    if(i<0||i>=L.length)return false;
+
+    //由于是用数组实现的方式，可以直接利用i查找
+    L.data[i]=em;
+    return true;
+
+}
+
+//Change Test
+void ChangeTest(SqList &L,int e,int em1,int i, int em2){
+    //change 修改元数据用引用的方式
+    printf("开始测试【改】\n"
+           "第一种方式先按值查找后改值\n");
+    if (LocateChangeElem(L,e,em1)){
+        printf("第一种先按值查找后改值成功啦，改变后的值如下：\n");
+        PrintSqList(L);
+    } else{
+        printf("第一种先按值查找后改值失败了，再检查一下吧！\n");
+    }
+    printf("第二种先按位序查找后改值\n");
+    if (getChangeElem(L,i,em2)){
+        printf("第二种先按位序查找后改值的方式成功啦，改变后的值如下：\n");
+        PrintSqList(L);
+    } else{
+        printf("第二种先按位序查找后改值的方式失败了，再检查一下吧！\n");
+    }
+
+
+}
+
+//销毁
+//由于静态分配方式是通过声明数组的方式实现的，故不需要手动销毁SqList表，在使用完成之后，系统会自动删除数据并回收数据空间
+
+//测试
+//打印整个顺序表
+void PrintSqList(SqList L){
+    //循环打印
+    printf("开始打印顺序表\n");
+    for (int i = 0; i < L.length ; i++) {
+        printf("Data[%d]==%d\n",i,L.data[i]);
+    }
+    printf("打印结束！\n");
+}
+
+//测试函数
+void Test(){
+    SqList L;
+    InitList(L);
+
+//    初试化一些值
+    L.data[0]=1;
+    L.data[1]=2;
+    L.data[2]=3;
+    L.length=3;
+
+    //插入操作
+    if (ListInsert(L,2,3)){
+        printf("插入成功了\n");
+    } else{
+        printf("插入失败了，i的位置不合法，请检查\n");
+    }
+
+    //删除操作
+    int e=-1;
+    if (ListDelete(L,2,e)){
+        printf("删除成功！删除的值是：%d\n",e);
+    } else{
+        printf("删除失败，请检查位序是否正确\n");
+    }
+
+    //数组当前长度
+    printf("数组当前长度是多少？%d\n",L.length);
+
+    //查找第一个元素是什么？
+    printf("第一个元素是什么？\n %d\n",GetElem(L,1));
+
+    //查找值为3的元素在什么位置
+    printf("第一个值为3的元素在什么位置？\n %d \n",LocateElem(L,3));
+
+    //打印输出
+    PrintSqList(L);
+
+    //测试改模块功能是否正常
+    ChangeTest(L,2,6,1,7);
+
+    //打印输出
+    PrintSqList(L);
+}
+
+//主函数
+int  main(){
+    Test();
+    return 0;
+}
\ No newline at end of file
diff --git a/DataStructure/DS_1_LinearList/DS_1_1_SqList.cpp b/DataStructure/DS_1_LinearList/DS_1_1_SqList.cpp
new file mode 100644
index 0000000..6ea695e
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/DS_1_1_SqList.cpp
@@ -0,0 +1,182 @@
+//
+// Created by kim on 2020/6/17.
+//
+
+//顺序表——动态分配的实现方式
+#include <stdio.h>
+#include <stdlib.h>
+#define InitSize 10
+typedef struct {
+    int *data; //指示动态分配数组的指针
+    int MaxSize;//顺序表的最大容量
+    int length;//顺序表当前的长度
+}SeqList;
+
+//初始化
+bool InitList(SeqList &L){
+    //用 malloc 函数申请一片连续的存储空间
+    L.data=(int *)malloc(InitSize*sizeof(int));
+    if (L.data==NULL)
+        //要细心呀，这里不小心写成了赋值语句，但是没有报错，找了半天错误！
+        return false;
+    //(int *) 是指针的强制类型转换
+    L.length=0;
+    L.MaxSize=InitSize;
+    return true;
+}
+
+//判空
+bool Empty(SeqList L){
+    return (L.length==0);
+}
+//判满
+bool Full(SeqList L){
+    return (L.length>=L.MaxSize);
+}
+
+//扩展空间
+void  IncreaseSize(SeqList &L,int len){
+    printf("开始扩展表存储空间。。。\n");
+    int *p=L.data;
+    L.data=(int *)malloc((InitSize+len)*sizeof(int ));
+    printf("开始复制转移数据。。。\n");
+    for (int i = 0; i < L.length; i++) {
+        L.data[i]=p[i];
+    }
+    printf("之前内存空间的长度是：%d\n",L.MaxSize);
+    L.MaxSize=L.MaxSize+len;
+    free(p);
+    //malloc 函数用于申请内存空间；free 函数用于释放内存空间；
+    printf("现在的内存空间长度是%d\n",L.MaxSize);
+}
+
+//插入
+bool ListInsert(SeqList &L,int i,int e){
+    //判断插入的位置是否合法，
+    if (i<1||i>L.length+1)
+        return false;
+    //判断表是否存满了
+//    if (L.length>=L.MaxSize)
+//        return false;
+    if (Full(L))
+        return false;
+
+    //后面的元素后移
+    for (int j = L.length; j >=i ; j--) {
+        L.data[j]=L.data[j-1];
+    }
+    L.data[i-1]=e;
+    L.length++;
+    return true;
+}
+
+
+//按位查找
+int GetElem(SeqList L,int i){
+    //判断是否越界
+    if (i<0||i>L.length)
+        return -1;
+    return L.data[i-1];
+}
+
+//按值查找
+int LocateElem(SeqList L,int e){
+    //循环出查找
+    for (int i = 0; i <L.length ; i++) {
+        if (L.data[i]==e)
+            return i+1; //返回位序
+    }
+    return -1;
+}
+//删除
+bool ListDelete(SeqList &L,int i,int &e){
+    //判断i的位置是否合法
+    if(i<0||i>L.length){
+        return false;
+    }
+    //取出将要被删除的数
+    e=L.data[i-1];
+    //将其后的数据前移
+    for (int j = i; j <=L.length ; j++) {
+        L.data[j-1]=L.data[j];
+    }
+    //线性表长度减一
+    L.length--;
+    return true;
+}
+
+//销毁
+//由于动态分配方式使用malloc申请的内存空间，故需要使用free函数手动释放空间！
+void DestroySqList(SeqList &L){
+    free(L.data);
+    L.data=NULL;
+    L.length=0;
+}
+
+//测试
+//打印整个顺序表
+void PrintSqList(SeqList L){
+    if (L.data==NULL||L.length==0)
+        printf("这是一个空表！");
+    else {
+        //循环打印
+        printf("开始打印顺序表\n");
+        for (int i = 0; i < L.length; i++) {
+            printf("Data[%d]==%d\n", i, L.data[i]);
+        }
+        printf("打印结束！\n");
+    }
+}
+
+//测试输出
+void TestPrint(bool test,char message[]){
+    if(test)
+        printf("%s成功啦!\n",message);
+    else
+        printf("%s失败啦！\n",message);
+}
+
+int main(){
+    SeqList L;
+
+    TestPrint(InitList(L),"初始化");
+
+//    初试化一些值
+    L.data[0]=1;
+    L.data[1]=2;
+    L.data[2]=3;
+    L.length=3;
+    PrintSqList(L);
+
+    //循环插入直到表满
+    int i=4;
+    int InsertValue=4;
+    while(L.length<L.MaxSize) {
+        TestPrint(ListInsert(L, i, InsertValue), "插入");
+        i++;
+        InsertValue++;
+    }
+    PrintSqList(L);
+
+    //表满则扩展空间
+    if (Full(L))IncreaseSize(L,5);
+
+    //按位查找
+    printf("第5个元素是%d\n",GetElem(L,5));
+
+    //按值查找
+    printf("值为6的元素的位序是%d\n",LocateElem(L,6));
+
+    //删除
+    int e;
+    TestPrint(ListDelete(L,4,e),"删除");
+    printf("删除的元素是%d\n",e);
+    PrintSqList(L);
+
+    //销毁
+    DestroySqList(L);
+    TestPrint(Empty(L),"删除");
+    PrintSqList(L);
+
+    return 0;
+}
\ No newline at end of file
diff --git a/DataStructure/DS_1_LinearList/DS_1_2_LinkList1.cpp b/DataStructure/DS_1_LinearList/DS_1_2_LinkList1.cpp
new file mode 100644
index 0000000..7807ce4
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/DS_1_2_LinkList1.cpp
@@ -0,0 +1,132 @@
+//
+// Created by kim on 2020/6/19.
+//
+
+//带头节点的单链表
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct LNode{
+    int data;
+    LNode *next;
+}LNode,*LinkList;
+
+//初试化(带有头节点)
+bool InitList(LinkList &L){
+    L=(LNode *)malloc(sizeof(LNode));//分配一个头节点
+    if (L==NULL)
+        return false;//头节点分配失败，可能是内存不足
+    L->next=NULL;//头节点之后暂时没有节点，头节点也不存放数据
+    return true;
+}
+
+//判空
+bool Empty(LinkList L){
+//    if(L->next==NULL)
+//        return true;
+//    else
+//        return false;
+    return (L->next==NULL);
+}
+
+//按位插入
+bool ListInsert(LinkList &L,int i, int e){
+    if (i<1)return false;//判断位序i是否合法
+    LNode *p;//指针指向当前扫面到的节点
+    int j=0;//记录p指向的节点的位序
+    p=L;//L指向头节点，从头开始
+    while (p!=NULL&&j<i-1){
+        //循环扫描
+        p=p->next;
+        j++;
+    }
+    if (p==NULL) //i值超过来表长，不合法
+        return false;
+    LNode *s=(LNode *)malloc(sizeof(LNode));
+    s->data=e;
+    //下面的顺序不可交换
+    s->next=p->next;
+    p->next=s;
+    return true;
+}
+//指定节点的后插操作
+bool InsertNextNode(LNode *p,int e){
+    if (p==NULL)
+        return false;//判断指定节点是否存在
+    LNode *s=(LNode *)malloc(sizeof(LNode));
+    if (s==NULL)return false;//分配内存失败
+    s->data=e;
+    s->next=p->next;
+    p->next=s;
+    return true;
+}
+
+//指定节点的前插操作
+//先完成后插，再交换数据以实现前插
+bool InsertPriorNode(LNode *p,int e){
+    if (p==NULL)return false;
+    LNode *s=(LNode *)malloc(sizeof(LNode));
+    if (s==NULL)return false;
+    s->next=p->next;
+    p->next=s;
+    s->data=p->data;
+    p->data=e;
+    return true;
+}
+
+//按指定位序删除节点并返回其值
+bool ListDelete(LinkList &L,int i,int &e){
+    if (i<1)return false;
+    LNode *p;
+    int j=0;
+    p=L;
+    while (p!=NULL&&j<i-1){
+        p=p->next;
+        j++;
+    }
+    LNode *q=p->next;
+    e = q->data;
+    p->next=q->next;
+    free(q);
+    return true;
+}
+
+//删除指定节点
+bool DeleteNode(LNode *p){
+
+}
+
+//Test
+void TestPrint(bool test,char about[]){
+    if (test)
+        printf("%s成功\n",about);
+    else
+        printf("%s失败\n",about);
+}
+
+void PrintList(LinkList L){
+    //循环打印整个链表
+    LNode *p=L->next;//扫描指针
+    int j=0;
+    if (p==NULL)printf("这是一个空表\n");
+    while (p!=NULL){
+        printf("LinkList[%d]=%d\n",j,p->data);
+        p=p->next;
+        j++;
+    }
+
+}
+
+int main(){
+    LinkList L;
+    TestPrint(InitList(L),"初始化");
+    PrintList(L);
+    TestPrint(ListInsert(L,1,3),"按位插入");
+    PrintList(L);
+    int e;
+    TestPrint(ListDelete(L,1,e),"删除");
+    PrintList(L);
+    printf("被删除的数据是：%d\n",e);
+    return 0;
+}
\ No newline at end of file
diff --git a/DataStructure/DS_1_LinearList/DS_1_3_LinkList.cpp b/DataStructure/DS_1_LinearList/DS_1_3_LinkList.cpp
new file mode 100644
index 0000000..c656899
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/DS_1_3_LinkList.cpp
@@ -0,0 +1,96 @@
+//
+// Created by kim on 2020/6/19.
+//
+
+//不带头节点的单链表
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct LNode{
+    int data;
+    struct LNode *next;
+}LNode,*LinkList;
+//等价于
+//struct LNode{
+//    int data;
+//    struct LNode *next;
+//};
+//
+//typedef struct LNode LNode;
+//typedef struct LNode *LinkList;
+
+//初始化
+bool InitList(LinkList &L){
+    L=NULL;//空表暂时没有任何数据
+    return true;
+}
+
+//判断是否为空
+bool Empty(LinkList L){
+    return (L==NULL);
+}
+//等价于
+//bool Empty1(LinkList L){
+//    if (L==NULL)
+//        return true;
+//    else
+//        return false;
+//}
+
+bool ListInsert(LinkList &L,int i, int e){
+    if (i<1)return false;//判断位序i是否合法
+    //不带头节点时，插入位置正好为表头时，得单独处理
+    if (i=1){
+        LNode *s =(LNode *)malloc(sizeof(LNode));
+        s->data=e;
+        s->next=L;
+        L=s;
+        return true;}
+    LNode *p;//指针指向当前扫面到的节点
+    int j=0;//记录p指向的节点的位序
+    p=L;//L指向头节点，从头开始
+    while (p!=NULL&&j<i-1){
+        //循环扫描
+        p=p->next;
+        j++;
+    }
+    if (p==NULL) //i值超过来表长，不合法
+        return false;
+    LNode *s=(LNode *)malloc(sizeof(LNode));
+    s->data=e;
+    //下面的顺序不可交换
+    s->next=p->next;
+    p->next=s;
+    return true;
+}
+
+//Test
+void TestPrint(bool test,char about[]){
+    if (test)
+        printf("%s成功\n",about);
+    else
+        printf("%s失败\n",about);
+}
+
+void PrintList(LinkList L){
+    //循环打印整个链表
+    LNode *p=L;//扫描指针
+    int j=0;
+    if (p==NULL)printf("这是一个空表\n");
+    while (p!=NULL){
+        printf("LinkList[%d]=%d",j,p->data);
+        p=p->next;
+        j++;
+    }
+}
+
+int main(){
+    LinkList L;
+    TestPrint(InitList(L),"初始化");
+    PrintList(L);
+    TestPrint(ListInsert(L,1,2),"按位插入");
+    PrintList(L);
+
+    return 0;
+
+}
\ No newline at end of file
diff --git a/DataStructure/DS_1_LinearList/DS_1_4_DLinkList.cpp b/DataStructure/DS_1_LinearList/DS_1_4_DLinkList.cpp
new file mode 100644
index 0000000..b78069c
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/DS_1_4_DLinkList.cpp
@@ -0,0 +1,104 @@
+//
+// Created by kim on 2020/6/20.
+//
+
+//带有头节点版本——双链表
+
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct DNode{
+    int data;//数据域
+    struct DNode *prior,*next;//前指针和后指针
+}DNode,*DLinkList;
+
+//初始化
+bool InitDLinkList(DLinkList &L){
+    L = (DNode *)malloc(sizeof(DNode));//分配一个头节点
+    if (L==NULL)
+        return false;
+    L->prior==NULL;//头节点前后指针都指向空
+    L->next==NULL;
+    return true;
+}
+
+//判空
+bool Empty(DLinkList L){
+    return (L->next==NULL);
+}
+
+//指定节点的后插操作
+bool InsertNextElem(DNode *p,DNode *s){
+    //注意顺序不可交换
+    s->next=p->next;
+    p->next->prior=s;
+    s->prior=p;
+    p->next=s;
+}
+
+//删除P节点的后继节点
+bool DeletNextNode(DNode *p){
+    if(p == NULL)return false;//p节点为空
+    DNode *q=p->next;
+    if (q==NULL)return false;//P节点没有后继
+    p->next=q->next;
+    if (q->next!=NULL)//q不是最后一个节点
+        q->next->prior=p;
+    free(q);//手动释放内存空间
+    return true;
+}
+
+//销毁整个表
+bool DestoryList(DLinkList &L){
+    //循环删除并释放每个节点
+    while (L->next!=NULL)
+        DeletNextNode(L);
+    free(L);//释放头节点
+    L=NULL;//头指针指向NULL
+
+}
+
+//从P点向后遍历
+bool PrintNextElems(DNode *p){
+    if (p==NULL)return false;//
+    while (p!=NULL){
+        printf("当前节点的值是:%d",p->data);
+        p=p->next;
+    }
+    return true;
+}
+
+//从P点向前遍历
+bool PrintPriorElems(DNode *p){
+    if (p==NULL)return false;//
+    while (p!=NULL){
+        printf("当前节点的值是:%d",p->data);
+        p=p->prior;
+    }
+    return true;
+}
+
+//从P点向前遍历（跳过头节点）
+bool PrintPriorElemsOverHead(DNode *p){
+    if (p==NULL)return false;//
+    while (p->prior!=NULL){
+        printf("当前节点的值是:%d",p->data);
+        p=p->prior;
+    }
+    return true;
+}
+
+//测试函数
+void TestPrint(bool test,char message[]){
+    if (test)
+        printf("%s成功啦！\n",message);
+    else
+        printf("%s失败啦！\n",message);
+}
+
+int main(){
+    DLinkList L;
+    TestPrint(InitDLinkList(L),"初始化");
+
+    return 0;
+}
diff --git a/DataStructure/DS_1_LinearList/DS_1_5_RLinkList.cpp b/DataStructure/DS_1_LinearList/DS_1_5_RLinkList.cpp
new file mode 100644
index 0000000..09e2da1
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/DS_1_5_RLinkList.cpp
@@ -0,0 +1,31 @@
+//
+// Created by kim on 2020/6/20.
+//
+
+//循环单链表
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct LNode{
+    int data;
+    struct LNode *next;
+}LNode,*LinkList;
+
+//初始化一个循环单链表
+bool InitRLinkList(LinkList &L){
+    L=(LNode *)malloc(sizeof(LNode));//分配一个头节点
+    if (L=NULL)
+        return false;//内存不足，分配失败；
+    L->next=L;//头节点nex指向头节点，以此形成循环链表
+    return true;
+}
+
+//判断P是不是表尾指针
+bool IsTail(LinkList L,LNode *p){
+    return (p->next==L);
+}
+
+int  main(){
+
+    return 0;
+}
diff --git a/DataStructure/DS_1_LinearList/DS_1_6_RDLinkList.cpp b/DataStructure/DS_1_LinearList/DS_1_6_RDLinkList.cpp
new file mode 100644
index 0000000..800e1d6
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/DS_1_6_RDLinkList.cpp
@@ -0,0 +1,50 @@
+//
+// Created by kim on 2020/6/20.
+//
+
+//循环双链表
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct DNode{
+    int data;
+    struct DNode *prior,*next;
+}DNode,*DLinkList;
+
+//初始化
+bool InitRDLinkList(DLinkList &L){
+    L=(DNode *)malloc(sizeof(DNode));//分配头节点
+    if (L==NULL)return false;
+    L->prior=L;
+    L->next=L;//循环抱住自己
+    return true;
+}
+
+//判断节点p是不是循环双链表的表尾节点
+bool iTail(DLinkList L,DNode *p){
+    return (p->next==L);
+}
+
+//在p节点之后插入s节点
+bool InsertNextDNode(DNode *p,DNode *s){
+    s->next=p->next;
+    p->next->prior=s;
+    s->prior=p;
+    p->next=s;
+    return true;
+}
+
+//删除操作
+bool DeleteNextDNode(DLinkList &L,DNode *p){
+    DNode *q = p->next;
+    p->next=q->next;
+    q->next->prior=p;
+    free(q);
+    return true;
+}
+
+int main(){
+
+
+    return 0;
+}
\ No newline at end of file
diff --git a/DataStructure/DS_1_LinearList/DS_1_7_SLinkList.cpp b/DataStructure/DS_1_LinearList/DS_1_7_SLinkList.cpp
new file mode 100644
index 0000000..40918d1
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/DS_1_7_SLinkList.cpp
@@ -0,0 +1,38 @@
+//
+// Created by kim on 2020/6/20.
+//
+
+//静态链表
+#include <stdlib.h>
+#include <stdlib.h>
+#define MaxSize 10
+
+//第一种定义方法
+struct Node0{
+    int data;
+    int next;
+};
+
+void testSLinkList(){
+    //声明时
+    struct Node0 a[MaxSize];
+}
+
+//第二种定义方法
+typedef struct Node{
+    int data;
+    int next;
+}SLinkList[MaxSize];
+
+void TestSLinkList(){
+    //第二种方法声明时
+    SLinkList a;
+}
+
+//相比之下，第二种方法可读性更强！，推荐
+
+int main(){
+    //后续来填坑吧！！
+
+    return 0;
+}
\ No newline at end of file
diff --git a/DataStructure/DS_1_LinearList/Doc_1_0_线性表.md b/DataStructure/DS_1_LinearList/Doc_1_0_线性表.md
new file mode 100644
index 0000000..de528f1
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/Doc_1_0_线性表.md
@@ -0,0 +1,39 @@
+# 线性表
+
+##线性表的基本概念
+
+![image-20200617165505571](https://tva1.sinaimg.cn/large/007S8ZIlly1gfve0nemwmj30o80cu77w.jpg)
+
+### 线性表的定义
+
+线性表是具有相同数据类型的n(n>=0)个元素的有限序列。
+
+![image-20200617165917735](https://tva1.sinaimg.cn/large/007S8ZIlly1gfve4zll7lj30up0ik4am.jpg)
+
+### 线性表的基本操作
+
+![image-20200617171119623](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvehigdj1j30w20izdvt.jpg)
+
+
+
+
+#### 什么时候要传入参数的引用“&”？
+
+一种是值类型，使用时会直接复制原值，修改参数不会影响原值
+
+![image-20200617171738597](https://tva1.sinaimg.cn/large/007S8ZIlly1gfveo2ng8wj30xe0h3dnd.jpg)
+
+一种是引用类型，使用时操作的是原值，修改时直接修改原值！（C语言不支持这种引用类型！）
+
+![image-20200617171916923](https://tva1.sinaimg.cn/large/007S8ZIlly1gfveps22edj30wd0fdjyr.jpg)
+
+#### 为什么要实现对数据结构的基本操作？
+
+1. 团队合作编程，你定义的数据结构要让别人能够很方便的使用（封装）
+2. 将常用的操作/运算封装称函数，避免重复工作，降低出错风险。
+
+### 总结
+
+![image-20200617171547528](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvem5coyuj30vq0e3qc9.jpg)
+
+注意⚠️：位序是用1开始计算的！！！
diff --git a/DataStructure/DS_1_LinearList/Doc_1_1_顺序表.md b/DataStructure/DS_1_LinearList/Doc_1_1_顺序表.md
new file mode 100644
index 0000000..2206231
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/Doc_1_1_顺序表.md
@@ -0,0 +1,202 @@
+# 顺序表
+##顺序表的基本概念
+
+![image-20200617172240151](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvetax0y7j30v20a6jwv.jpg)
+
+### 顺序表的定义
+
+![image-20200617172428297](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvev6pex4j30w80gydvc.jpg)
+
+### 顺序表的初始化
+
+#### 静态分配
+
+![image-20200617172843813](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvezlw2d3j30ww0hjqda.jpg)
+
+具体实现：
+
+![image-20200617173539443](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvf6tyv9gj30zh0j67n2.jpg)
+
+```c
+//初始化(静态分配)
+void InitList(SqList &L){
+    for (int i = 0; i < MaxSize; i++) {
+        L.data[i]=0;//将所有元素的初始值默认设置为0
+        //这一步其实可以省略，但是省略之后，有可能受到内存中"脏数据"的影响
+    }
+    L.length=0;
+}
+```
+
+##### 问题反思
+
+1. 如果“数组”存满留怎么办？
+
+可以放弃治疗，顺序表长刚开始确定后就无法更改（存储空间是静态的）
+
+2. 如果一开始就声明一个很大的内存空间呢？会存在什么问题？
+
+浪费，会造成大量的浪费。
+
+#### 动态分配
+
+![image-20200617190108177](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvhnrmmsaj30uw0gnwp4.jpg)
+
+具体实现方式
+
+![image-20200617190651552](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvhtq2yz3j31020jddxd.jpg)
+
+```c
+//初始化（动态方式）
+bool InitList(SeqList &L){
+    //用 malloc 函数申请一片连续的存储空间
+    L.data=(int *)malloc(InitSize*sizeof(int));
+    if (L.data==NULL)
+        //要细心呀，这里不小心写成了赋值语句，但是没有报错，找了半天错误！
+        return false;
+    //(int *) 是指针的强制类型转换
+    L.length=0;
+    L.MaxSize=InitSize;
+    return true;
+}
+```
+
+#### 总结
+
+![image-20200617190838244](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvhvlp3blj30vw0gm48a.jpg)
+
+![image-20200617191008606](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvhx506r8j30w20ga47f.jpg)
+
+### 顺序表的基本操作
+
+#### 插入
+
+ListInsert(&L,i,e):插入操作。在表L中的第i个位置上插入指定元素e。
+
+![image-20200617211304785](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvlh1yhi4j30yt0i6tma.jpg)
+
+详细实现方式：
+
+![image-20200617212225782](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvlqt37s4j30x10howwh.jpg)
+
+优化之后：
+
+![image-20200617212144846](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvlq3dqifj30xg0gjwsn.jpg)
+
+```c
+bool ListInsert(SqList &L,int i,int e){
+    //判断插入的位置是否合法，
+    if (i<1||i>L.length+1)
+        return false;
+    //判断表是否存满了
+    if (L.length>=MaxSize)
+        return false;
+
+    //后面的元素后移
+    for (int j = L.length; j >=i ; j--) {
+        L.data[j]=L.data[j-1];
+    }
+    L.data[i-1]=e;
+    L.length++;
+    return true;
+}
+```
+
+#####插入操作的时间复杂度分析
+
+![image-20200617213723625](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvm6cjrx0j30x80gugxr.jpg)
+
+#### 删除
+
+![image-20200617220850929](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvn335whij30y90i8dww.jpg)
+
+```c
+//删除
+bool ListDelete(SqList &L,int i,int &e){
+    //判断i的位置是否合法
+    if(i<0||i>L.length){
+        return false;
+    }
+    //取出将要被删除的数
+    e=L.data[i-1];
+    //将其后的数据前移
+    for (int j = i; j <=L.length ; j++) {
+        L.data[j-1]=L.data[j];
+    }
+    //线性表长度减一
+    L.length--;
+    return true;
+}
+```
+
+
+
+##### 删除操作的时间复杂度分析
+
+![image-20200617221030044](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvn4sq428j30w20j4qfi.jpg)
+
+#### 总结反思
+
+![image-20200617221250309](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvn78glgxj30x50ffgwe.jpg)
+
+#### 查找
+#####按位查找
+
+GetElem(L,i):按位查找操作，获取表L中第i个位置的元素的值
+
+###### 静态分配状态下的实现方式
+
+![image-20200617222107279](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvnfu8xd7j30st0cf7bq.jpg)
+
+###### 动态分配状态下的实现方式
+
+![image-20200617222212660](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvngzflxoj30wx0hhang.jpg)
+
+用指针加数组下标的方式取数据的时候，数组类型决定着取数据时取几个字节！！
+
+```c
+//按位查找
+int GetElem(SeqList L,int i){
+    //判断是否越界
+    if (i<0||i>L.length)
+        return -1;
+    return L.data[i-1];
+}
+```
+
+###### 按位查找的时间复杂度分析
+
+![image-20200617222451314](https://tva1.sinaimg.cn/large/007S8ZIlly1gfvnjqz0ayj30vk0dvdm6.jpg)
+
+##### 按值查找
+
+![image-20200618215105169](https://tva1.sinaimg.cn/large/007S8ZIlly1gfws6wtavaj30yc0kcaow.jpg)
+
+```c
+//按值查找
+int LocateElem(SeqList L,int e){
+    //循环出查找
+    for (int i = 0; i <L.length ; i++) {
+        if (L.data[i]==e)
+            return i+1; //返回位序
+    }
+    return -1;
+}
+```
+
+###### 结构类型的比较
+
+![image-20200618215217216](https://tva1.sinaimg.cn/large/007S8ZIlly1gfws85u0bfj30vx0h87h6.jpg)
+
+注意：考研初试中华，手写代码可以直接用“==”，无论是ElemType是基本数据类型还是结构类型，手写代码主要考察学生是否理解算法思想，不会严格要求代码完全可运行
+
+有的学校复试考《C语言程序设计》，那么。。。也许就要语法严格一些！
+
+######  按值查找的时间复杂度
+
+![image-20200618215714251](https://tva1.sinaimg.cn/large/007S8ZIlly1gfwsdclu05j30vr0fun79.jpg)
+
+##### 总结反思
+
+![image-20200618215837154](https://tva1.sinaimg.cn/large/007S8ZIlly1gfwseqqu3jj30xm0c7450.jpg)
+
diff --git a/DataStructure/DS_1_LinearList/Doc_1_2_单链表.md b/DataStructure/DS_1_LinearList/Doc_1_2_单链表.md
new file mode 100644
index 0000000..ddece7b
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/Doc_1_2_单链表.md
@@ -0,0 +1,182 @@
+# 单链表
+
+![image-20200618221439465](https://tva1.sinaimg.cn/large/007S8ZIlly1gfwsvfgvpqj30xa0g110c.jpg)
+
+![image-20200618221516210](https://tva1.sinaimg.cn/large/007S8ZIlly1gfwsw28jg4j30m608n76v.jpg)
+
+## 什么是单链表？
+
+![image-20200618221658525](https://tva1.sinaimg.cn/large/007S8ZIlly1gfwsxuuqfcj30w70gk120.jpg)
+
+## 单链表的定义
+
+![image-20200618221959788](https://tva1.sinaimg.cn/large/007S8ZIlly1gfwt0zoggtj30xp0jch19.jpg)
+
+### 别名
+
+![image-20200618222203154](https://tva1.sinaimg.cn/large/007S8ZIlly1gfwt36clauj30vy0gv498.jpg)
+
+![image-20200618222313544](https://tva1.sinaimg.cn/large/007S8ZIlly1gfwt4c4elwj30uz0hf48n.jpg)
+
+注释：或者可以理解为指向头节点的指针既可以表示整个单链表也可以表示头节点，为了便于区分才建议使用 typedef 进行重命名，以方便区别其不同的含义
+
+### 头插法建立单链表
+
+![image-20200619095117732](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxd09ulpaj30w90h3don.jpg)
+
+## 单链表的基本操作
+
+### 单链表的初始化
+
+#### 不带头节点的单链表的初始化
+
+![image-20200619095400757](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxd33bz57j30xd0iydr5.jpg)
+
+#### 带头节点的单链表的初始化
+
+![image-20200619095545238](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxd4wvb40j30we0h0ali.jpg)
+
+#### 两者区别是什么？
+
+![image-20200619095738329](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxd6vl5fjj30w10gewmr.jpg)
+
+### 总结
+
+![image-20200619095821536](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxd7m8hwsj30wy0gkgwc.jpg)
+
+### 插入和删除
+
+![image-20200619104612536](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxelei5ypj30vn0bydkr.jpg)
+
+#### 插入
+
+##### 按位序插入（带头节点的单链表）
+
+![image-20200619105030154](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxepvm0rtj30pf0bm0x5.jpg)
+
+具体实现
+
+分析在表头插入
+
+![image-20200619105401211](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxetj6536j30yq0go49z.jpg)
+
+分析为什么不能颠倒
+
+![image-20200619105451377](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxeuen5f3j30y90glanl.jpg)
+
+分析在表中插入
+
+![image-20200619105800111](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxexom8upj30xu0grn8b.jpg)
+
+分析在表尾插入
+
+![image-20200619110039686](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxf0gbc40j30ya0gmn7y.jpg)
+
+分析插入位置超出表长
+
+![image-20200619110159253](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxf1ut4dbj30yh0gln85.jpg)
+
+总结
+
+![image-20200619110309541](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxf31fw4pj30ug0gok3z.jpg)
+
+##### 按位插入（不带头节点）
+
+![image-20200619110418752](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxf49091ej30pv0cmtd8.jpg)
+
+具体实现
+
+![image-20200619110547637](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxf5s71ezj30xj0hzalf.jpg)
+
+结论：不带头节点的单链表，写代码更不方便，除非特别声明，默认推荐使用带头节点的实现方式，还有要注意在考试中带头、不带头都有可能考察，注意审题。
+
+##### 指定节点的后插操作
+
+![image-20200619111032277](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxfaq6p4vj30up0fhgvd.jpg)
+
+指定节点的前插操作
+
+通过传入头指针实现前插
+
+![image-20200619111607840](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxfgjkvwcj30xz0ge483.jpg)
+
+先进行后插，然后交换前后数据，以此实现前插
+
+![image-20200619111716141](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxfhq2cfqj30sg0gx130.jpg)
+
+![image-20200619111814873](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxfire7naj30rb0g546o.jpg)
+
+#### 删除
+
+##### 带有头节点版本
+
+![image-20200619111915877](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxfjt249oj30ql0arn1l.jpg)
+
+具体实现
+
+![image-20200619135048885](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxjxj0fkej30yk0gdqer.jpg)
+
+###### 删除指定结点
+
+![image-20200619135226089](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxjz7e23hj30tu0futhr.jpg)
+
+如果P是最后一个节点，咋办？
+
+只能从表头表头依次寻找前驱，时间复杂度O(n)
+
+![image-20200619135401028](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxk0tlqn0j30ue0fgqcj.jpg)
+
+单链表的局限性：无法逆向检索！！
+
+#### 总结
+
+![image-20200619135623242](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxk3ajg2pj30wi0frgsp.jpg)
+
+#### 查找
+
+##### 按位查找(带头节点)
+
+![image-20200619152704151](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxmpn8i9wj30yq0ia7cw.jpg)
+
+#####按值查找(带头节点)
+
+![image-20200619153147639](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxmuk9506j30sf0f679p.jpg)
+
+##### 求表的长度(带头节点)
+
+![image-20200619153411974](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxmx2amnnj30rg0e6wj9.jpg)
+
+#### 总结
+
+![image-20200619153525681](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxmych5jgj30rs0b50xf.jpg)
+
+## 单链表的建立方法
+
+![image-20200619153742876](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxn0qz3vgj30sa0ca42l.jpg)
+
+PS：找不到对象就娶一个数据元素吧！哈哈
+
+### 尾插法
+
+第一种方法：
+
+![image-20200619154012867](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxn3c9groj30y00ha15o.jpg)
+
+问题：时间复杂度太高！！可以用一个指针记录最后一个数据元素的位置来优化时间。
+
+优化之后:
+
+![image-20200619172815577](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxq7qma30j30y40hiqeo.jpg)
+
+### 头插法
+
+![image-20200619172945304](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxq9avytdj30to0h1dlw.jpg)
+
+具体实现：
+
+![image-20200619173800669](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxqhvy3nvj30za0js1b5.jpg)
+
+### 总结
+
+![image-20200619173925151](https://tva1.sinaimg.cn/large/007S8ZIlly1gfxqjcvhagj30my0e8gry.jpg)
+
diff --git a/DataStructure/DS_1_LinearList/Doc_1_3_双链表.md b/DataStructure/DS_1_LinearList/Doc_1_3_双链表.md
new file mode 100644
index 0000000..1d3ca9b
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/Doc_1_3_双链表.md
@@ -0,0 +1,36 @@
+# 双链表
+
+
+
+![image-20200620154549814](https://tva1.sinaimg.cn/large/007S8ZIlly1gfysvh4cehj30ee0ajjst.jpg)
+
+## 单链表VS双链表
+
+![image-20200620154721595](https://tva1.sinaimg.cn/large/007S8ZIlly1gfysx267g6j30xg0fx11p.jpg)
+
+## 双链表基本操作
+
+### 初始化
+
+![image-20200620154836876](https://tva1.sinaimg.cn/large/007S8ZIlly1gfysydgbowj30xb0ftn6x.jpg)
+
+### 插入
+
+![image-20200620155038642](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyt0hopthj30rg0gjn3p.jpg)
+
+优化之后
+
+![image-20200620155238232](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyt2jprnqj30yo0gcqdx.jpg)
+
+### 删除
+
+![image-20200620155535132](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyt5mnf8zj30ul0gnn7k.jpg)
+
+### 遍历
+
+![image-20200620155741873](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyt7tv85ij30wy09hwju.jpg)
+
+## 总结反思
+
+![image-20200620155909044](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyt9btkm7j30uf0c77ao.jpg)
+
diff --git a/DataStructure/DS_1_LinearList/Doc_1_4_循环链表.md b/DataStructure/DS_1_LinearList/Doc_1_4_循环链表.md
new file mode 100644
index 0000000..d172967
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/Doc_1_4_循环链表.md
@@ -0,0 +1,38 @@
+# 循环链表
+
+![image-20200620160012077](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytaf2sn1j30fn0ck40l.jpg)
+
+## 循环单链表
+
+![image-20200620160101211](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytba0cflj30ua0a5go9.jpg)
+
+具体实现：
+
+![image-20200620160209813](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytch1jiuj30xa0iek24.jpg)
+
+优势：
+
+![image-20200620160300669](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytdchmujj30ua0cb42g.jpg)
+
+![image-20200620160451334](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytf9swaoj30o20dxq99.jpg)
+
+## 循环双链表
+
+![image-20200620160535337](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytg0xjx0j30vn0c5tck.jpg)
+
+### 初始化
+
+![image-20200620160644172](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyth7yrcij30w10fi11y.jpg)
+
+### 插入
+
+![image-20200620160728846](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyti01525j30sl0g9q81.jpg)
+
+### 删除
+
+![image-20200620160824559](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytiypnxbj30sw0f5gq8.jpg)
+
+## 总结反思
+
+![image-20200620161033347](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytl7mgkzj30z20hmwon.jpg)
+
diff --git a/DataStructure/DS_1_LinearList/Doc_1_5_静态链表.md b/DataStructure/DS_1_LinearList/Doc_1_5_静态链表.md
new file mode 100644
index 0000000..6c8b450
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/Doc_1_5_静态链表.md
@@ -0,0 +1,30 @@
+# 静态链表
+
+![image-20200620161229028](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytn7s67mj30la08040p.jpg)
+
+## 什么是静态链表？
+
+![image-20200620161554872](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytqs11tcj30w70hfn6n.jpg)
+
+## 定义一个静态链表
+
+方法1:
+
+![image-20200620161706934](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytx6l9jfj30uk0gi7a8.jpg)
+
+方法2:
+
+![image-20200620161934969](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytula0g3j30z40jpany.jpg)
+
+验证方法2的定义方法
+
+![image-20200620162124454](https://tva1.sinaimg.cn/large/007S8ZIlly1gfytwhk67rj30yc0h47d4.jpg)
+
+## 基本操作
+
+![image-20200620162512284](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyu0g0vzfj30xy0huwqa.jpg)
+
+### 总结反思
+
+![image-20200620162709709](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyu2hfv4rj30y90huwra.jpg)
+
diff --git a/DataStructure/DS_1_LinearList/Doc_1_6_章节总结.md b/DataStructure/DS_1_LinearList/Doc_1_6_章节总结.md
new file mode 100644
index 0000000..950201c
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/Doc_1_6_章节总结.md
@@ -0,0 +1,42 @@
+# 线性表章节复习反思
+
+![image-20200620162832052](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyu3wovhbj30oj08n77i.jpg)
+
+##逻辑结构对比
+
+![image-20200620162853478](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyu49zzb4j30cr0esmzc.jpg)
+
+## 存储结构对比
+
+![image-20200620163051729](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyu6cnlpwj30x90iugtf.jpg)
+
+## 基本操作对比
+
+![image-20200620163155730](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyu7frurej30l20eeafo.jpg)
+
+### 初始化(创建)
+
+![image-20200620163353375](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyu9hcgf6j30xf0gvwng.jpg)
+
+### 销毁
+
+![image-20200620163638128](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyucbwtg4j30y90hetiv.jpg)
+
+### 增加/删除
+
+![image-20200620163904064](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyuew663yj30vi0h0wql.jpg)
+
+### 查找
+
+![image-20200620164016463](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyug4z61xj30vy0el7ba.jpg)
+
+## 总结
+
+![image-20200620164133349](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyuhgb8chj30mu0ftagw.jpg)
+
+具体使用时，需要根据具体场景去选择
+
+## 开放式答题的思路
+
+![image-20200620164325277](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyuje7i9rj30ul089gq1.jpg)
+
diff --git a/DataStructure/DS_1_LinearList/Doc_1_7错题总结.md b/DataStructure/DS_1_LinearList/Doc_1_7错题总结.md
new file mode 100644
index 0000000..488d1e1
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/Doc_1_7错题总结.md
@@ -0,0 +1,26 @@
+# 错题总结
+
+###2.1 线性表
+
+![image-20200620151207369](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyrwe97y1j314p05zq4j.jpg)
+
+![image-20200620151242645](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyrx0cm6hj31ez08e0wi.jpg)
+
+### 2.1顺序表
+
+![image-20200620153733873](https://tva1.sinaimg.cn/large/007S8ZIlly1gfysmvw0ncj30m003iq3b.jpg)
+
+![image-20200620153751084](https://tva1.sinaimg.cn/large/007S8ZIlly1gfysn6940qj30nz07yabd.jpg)
+
+![image-20200620153817838](https://tva1.sinaimg.cn/large/007S8ZIlly1gfysnmwrcsj30xu052408.jpg)
+
+
+
+![image-20200620153934843](https://tva1.sinaimg.cn/large/007S8ZIlly1gfysoz2g9aj31cm091mzm.jpg)
+
+![image-20200620153947801](https://tva1.sinaimg.cn/large/007S8ZIlly1gfysp6z5u7j30u3032js6.jpg)
+
+![image-20200620154007953](https://tva1.sinaimg.cn/large/007S8ZIlly1gfyspjktpdj30o40220t7.jpg)
+
+**要仔细啊！！就少看了两个字！！**
+
diff --git a/DataStructure/DS_1_LinearList/README.md b/DataStructure/DS_1_LinearList/README.md
new file mode 100644
index 0000000..9abf2e6
--- /dev/null
+++ b/DataStructure/DS_1_LinearList/README.md
@@ -0,0 +1,17 @@
+# 线性表
+
+## 笔记目录
+
+* [线性表](Doc_1_0_线性表.md)
+* [顺序表](Doc_1_1_顺序表.md)
+* [单链表](Doc_1_2_单链表.md)
+* [双链表](Doc_1_3_双链表.md)
+* [循环链表](Doc_1_4_循环链表.md)
+* [静态链表](Doc_1_5_静态链表.md)
+* [章节总结](Doc_1_6_章节总结.md)
+* [错题总结](Doc_1_7错题总结.md)
+
+## 课件目录
+
+
+
diff --git a/DataStructure/DS_2_StackAndQueue/DS_2_0_SqStack.cpp b/DataStructure/DS_2_StackAndQueue/DS_2_0_SqStack.cpp
new file mode 100644
index 0000000..e93e947
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/DS_2_0_SqStack.cpp
@@ -0,0 +1,194 @@
+//
+// Created by kim on 2020/6/21.
+//
+
+//顺序栈的实现
+#include <stdio.h>
+
+# define  MaxSize 10
+typedef struct {
+    int data[MaxSize];
+    int top;
+} SqStack;
+
+//初始化
+void InitStack(SqStack &S) {
+    S.top = -1;//这种初始化的方式，栈顶指针始终指向栈顶元素
+}
+
+//初始化1
+void InitStack1(SqStack &S) {
+    S.top = 0;//这种初始化方式，栈顶指针始终会指向栈顶元素的下一空元素
+}
+
+//入栈
+bool Push(SqStack &S, int t) {
+    if (S.top == MaxSize - 1)return false;//栈满
+    S.data[++S.top] = t;
+//    等价下面两个语句
+//    S.top+=1;//先将栈顶指针指向下一个位置
+//    S.data[S.top]=t;//再填充元素
+    return true;
+}
+
+//入栈，初始化1
+bool Push1(SqStack &S, int t) {
+    if (S.top == MaxSize)return false;//栈满，注意初始化条件不一样判空的条件也不一样了
+    S.data[S.top++] = t;
+//    等价下面两个语句
+//    S.data[S.top]=t;
+//    S.top+=1;
+//注意初始化方式不同，上边的顺序也不一样了，先填充元素，再移动指针
+    return true;
+}
+
+//出栈,并打印出栈顶元素
+bool Pop(SqStack &S, int &x) {
+    //判断
+    if (S.top == -1)return false;//栈空报错
+    x = S.data[S.top--];
+//    等价于下面
+//    x=S.data[S.top];//先取元素
+//    S.top -=1;//再改指针
+    return true;
+}
+
+//出栈,并打印出栈顶元素，初始化1
+bool Pop1(SqStack &S, int &x) {
+    //判断
+    if (S.top == 0)return false;//栈空报错，注意判空条件
+    x = S.data[--S.top];
+//    等价于下面
+//    S.top -=1;
+//    x=S.data[S.top];
+//注意初始化方式不同，上边的顺序也不一样了，先将指针指向当前栈顶元素，再将其取出
+    return true;
+}
+
+//读取栈顶元素
+bool GetTop(SqStack S, int &x) {
+    if (S.top == -1)return false;
+    x = S.data[S.top];
+    return true;
+}
+//读取栈顶元素，初始化1
+bool GetTop1(SqStack S, int &x) {
+    if (S.top == 0)return false;
+    x = S.data[S.top-1];//注意按初始化1的方式，这里指针减1才是栈顶元素的位置，
+    // 同时注意不能使用--S.top,因为这里是读取，不可修改原栈，所以不可和出栈一样
+    //但即时这里你错误使用了--S.top，也不会有问题，因为此处的S是值传递，非引用传递，所以你修改的也只是复制之后的S，不会影响原栈S，即时这样也不建议使用--S.top，如果老师较真的话，可以扣分哒
+    return true;
+}
+
+//读取栈顶元素的第二种实现方式
+//利用返回值返回栈顶元素，若成功就返回栈顶元素，失败就返回-1；
+//缺点：如果栈顶元素就是-1，容易造成误判，正因它的缺点，如果考试考到了它，写这种方式应该是会被扣部分分数的
+int GetTopOther(SqStack S) {
+    if (S.top == -1)return -1;
+    return S.data[S.top];
+}
+
+int GetTopOther1(SqStack S) {
+    if (S.top == 0)return -1;
+    return S.data[S.top-1];
+}
+
+
+//打印整个栈
+void PrintStack(SqStack S){
+    printf("从栈顶元素开始，栈如下：\n");
+    while (S.top>=0){//注意判空的条件
+        printf("S[%d]=%d\n",S.top,S.data[S.top--]);
+    }
+    printf("栈打印完毕\n");
+}
+//打印整个栈，初始化方式1
+void PrintStack1(SqStack S){
+    printf("从栈顶元素开始，栈如下：\n");
+    while (S.top>0){//注意判空的条件
+        printf("S1[%d]=%d\n",S.top-1,S.data[--S.top]);//初始化方式1得先移动指针再获取元素
+    }
+    printf("栈打印完毕\n");
+}
+
+
+void testStack() {
+    printf("开始测试\n");
+    SqStack S;
+    printf("测试第一种初始化方式\n");
+    InitStack(S);
+    if (Push(S,1)){
+        printf("入栈成功啦！\n");
+    } else{
+        printf("入栈失败了\n");
+    }
+    if (Push(S,2)){
+        printf("入栈又成功啦！\n");
+    } else{
+        printf("入栈又失败了\n");
+    }
+    PrintStack(S);
+    int x;
+    if (Pop(S, x)){
+        printf("出栈成功，弹出的元素为:%d\n",x);
+    } else{
+        printf("出栈失败了，再检出一下吧！\n");
+    }
+    PrintStack(S);
+    int x1;
+    if (GetTop(S,x1)){
+        printf("读取栈顶元素成功了，栈顶元素为：%d\n",x1);
+    }else{
+        printf("读取栈顶元素失败，再检查一下吧！\n");
+    }
+    int x4=GetTopOther(S);
+    if (x4!=-1){
+        printf("第二种读取栈顶元素的方式成功了，栈顶元素为：%d\n",x4);
+    } else{
+        printf("第二种读取栈顶元素的方式失败了\n");
+    }
+
+
+    printf("测试第二种初始化方式\n");
+    SqStack S1;
+    InitStack1(S1);
+    if (Push1(S1,1)){
+        printf("入栈成功啦！\n");
+    } else{
+        printf("入栈失败了\n");
+    }
+    if (Push1(S1,2)){
+        printf("入栈又成功啦！\n");
+    } else{
+        printf("入栈又失败了\n");
+    }
+    PrintStack1(S1);
+    int x2;
+    if (Pop1(S1, x2)){
+        printf("出栈成功，弹出的元素为[%d]\n",x2);
+    } else{
+        printf("出栈失败了，再检出一下吧！\n");
+    }
+    PrintStack1(S1);
+    int x3;
+    if (GetTop1(S1,x3)){
+        printf("读取栈顶元素成功了，栈顶元素为：%d\n",x3);
+    }else{
+        printf("读取栈顶元素失败，再检查一下吧！\n");
+    }
+    int x5=GetTopOther1(S1);
+    if (x5!=-1){
+        printf("第二种读取栈顶元素的方式成功了，栈顶元素为：%d\n",x5);
+    } else{
+        printf("第二种读取栈顶元素的方式失败了\n");
+    }
+
+    printf("测试完毕了！\n");
+}
+
+
+int main() {
+    printf("Hello, SqStack!");
+    testStack();
+    return 0;
+}
\ No newline at end of file
diff --git a/DataStructure/DS_2_StackAndQueue/DS_2_1_ShStack.cpp b/DataStructure/DS_2_StackAndQueue/DS_2_1_ShStack.cpp
new file mode 100644
index 0000000..1dc20ef
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/DS_2_1_ShStack.cpp
@@ -0,0 +1,160 @@
+//
+// Created by kim on 2020/6/28.
+//
+
+//共享顺序栈的实现
+//简单来说就是两个栈共享一片存储空间，提高顺序栈的对存储空间的使用率
+#include <stdio.h>
+
+# define  MaxSize 10
+typedef struct {
+    int data[MaxSize];
+    int top0;
+    int top1;
+} ShStack;
+//从结构体的定义就可以看出来，两个共享栈的根源就在于定义两个指针
+
+//初始化
+void InitStack(ShStack &S) {
+    S.top0 = -1;//这种初始化的方式，栈顶指针始终指向栈顶元素
+    S.top1 =MaxSize;//这里的MaxSize就是所谓的第二个栈的栈底
+    //可以根据顺序栈的第二种初试化方式，思考一下这种共享顺序栈的第二种初始化方式
+    //S.top0=0
+    //S.top1=MaxSize-1
+}
+
+
+//入栈0
+bool Push0(ShStack &S, int t) {
+    if (S.top0 +1== S.top1)return false;//注意共享栈满的条件
+    S.data[++S.top0] = t;//仔细品味一下这个++S.top
+    return true;
+}
+//入栈1
+bool Push1(ShStack &S, int t) {
+    if (S.top0 +1== S.top1)return false;//注意共享栈满的条件
+    S.data[--S.top1] = t;//仔细品味一下这个--S.top，想想为什么？
+    return true;
+}
+
+
+
+//出栈,并打印出栈顶元素
+bool Pop0(ShStack &S, int &x) {
+    //判断
+    if (S.top0 == -1)return false;//栈空报错
+    x = S.data[S.top0--];
+//    等价于下面
+//    x=S.data[S.top];//先取元素
+//    S.top -=1;//再改指针
+    return true;
+}
+//出栈1
+bool Pop1(ShStack &S, int &x) {
+    //判断
+    if (S.top1 == MaxSize)return false;//注意一下它的栈空报错条件
+    x = S.data[S.top1++];//注意这个栈修改指针是++
+//    等价于下面
+//    x=S.data[S.top];//先取元素
+//    S.top +=1;//再改指针
+    return true;
+}
+
+//读取栈顶元素，栈0
+bool GetTop0(ShStack S, int &x) {
+    if (S.top0 == -1)return false;
+    x = S.data[S.top0];
+    return true;
+}
+//栈1
+bool GetTop1(ShStack S, int &x) {
+    if (S.top1 == MaxSize)return false;
+    x = S.data[S.top1];
+    return true;
+}
+
+
+//打印整个栈,栈0
+void PrintStack0(ShStack S){
+    printf("从栈顶元素开始，栈如下：\n");
+    while (S.top0>-1){//注意判空的条件
+        printf("S[%d]=%d\n",S.top0,S.data[S.top0--]);
+    }
+    printf("栈打印完毕\n");
+}
+//打印整个栈
+void PrintStack1(ShStack S){
+    printf("从栈顶元素开始，栈如下：\n");
+    while (S.top1<MaxSize){//注意判空的条件
+        printf("S[%d]=%d\n",S.top1,S.data[S.top1++]);
+    }
+    printf("栈打印完毕\n");
+}
+
+void testShStack() {
+    printf("开始测试\n");
+    ShStack S;
+    InitStack(S);
+    printf("测试第一个栈\n");
+    if (Push0(S,1)){
+        printf("入栈成功啦！\n");
+    } else{
+        printf("入栈失败了\n");
+    }
+    if (Push0(S,2)){
+        printf("入栈又成功啦！\n");
+    } else{
+        printf("入栈又失败了\n");
+    }
+    PrintStack0(S);
+    int x;
+    if (Pop0(S, x)){
+        printf("出栈成功，弹出的元素为:%d\n",x);
+    } else{
+        printf("出栈失败了，再检出一下吧！\n");
+    }
+    PrintStack0(S);
+    int x1;
+    if (GetTop0(S,x1)){
+        printf("读取栈顶元素成功了，栈顶元素为：%d\n",x1);
+    }else{
+        printf("读取栈顶元素失败，再检查一下吧！\n");
+    }
+
+
+    printf("测试第一个栈\n");
+    if (Push1(S,10)){
+        printf("入栈成功啦！\n");
+    } else{
+        printf("入栈失败了\n");
+    }
+    if (Push1(S,9)){
+        printf("入栈又成功啦！\n");
+    } else{
+        printf("入栈又失败了\n");
+    }
+    PrintStack1(S);
+    int x3;
+    if (Pop1(S, x3)){
+        printf("出栈成功，弹出的元素为:%d\n",x3);
+    } else{
+        printf("出栈失败了，再检出一下吧！\n");
+    }
+    PrintStack1(S);
+    int x4;
+    if (GetTop1(S,x4)){
+        printf("读取栈顶元素成功了，栈顶元素为：%d\n",x4);
+    }else{
+        printf("读取栈顶元素失败，再检查一下吧！\n");
+    }
+
+
+    printf("测试完毕了！\n");
+}
+
+
+int main() {
+    printf("Hello, ShStack!");
+    testShStack();
+    return 0;
+}
\ No newline at end of file
diff --git a/DataStructure/DS_2_StackAndQueue/DS_2_2_LiStack.cpp b/DataStructure/DS_2_StackAndQueue/DS_2_2_LiStack.cpp
new file mode 100644
index 0000000..5be32b3
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/DS_2_2_LiStack.cpp
@@ -0,0 +1,159 @@
+//
+// Created by kim on 2020/6/28.
+//
+
+//链栈的实现
+#include <stdio.h>
+
+# define  MaxSize 10
+typedef struct {
+    int data[MaxSize];
+    int top0;
+    int top1;
+} ShStack;
+//从结构体的定义就可以看出来，两个共享栈的根源就在于定义两个指针
+
+//初始化
+void InitStack(ShStack &S) {
+    S.top0 = -1;//这种初始化的方式，栈顶指针始终指向栈顶元素
+    S.top1 =MaxSize;//这里的MaxSize就是所谓的第二个栈的栈底
+    //可以根据顺序栈的第二种初试化方式，思考一下这种共享顺序栈的第二种初始化方式
+    //S.top0=0
+    //S.top1=MaxSize-1
+}
+
+
+//入栈0
+bool Push0(ShStack &S, int t) {
+    if (S.top0 +1== S.top1)return false;//注意共享栈满的条件
+    S.data[++S.top0] = t;//仔细品味一下这个++S.top
+    return true;
+}
+//入栈1
+bool Push1(ShStack &S, int t) {
+    if (S.top0 +1== S.top1)return false;//注意共享栈满的条件
+    S.data[--S.top1] = t;//仔细品味一下这个--S.top，想想为什么？
+    return true;
+}
+
+
+
+//出栈,并打印出栈顶元素
+bool Pop0(ShStack &S, int &x) {
+    //判断
+    if (S.top0 == -1)return false;//栈空报错
+    x = S.data[S.top0--];
+//    等价于下面
+//    x=S.data[S.top];//先取元素
+//    S.top -=1;//再改指针
+    return true;
+}
+//出栈1
+bool Pop1(ShStack &S, int &x) {
+    //判断
+    if (S.top1 == MaxSize)return false;//注意一下它的栈空报错条件
+    x = S.data[S.top1++];//注意这个栈修改指针是++
+//    等价于下面
+//    x=S.data[S.top];//先取元素
+//    S.top +=1;//再改指针
+    return true;
+}
+
+//读取栈顶元素，栈0
+bool GetTop0(ShStack S, int &x) {
+    if (S.top0 == -1)return false;
+    x = S.data[S.top0];
+    return true;
+}
+//栈1
+bool GetTop1(ShStack S, int &x) {
+    if (S.top1 == MaxSize)return false;
+    x = S.data[S.top1];
+    return true;
+}
+
+
+//打印整个栈,栈0
+void PrintStack0(ShStack S){
+    printf("从栈顶元素开始，栈如下：\n");
+    while (S.top0>-1){//注意判空的条件
+        printf("S[%d]=%d\n",S.top0,S.data[S.top0--]);
+    }
+    printf("栈打印完毕\n");
+}
+//打印整个栈
+void PrintStack1(ShStack S){
+    printf("从栈顶元素开始，栈如下：\n");
+    while (S.top1<MaxSize){//注意判空的条件
+        printf("S[%d]=%d\n",S.top1,S.data[S.top1++]);
+    }
+    printf("栈打印完毕\n");
+}
+
+void testShStack() {
+    printf("开始测试\n");
+    ShStack S;
+    InitStack(S);
+    printf("测试第一个栈\n");
+    if (Push0(S,1)){
+        printf("入栈成功啦！\n");
+    } else{
+        printf("入栈失败了\n");
+    }
+    if (Push0(S,2)){
+        printf("入栈又成功啦！\n");
+    } else{
+        printf("入栈又失败了\n");
+    }
+    PrintStack0(S);
+    int x;
+    if (Pop0(S, x)){
+        printf("出栈成功，弹出的元素为:%d\n",x);
+    } else{
+        printf("出栈失败了，再检出一下吧！\n");
+    }
+    PrintStack0(S);
+    int x1;
+    if (GetTop0(S,x1)){
+        printf("读取栈顶元素成功了，栈顶元素为：%d\n",x1);
+    }else{
+        printf("读取栈顶元素失败，再检查一下吧！\n");
+    }
+
+
+    printf("测试第一个栈\n");
+    if (Push1(S,10)){
+        printf("入栈成功啦！\n");
+    } else{
+        printf("入栈失败了\n");
+    }
+    if (Push1(S,9)){
+        printf("入栈又成功啦！\n");
+    } else{
+        printf("入栈又失败了\n");
+    }
+    PrintStack1(S);
+    int x3;
+    if (Pop1(S, x3)){
+        printf("出栈成功，弹出的元素为:%d\n",x3);
+    } else{
+        printf("出栈失败了，再检出一下吧！\n");
+    }
+    PrintStack1(S);
+    int x4;
+    if (GetTop1(S,x4)){
+        printf("读取栈顶元素成功了，栈顶元素为：%d\n",x4);
+    }else{
+        printf("读取栈顶元素失败，再检查一下吧！\n");
+    }
+
+
+    printf("测试完毕了！\n");
+}
+
+
+int main() {
+    printf("Hello, ShStack!");
+    testShStack();
+    return 0;
+}
\ No newline at end of file
diff --git a/DataStructure/DS_2_StackAndQueue/Doc_2_0_栈.md b/DataStructure/DS_2_StackAndQueue/Doc_2_0_栈.md
new file mode 100644
index 0000000..782b1c4
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/Doc_2_0_栈.md
@@ -0,0 +1,24 @@
+# 栈
+
+![image-20200624150012426](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3e19r5y8j30u30d9whr.jpg)
+
+## 栈的定义
+
+![image-20200624150149844](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3e2xb551j30w90gl46s.jpg)
+
+![image-20200624150313680](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3e4dmrd7j30tr0epn79.jpg)
+
+![image-20200624150459308](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3e67blrmj30vl0e9n6m.jpg)
+
+## 栈的基本操作
+
+![image-20200624150704360](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3e8dd5asj30x30f7n5z.jpg)
+
+### 出栈顺序
+
+![image-20200624150927909](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3eavbxr9j30ra0fsdlo.jpg)
+
+## 总结
+
+![image-20200624151001874](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ebgf75pj30yv0fo452.jpg)
+
diff --git a/DataStructure/DS_2_StackAndQueue/Doc_2_1_顺序栈.md b/DataStructure/DS_2_StackAndQueue/Doc_2_1_顺序栈.md
new file mode 100644
index 0000000..3806c49
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/Doc_2_1_顺序栈.md
@@ -0,0 +1,41 @@
+# 顺序栈
+
+![image-20200624151201362](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ediqo6gj30n70bvgpc.jpg)
+
+## 顺序栈的定义
+
+![image-20200624151329974](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ef24b97j30wx0hxgvy.jpg)
+
+## 基本操作
+
+### 初始化操作
+
+![image-20200624151413408](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3eftbuugj30wr0i1qbi.jpg)
+
+### 进栈操作
+
+![image-20200624151826628](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ek7hcz7j30xn0icdsu.jpg)
+
+### 出栈操作
+
+![image-20200624152110685](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3en4wi18j30y70idgzs.jpg)
+
+
+
+### 读取栈顶元素
+
+![image-20200624152208184](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3eo1opjcj30xn0hjguw.jpg)
+
+## 另一种基本操作的实现方式：
+
+![image-20200624152341443](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3epo5wa6j30xn0fuwn2.jpg)
+
+![image-20200624152540477](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3erqkql9j31090hrqg4.jpg)
+
+## 共享栈
+
+![image-20200624152655905](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3et1c5a6j30x60j4aib.jpg)
+
+## 总结
+
+![image-20200624152849214](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ev03gkaj30rs0g3aet.jpg)
\ No newline at end of file
diff --git a/DataStructure/DS_2_StackAndQueue/Doc_2_2_链栈.md b/DataStructure/DS_2_StackAndQueue/Doc_2_2_链栈.md
new file mode 100644
index 0000000..adfd045
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/Doc_2_2_链栈.md
@@ -0,0 +1,18 @@
+# 链栈
+
+![image-20200624153019827](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ewkr8m8j30oj0e2770.jpg)
+
+## 复习单链表
+
+![image-20200624153122502](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3exnol1fj30wx0imgtj.jpg)
+
+![image-20200624153252888](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ez8ce1ej30tn0drgrc.jpg)
+
+## 链栈的定义
+
+![image-20200624153433781](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3f0zi9tij30vr0gqn36.jpg)
+
+## 总结
+
+![image-20200624153535956](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3f222idsj30sc0e5tcl.jpg)
+
diff --git a/DataStructure/DS_2_StackAndQueue/Doc_2_3_队列.md b/DataStructure/DS_2_StackAndQueue/Doc_2_3_队列.md
new file mode 100644
index 0000000..ae15378
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/Doc_2_3_队列.md
@@ -0,0 +1,19 @@
+# 队列
+
+![image-20200624153725089](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3f3y8f35j30vf0dgwiw.jpg)
+
+## 队列的定义
+
+![image-20200624153857510](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3f5jwt16j30v90ejdn3.jpg)
+
+![image-20200624154000138](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3f6n5z4yj30u60flh2o.jpg)
+
+![image-20200624154121849](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3f82a7xdj30qi0fuq9i.jpg)
+
+##  队列的基本操作
+
+![image-20200624154224115](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3f9523mrj30y00euth1.jpg)
+
+## 总结
+
+![image-20200624154248823](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3f9k2lh7j30uu0dr79a.jpg)
\ No newline at end of file
diff --git a/DataStructure/DS_2_StackAndQueue/Doc_2_4_顺序队列.md b/DataStructure/DS_2_StackAndQueue/Doc_2_4_顺序队列.md
new file mode 100644
index 0000000..450b246
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/Doc_2_4_顺序队列.md
@@ -0,0 +1,53 @@
+# 顺序队列
+
+![image-20200624154351327](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fanepcfj30ve0dt0vz.jpg)
+
+## 顺序队列的定义
+
+![image-20200624154511213](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fc1hnm0j30y90gktky.jpg)
+
+### 顺序队列的初始化
+
+![image-20200624154606843](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fczuatuj30wu0gzwo7.jpg)
+
+### 入队操作
+
+![image-20200624155112673](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fibcpw0j30ri0f10wh.jpg)
+
+![image-20200624155125271](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fiimg3vj30rf0f8dkr.jpg)
+
+### 循环队列
+
+![image-20200624155155915](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fj238xpj30qs0fdtcd.jpg)
+
+![image-20200624155216098](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fjerveoj30qx0f0785.jpg)
+
+### 出队
+
+![image-20200624155258305](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fk4u3n1j30rk0fpn1s.jpg)
+
+### 判空/判满
+
+方案一：牺牲一个存储空间
+
+![image-20200624155343663](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fkxhd4ij30qz0ftjv5.jpg)
+
+方案二：利用size变量记录队列长度
+
+![image-20200624155414159](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3flg4hgej30qc0euado.jpg)
+
+方案三：利用tag记录最后一次操作
+
+![image-20200624155619066](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fnmgc3dj30qy0f2dkj.jpg)
+
+## 其它实现方式
+
+![image-20200624155808035](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fpi4g82j30pw0djq6j.jpg)
+
+![image-20200624155827353](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fpu5honj30nu0cs76e.jpg)
+
+![image-20200624155906039](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fqii7nrj30nc0dpgnu.jpg)
+
+## 总结
+
+![image-20200624160059508](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fshe0aqj30x40hvwnq.jpg)
\ No newline at end of file
diff --git a/DataStructure/DS_2_StackAndQueue/Doc_2_5_链式队列.md b/DataStructure/DS_2_StackAndQueue/Doc_2_5_链式队列.md
new file mode 100644
index 0000000..e0a30a1
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/Doc_2_5_链式队列.md
@@ -0,0 +1,44 @@
+# 链队列
+
+![image-20200624160150945](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ftdkrv2j30v30ds42h.jpg)
+
+## 链队列的定义
+
+![image-20200624160334221](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fv5uhv6j30sc0grgs5.jpg)
+
+## 链队列的基本操作
+
+### 链队列的初始化
+
+![image-20200624160434942](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fw7qcfij30xq0j0wpo.jpg)
+
+### 入队
+
+带头节点
+
+![image-20200624160602691](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fxqiigij30yu0ffq7q.jpg)
+
+不带头节点
+
+![image-20200624160710140](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3fywji55j30wq0dwn6f.jpg)
+
+### 出队
+
+带有头节点
+
+![image-20200624160905141](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3g0wnhuuj30x50gz465.jpg)
+
+不带头节点
+
+![image-20200624160952329](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3g1prhxgj30w80h1ti9.jpg)
+
+### 判满
+
+![image-20200624161057518](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3g2ugm1lj31050h6jyc.jpg)
+
+## 总结
+
+![image-20200624161134905](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3g3hwkxbj30x70hl7ba.jpg)
+
+
+
diff --git a/DataStructure/DS_2_StackAndQueue/Doc_2_6_双端队列.md b/DataStructure/DS_2_StackAndQueue/Doc_2_6_双端队列.md
new file mode 100644
index 0000000..3223d55
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/Doc_2_6_双端队列.md
@@ -0,0 +1,34 @@
+# 双端队列
+
+![image-20200624161331529](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3g5ijsqaj30og0gt0xt.jpg)
+
+## 双端队列的定义
+
+![image-20200624161416772](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3g6b1zgmj30px0h2gvk.jpg)
+
+## 考点：判断输出序列的合法性
+
+### 对于栈的输出序列的合法性
+
+![image-20200624161642449](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3g8tspcwj30wn0fb441.jpg)
+
+绿色为合法，红色为非法
+
+### 对于输入受限的双端队列的输出序列的合法性
+
+![image-20200624162025565](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3gcpf6fcj30wk0evq9k.jpg)
+
+绿色为合法，红色为非法，带下划线是在栈中不合法，但在输入受限的双端队列中合法的。
+
+### 对于输出受限的双端队列
+
+![image-20200624162509184](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ghmbilrj30w20et454.jpg)
+
+绿色为合法，红色为非法，带下划线是在栈中不合法，但在输出受限的双端队列中合法
+
+这种输出受限的双端队列，看序号较大的元素输出的位置，这意味着，在它输出之前，比它小的元素的相对位置是确定的，接下来就是考虑有什么插入的方法能实现这种相对位置关系！
+
+## 总结
+
+## ![image-20200624162951819](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3gmivt6mj30xv09ddla.jpg)
+
diff --git a/DataStructure/DS_2_StackAndQueue/Doc_2_7_栈的应用.md b/DataStructure/DS_2_StackAndQueue/Doc_2_7_栈的应用.md
new file mode 100644
index 0000000..a3fa621
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/Doc_2_7_栈的应用.md
@@ -0,0 +1,148 @@
+# 栈的应用
+
+## 括号匹配问题
+
+![image-20200624163218954](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3gp2nlldj30rl0epwl9.jpg)
+
+### 实际过程
+
+![image-20200624163415891](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3gr3qzzpj30vp08s41n.jpg)
+
+####正好匹配
+
+![image-20200624163523560](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3gs9w2tjj30lg0g640j.jpg)
+
+####左右不匹配
+
+![image-20200624163548297](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3gsp5eixj30ox0fftbx.jpg)
+
+#### 右括号单身
+
+![image-20200624163638571](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3gtkif5hj30uc0g1gp6.jpg)
+
+#### 左括号单身
+
+![image-20200624163721992](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3gubowzlj30v90f2whs.jpg)
+
+#### 整个流程
+
+![image-20200624163928215](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3gwicyinj30vc0k3aij.jpg)
+
+### 算法实现
+
+![image-20200624164327998](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3h0o6j1pj31010hudsw.jpg)
+
+### 总结
+
+![image-20200624164420239](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3h1knszrj30v00as42w.jpg)
+
+## 表达式求值
+
+![image-20200624164751528](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3h58yijoj30vj0dg0xs.jpg)
+
+### 算数表达式是什么？
+
+由三个部分组成（操作数，运算符，界限符）
+
+![image-20200624165021200](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3h7ua9jbj30wk0g0dm6.jpg)
+
+### 前/后缀表达式的诞生
+
+![image-20200624165107095](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3h8muhumj30mp0gegrp.jpg)
+
+### 中/后/前缀表达式的区别
+
+![image-20200624165500339](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3hcoc0paj30tm0f2jy3.jpg)
+
+#### 中转后的过程：
+
+![image-20200624165755963](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3hfpzb8mj30vv0edjxe.jpg)
+
+**上图中，后缀表达式的算术符的先后次序对应中缀表达式的生效的先后次序**，但是这是一定的吗？
+
+![image-20200624170300224](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3hl04ewvj30yl0gtqfl.jpg)
+
+左优先原则，可保证运算顺序唯一性，以确定机算算法输出结果的唯一性！!
+
+![image-20200624190745666](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3l6tdpuuj30v50gnjxj.jpg)
+
+#### 机算算法实现
+
+![image-20200624191112704](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3laei7pbj30wf0gy10c.jpg) 
+
+![image-20200624191355054](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ld7kfcfj30pk0f4tcy.jpg)
+
+### 中转前的过程
+
+![image-20200624191538706](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3lf0me2pj30nt0egjv1.jpg)
+
+中转后和中转前的区别：
+
+![image-20200624191614443](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3lfmqs26j30ov0en0v6.jpg)
+
+#### 中转前的机算过程：
+
+![image-20200624191810971](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3lhnpy97j30xl0gejzu.jpg)
+
+### 总结
+
+![image-20200624191919379](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3liufbq4j30rg0fy0yf.jpg)
+
+"左优先"/“右优先”原则和左/右操作数不是专业说法，仅供理解！
+
+## 表达式求值——具体代码实现
+
+![image-20200624192258712](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3lmn5bcuj30y407077j.jpg)
+
+### 中转后机算
+
+手算过程：
+
+![image-20200624192506786](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3lov1ve7j30xi0h5n4t.jpg)
+
+机算过程：
+
+![image-20200624193355396](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3ly15bjcj30x20imakj.jpg)
+
+### 中缀表达式的计算
+
+![image-20200624193844266](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3m31iy57j30oh08cjuk.jpg)
+
+![image-20200624194515343](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3m9tycovj30oi0eqjvv.jpg)
+
+CPU只能执行单个的加减乘除运算，上边这么搞的意义就是为了将高级程序语言编译成简单的机器码，让CPU去执行！
+
+### 总结
+
+![image-20200624194707110](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mbr9sqtj30p80dwjyq.jpg)
+
+## 栈在递归中的应用
+
+递归的过程就是函数调用的过程
+
+![image-20200624195132597](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mgdjqtjj30xg0g77e5.jpg)
+
+![image-20200624195412187](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mj4njfsj30q50d4whs.jpg)
+
+### 适合用“递归”算法解决的问题
+
+![image-20200624195452395](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mjtwxqnj30ny0ao40z.jpg)
+
+求阶乘：
+
+![image-20200624195709306](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mm7rbj5j30r50dw79a.jpg)
+
+**使用递归时，需要注意调用栈溢出！**
+
+![image-20200624200031925](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mppmy5uj30py0cxn0f.jpg)
+
+**可以自定义栈将递归算法改造成非递归算法！**
+
+求斐波那契数列
+
+![image-20200624200155981](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mr6it0gj30pd0cwtbu.jpg)
+
+### 总结
+
+![image-20200624200214150](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mrhq6wnj30mq0adtbj.jpg)
+
diff --git a/DataStructure/DS_2_StackAndQueue/Doc_2_8_队列的应用.md b/DataStructure/DS_2_StackAndQueue/Doc_2_8_队列的应用.md
new file mode 100644
index 0000000..1128526
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/Doc_2_8_队列的应用.md
@@ -0,0 +1,26 @@
+# 队列的应用
+
+## 树的层次遍历
+
+提示：不知道树这种数据结构的同学，可以考虑先跳过本文内容，等了解树之后，再来康康～
+
+![image-20200624200711109](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mwnobv8j30y20fwjxo.jpg)
+
+详细实现内容在树的章节实现！
+
+## 图的广度优先遍历
+
+遍历是指找出所有元素节点
+
+![image-20200624200822823](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mxvo8h6j30x40dmn1j.jpg)
+
+## 队列在操作系统中的应用
+
+**CPU资源分配问题**
+
+![image-20200624200936738](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3mz62g39j30wz0exn4l.jpg)
+
+**打印数据缓冲区**
+
+![image-20200624201203709](https://tva1.sinaimg.cn/large/007S8ZIlly1gg3n1pslqoj30mn0cuq69.jpg)
+
diff --git a/DataStructure/DS_2_StackAndQueue/README.md b/DataStructure/DS_2_StackAndQueue/README.md
new file mode 100644
index 0000000..69df42f
--- /dev/null
+++ b/DataStructure/DS_2_StackAndQueue/README.md
@@ -0,0 +1,14 @@
+# 栈和队列
+
+## 笔记目录
+
+*   [栈](Doc_2_0_栈.md)
+*   [顺序栈](Doc_2_1_顺序栈.md)
+*   [链栈](Doc_2_2_链栈.md)
+*   [队列](Doc_2_3_队列.md)
+*   [顺序队列](Doc_2_4_顺序队列.md)
+*   [链式队列](Doc_2_5_链式队列.md)
+*   [双端队列](Doc_2_6_双端队列.md)
+*   [栈的应用](Doc_2_7_栈的应用.md)
+*   [队列的应用](Doc_2_8_队列的应用.md)
+
diff --git a/DataStructure/DS_3_String/Doc_3_0_串.md b/DataStructure/DS_3_String/Doc_3_0_串.md
new file mode 100644
index 0000000..74f14f6
--- /dev/null
+++ b/DataStructure/DS_3_String/Doc_3_0_串.md
@@ -0,0 +1,2 @@
+# 串
+
diff --git a/DataStructure/DS_3_String/README.md b/DataStructure/DS_3_String/README.md
new file mode 100644
index 0000000..dab9c97
--- /dev/null
+++ b/DataStructure/DS_3_String/README.md
@@ -0,0 +1,4 @@
+# 串
+
+## 笔记目录
+
diff --git a/DataStructure/DS_4_TreeAndBinaryTree/README.md b/DataStructure/DS_4_TreeAndBinaryTree/README.md
new file mode 100644
index 0000000..96a3ef2
--- /dev/null
+++ b/DataStructure/DS_4_TreeAndBinaryTree/README.md
@@ -0,0 +1,4 @@
+# 树和二叉树
+
+
+
diff --git a/DataStructure/DS_5_Graph/README.md b/DataStructure/DS_5_Graph/README.md
new file mode 100644
index 0000000..c441bea
--- /dev/null
+++ b/DataStructure/DS_5_Graph/README.md
@@ -0,0 +1,2 @@
+# 图
+
diff --git a/DataStructure/DS_6_Search/README.md b/DataStructure/DS_6_Search/README.md
new file mode 100644
index 0000000..327ef60
--- /dev/null
+++ b/DataStructure/DS_6_Search/README.md
@@ -0,0 +1,2 @@
+# 查找
+
diff --git a/DataStructure/DS_7_Sort/README.md b/DataStructure/DS_7_Sort/README.md
new file mode 100644
index 0000000..7dbafdc
--- /dev/null
+++ b/DataStructure/DS_7_Sort/README.md
@@ -0,0 +1,4 @@
+# 排序
+
+
+
diff --git a/DataStructure/DS_HelloWord.c b/DataStructure/DS_HelloWord.c
new file mode 100644
index 0000000..d3d8173
--- /dev/null
+++ b/DataStructure/DS_HelloWord.c
@@ -0,0 +1,8 @@
+//
+// Created by kim yang on 2020/6/28.
+//
+
+#include <stdio.h>
+ int main(){
+    printf("Hello, DataStructure!");
+}
\ No newline at end of file
diff --git a/DataStructure/PPT/1.0_开篇_数据结构在学什么.pdf b/DataStructure/PPT/1.0_开篇_数据结构在学什么.pdf
new file mode 100644
index 0000000..0e349fc
--- /dev/null
+++ b/DataStructure/PPT/1.0_开篇_数据结构在学什么.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31832ea53409aa17a8e32e42fda4302d97afeb2fbb5b3286a5f4648f3e89492e
+size 6203367
diff --git a/DataStructure/PPT/1.1_数据结构的基本概念.pdf b/DataStructure/PPT/1.1_数据结构的基本概念.pdf
new file mode 100644
index 0000000..509b941
--- /dev/null
+++ b/DataStructure/PPT/1.1_数据结构的基本概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6fa3137ce64182bc9318f76a565fe62467f0009cc253be9b63b03b605683e093
+size 12623104
diff --git a/DataStructure/PPT/1.2_1_算法的基本概念.pdf b/DataStructure/PPT/1.2_1_算法的基本概念.pdf
new file mode 100644
index 0000000..d28ae9d
--- /dev/null
+++ b/DataStructure/PPT/1.2_1_算法的基本概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:155423654a9a3950b8e30b7062f70e2b2f9502c5476fc4fdbbcf584831e565c6
+size 704368
diff --git a/DataStructure/PPT/1.2_2_算法的时间复杂度.pdf b/DataStructure/PPT/1.2_2_算法的时间复杂度.pdf
new file mode 100644
index 0000000..ecc2de5
--- /dev/null
+++ b/DataStructure/PPT/1.2_2_算法的时间复杂度.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e1dbf8971121a0ca598ad789a27d65da1c6f0dce7c814119d14950bb9215d0c
+size 3556760
diff --git a/DataStructure/PPT/1.2_3_算法的空间复杂度.pdf b/DataStructure/PPT/1.2_3_算法的空间复杂度.pdf
new file mode 100644
index 0000000..e403d06
--- /dev/null
+++ b/DataStructure/PPT/1.2_3_算法的空间复杂度.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd95cd2160999e6356fb81753fbaf90d745bbcbd893e25fcef8da982fe600a6e
+size 418353
diff --git a/DataStructure/PPT/2.1_线性表的定义和基本操作.pdf b/DataStructure/PPT/2.1_线性表的定义和基本操作.pdf
new file mode 100644
index 0000000..6c6cd52
--- /dev/null
+++ b/DataStructure/PPT/2.1_线性表的定义和基本操作.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:348871fe8a8aca99948fdc5e04e9eeda04f2de3095f3e1befbb85780a90848c4
+size 1295192
diff --git a/DataStructure/PPT/2.2.1_顺序表的定义.pdf b/DataStructure/PPT/2.2.1_顺序表的定义.pdf
new file mode 100644
index 0000000..c682aa6
--- /dev/null
+++ b/DataStructure/PPT/2.2.1_顺序表的定义.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1de355187c4664ad0ed4c26391c2107c3deef49600fa84c3504a5c72e9856fc5
+size 687807
diff --git a/DataStructure/PPT/2.2.2_1_顺序表的插入删除.pdf b/DataStructure/PPT/2.2.2_1_顺序表的插入删除.pdf
new file mode 100644
index 0000000..8e520fd
--- /dev/null
+++ b/DataStructure/PPT/2.2.2_1_顺序表的插入删除.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:656c085d959c61c2a57ba3aab34e7b9663b180e0be381de009f43d7677a1f63f
+size 769053
diff --git a/DataStructure/PPT/2.2.2_2_顺序表的查找.pdf b/DataStructure/PPT/2.2.2_2_顺序表的查找.pdf
new file mode 100644
index 0000000..c7a6518
--- /dev/null
+++ b/DataStructure/PPT/2.2.2_2_顺序表的查找.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52346caf4d945d9836921176284c1f115b1d1582b3e973fec33a9e6bc0b2e6df
+size 464022
diff --git a/DataStructure/PPT/2.3.1_单链表的定义.pdf b/DataStructure/PPT/2.3.1_单链表的定义.pdf
new file mode 100644
index 0000000..c27a070
--- /dev/null
+++ b/DataStructure/PPT/2.3.1_单链表的定义.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c20be1d8c731c24450669367d3c3cab5fa7fec9b994a17421e2a5de687d18cc
+size 980962
diff --git a/DataStructure/PPT/2.3.2_1_单链表的插入删除.pdf b/DataStructure/PPT/2.3.2_1_单链表的插入删除.pdf
new file mode 100644
index 0000000..8da4d08
--- /dev/null
+++ b/DataStructure/PPT/2.3.2_1_单链表的插入删除.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecb4f0e9bd61e45d73cbabde9bed37c8cc007d3698abc5c415e4bd0e212d798c
+size 1810943
diff --git a/DataStructure/PPT/2.3.2_2_单链表的查找.pdf b/DataStructure/PPT/2.3.2_2_单链表的查找.pdf
new file mode 100644
index 0000000..def1300
--- /dev/null
+++ b/DataStructure/PPT/2.3.2_2_单链表的查找.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c70c1a325e68752d05b3cee37c021146b019067102f6584a7660d77e3299320
+size 648148
diff --git a/DataStructure/PPT/2.3.2_3_单链表的建立.pdf b/DataStructure/PPT/2.3.2_3_单链表的建立.pdf
new file mode 100644
index 0000000..0bf55de
--- /dev/null
+++ b/DataStructure/PPT/2.3.2_3_单链表的建立.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af0ede3a90425abf203d184b40bfb252c2f42b6804320dd24e69d4a7c5c52bb3
+size 662130
diff --git a/DataStructure/PPT/2.3.3_双链表.pdf b/DataStructure/PPT/2.3.3_双链表.pdf
new file mode 100644
index 0000000..8e2305d
--- /dev/null
+++ b/DataStructure/PPT/2.3.3_双链表.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:677e91aee9a82421e94befada1032f7fc602067ecee5a0340ae2dc3350652f78
+size 593854
diff --git a/DataStructure/PPT/2.3.4_循环链表.pdf b/DataStructure/PPT/2.3.4_循环链表.pdf
new file mode 100644
index 0000000..4db0f17
--- /dev/null
+++ b/DataStructure/PPT/2.3.4_循环链表.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e02c1c766f45e06c5ff7bcb3b1082b287a991a5d0c9debe73c6175d4f83a5b1f
+size 603970
diff --git a/DataStructure/PPT/2.3.5_静态链表.pdf b/DataStructure/PPT/2.3.5_静态链表.pdf
new file mode 100644
index 0000000..b22e75c
--- /dev/null
+++ b/DataStructure/PPT/2.3.5_静态链表.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec6402d955e8a5855a36d19aa857a9e328d60da2582ee8be3a72ed36c8ded5af
+size 492334
diff --git a/DataStructure/PPT/2.3.6_顺序表和链表的比较.pdf b/DataStructure/PPT/2.3.6_顺序表和链表的比较.pdf
new file mode 100644
index 0000000..a3be8c3
--- /dev/null
+++ b/DataStructure/PPT/2.3.6_顺序表和链表的比较.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f06bff7bb163b4a832ea4fd2a1c441915e613b8d5f98f31e40e82e3aa8b973f9
+size 995518
diff --git a/DataStructure/PPT/3.1.1_栈的基本概念.pdf b/DataStructure/PPT/3.1.1_栈的基本概念.pdf
new file mode 100644
index 0000000..a608c6f
--- /dev/null
+++ b/DataStructure/PPT/3.1.1_栈的基本概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3609b5fef1d0d7104906ba7b0304d45fefb2181775a6eef735ccf4522cba720
+size 1194421
diff --git a/DataStructure/PPT/3.1.2_栈的顺序存储实现.pdf b/DataStructure/PPT/3.1.2_栈的顺序存储实现.pdf
new file mode 100644
index 0000000..80bfd87
--- /dev/null
+++ b/DataStructure/PPT/3.1.2_栈的顺序存储实现.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:174574f5f6adb004b0ed25f573c56383bcaab141b83afa507f7d7f81d093e4a3
+size 732400
diff --git a/DataStructure/PPT/3.1.3_栈的链式存储实现.pdf b/DataStructure/PPT/3.1.3_栈的链式存储实现.pdf
new file mode 100644
index 0000000..41e311c
--- /dev/null
+++ b/DataStructure/PPT/3.1.3_栈的链式存储实现.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfa426c4ec85f029735969a877b67d85cb5a349985cdf5c6829b55fca08f45cd
+size 503837
diff --git a/DataStructure/PPT/3.2.1_队列的基本概念.pdf b/DataStructure/PPT/3.2.1_队列的基本概念.pdf
new file mode 100644
index 0000000..e88fb7a
--- /dev/null
+++ b/DataStructure/PPT/3.2.1_队列的基本概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26e35fe6b763cec1ca52b79746363afd574750a61678a97e2215310430bcfa45
+size 830453
diff --git a/DataStructure/PPT/3.2.2_队列的顺序实现.pdf b/DataStructure/PPT/3.2.2_队列的顺序实现.pdf
new file mode 100644
index 0000000..45c01b3
--- /dev/null
+++ b/DataStructure/PPT/3.2.2_队列的顺序实现.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd66084cf0a2af71d0d6ab948a4549318ba62488006e224314c2e447e6a0258d
+size 842585
diff --git a/DataStructure/PPT/3.2.3_队列的链式实现.pdf b/DataStructure/PPT/3.2.3_队列的链式实现.pdf
new file mode 100644
index 0000000..b402e7c
--- /dev/null
+++ b/DataStructure/PPT/3.2.3_队列的链式实现.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ead6930fbee282821b49c17e9110a76f7fbea08db592525484856cc53ce59203
+size 627283
diff --git a/DataStructure/PPT/3.2.4_双端队列.pdf b/DataStructure/PPT/3.2.4_双端队列.pdf
new file mode 100644
index 0000000..d991336
--- /dev/null
+++ b/DataStructure/PPT/3.2.4_双端队列.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98821660e12e4a45ffee801be71f57f15dbfc2ad862f49056f3dd1e6c2bc4c2f
+size 253515
diff --git a/DataStructure/PPT/3.3.1_栈在括号匹配中的应用.pdf b/DataStructure/PPT/3.3.1_栈在括号匹配中的应用.pdf
new file mode 100644
index 0000000..70ded3e
--- /dev/null
+++ b/DataStructure/PPT/3.3.1_栈在括号匹配中的应用.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3883310abfa2ed000bea90b7259b7709a1e4510827caf9818f4e20944a554157
+size 453225
diff --git a/DataStructure/PPT/3.3.2_栈在表达式求值中的应用(上).pdf b/DataStructure/PPT/3.3.2_栈在表达式求值中的应用(上).pdf
new file mode 100644
index 0000000..312f6eb
--- /dev/null
+++ b/DataStructure/PPT/3.3.2_栈在表达式求值中的应用(上).pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ff57bf239a7b1213d2808f5e44027229b37a6ad663ca039c568dc4a16aff602
+size 693556
diff --git a/DataStructure/PPT/3.3.2_栈在表达式求值中的应用(下).pdf b/DataStructure/PPT/3.3.2_栈在表达式求值中的应用(下).pdf
new file mode 100644
index 0000000..36c3294
--- /dev/null
+++ b/DataStructure/PPT/3.3.2_栈在表达式求值中的应用(下).pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3471ba935072ba1f71f9893d88a267b7236e8131eb79a3ff909c7a2b56d57004
+size 732782
diff --git a/DataStructure/PPT/3.3.3_栈在递归中的应用.pdf b/DataStructure/PPT/3.3.3_栈在递归中的应用.pdf
new file mode 100644
index 0000000..7cd97da
--- /dev/null
+++ b/DataStructure/PPT/3.3.3_栈在递归中的应用.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c8bc43766bb4c59359c005fc0c6a359833b86ddedc43530c4794b5c4a94dd7e
+size 538957
diff --git a/DataStructure/PPT/3.3.4_队列的应用.pdf b/DataStructure/PPT/3.3.4_队列的应用.pdf
new file mode 100644
index 0000000..d242cc9
--- /dev/null
+++ b/DataStructure/PPT/3.3.4_队列的应用.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bae7481b662d3ca967859e220cd5c39ce22f610571509d65e00353c0fc6cd28f
+size 303257
diff --git a/DataStructure/PPT/3.4_特殊矩阵的压缩存储.pdf b/DataStructure/PPT/3.4_特殊矩阵的压缩存储.pdf
new file mode 100644
index 0000000..a1cd747
--- /dev/null
+++ b/DataStructure/PPT/3.4_特殊矩阵的压缩存储.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ccdb2a971c82468bb6d7adf65a06a5b62a8130456a84301603b3947f4171a248
+size 1089230
diff --git a/DataStructure/PPT/4.1_1_串的定义和基本操作.pdf b/DataStructure/PPT/4.1_1_串的定义和基本操作.pdf
new file mode 100644
index 0000000..c36c021
--- /dev/null
+++ b/DataStructure/PPT/4.1_1_串的定义和基本操作.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e1122e431d55512916019cfbff13ab3696d5440e3bf2c15b240b47b2afe5862
+size 1734717
diff --git a/DataStructure/PPT/4.1_2_串的存储结构.pdf b/DataStructure/PPT/4.1_2_串的存储结构.pdf
new file mode 100644
index 0000000..1557fe5
--- /dev/null
+++ b/DataStructure/PPT/4.1_2_串的存储结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d242b5618b094e9ef568a5997d469e79062cebc00f0e191f12acadefd7059002
+size 575753
diff --git a/DataStructure/PPT/4.2_2_KMP算法.pdf b/DataStructure/PPT/4.2_2_KMP算法.pdf
new file mode 100644
index 0000000..40c75c7
--- /dev/null
+++ b/DataStructure/PPT/4.2_2_KMP算法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ccde1856d0e21f7d8d217eded54bf9fcfeb2ab5baebd585605b6c29bb9c5c331
+size 1276931
diff --git a/DataStructure/PPT/4.2_3_Next数组.pdf b/DataStructure/PPT/4.2_3_Next数组.pdf
new file mode 100644
index 0000000..1b0c427
--- /dev/null
+++ b/DataStructure/PPT/4.2_3_Next数组.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c3fc92454dd983c657286986f9eac771355daa241e57087d6926aa0e23dffef9
+size 821357
diff --git a/DataStructure/PPT/4.2_4_KMP算法再优化.pdf b/DataStructure/PPT/4.2_4_KMP算法再优化.pdf
new file mode 100644
index 0000000..a96abaf
--- /dev/null
+++ b/DataStructure/PPT/4.2_4_KMP算法再优化.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7da6f4eaee8c39bf148266cf40ce7467fe46c8fedada462f83dde03498250b52
+size 295098
diff --git a/DataStructure/PPT/5.1_1_树的定义和基本术语.pdf b/DataStructure/PPT/5.1_1_树的定义和基本术语.pdf
new file mode 100644
index 0000000..494d525
--- /dev/null
+++ b/DataStructure/PPT/5.1_1_树的定义和基本术语.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c892bd535af489f5c957371f593d1b75f2c6fb7c59ecf72033fbfeed72e45c8f
+size 2229753
diff --git a/DataStructure/PPT/5.1_2_树的性质.pdf b/DataStructure/PPT/5.1_2_树的性质.pdf
new file mode 100644
index 0000000..b62c9f1
--- /dev/null
+++ b/DataStructure/PPT/5.1_2_树的性质.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74455dfc4cdef5e04ef602f413c9aa2906a0c05ca9aaf930848931a1918abdc4
+size 587631
diff --git a/DataStructure/PPT/5.2_1_二叉树的定义和基本术语.pdf b/DataStructure/PPT/5.2_1_二叉树的定义和基本术语.pdf
new file mode 100644
index 0000000..897d516
--- /dev/null
+++ b/DataStructure/PPT/5.2_1_二叉树的定义和基本术语.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97514d464ced04c1b8f2a807fe1be4ad30196ed35190af3979204b6fdbf848ea
+size 555119
diff --git a/DataStructure/PPT/5.2_2_二叉树的性质.pdf b/DataStructure/PPT/5.2_2_二叉树的性质.pdf
new file mode 100644
index 0000000..d8604e0
--- /dev/null
+++ b/DataStructure/PPT/5.2_2_二叉树的性质.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb7d9c76651a0c784bcde8b57e4aa3844f8fea0af44ef11a7e250ad705f78abe
+size 260843
diff --git a/DataStructure/PPT/5.2_3_二叉树的存储结构.pdf b/DataStructure/PPT/5.2_3_二叉树的存储结构.pdf
new file mode 100644
index 0000000..56765b8
--- /dev/null
+++ b/DataStructure/PPT/5.2_3_二叉树的存储结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bb4b3f34c0f692962b7fcc95ba839f3ab727b77459074a20e9b244c59fe78f5d
+size 506258
diff --git a/DataStructure/PPT/5.3_1_二叉树的先中后序遍历.pdf b/DataStructure/PPT/5.3_1_二叉树的先中后序遍历.pdf
new file mode 100644
index 0000000..a5cca90
--- /dev/null
+++ b/DataStructure/PPT/5.3_1_二叉树的先中后序遍历.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e325d77e72d93c9a3da188298a06167aacd40a63bec5d70c920e2d997161771
+size 919816
diff --git a/DataStructure/PPT/5.3_2_二叉树的层次遍历.pdf b/DataStructure/PPT/5.3_2_二叉树的层次遍历.pdf
new file mode 100644
index 0000000..c9786d8
--- /dev/null
+++ b/DataStructure/PPT/5.3_2_二叉树的层次遍历.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e851f8d75ef25c0930eaf25f04a57a76fd967878da575b858dd74c3407477c1
+size 212907
diff --git a/DataStructure/PPT/5.3_3_由遍历序列构造二叉树.pdf b/DataStructure/PPT/5.3_3_由遍历序列构造二叉树.pdf
new file mode 100644
index 0000000..f570cfc
--- /dev/null
+++ b/DataStructure/PPT/5.3_3_由遍历序列构造二叉树.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b00f823ab66130353c5d2731e1ad11f8e2743b1d699fda714ec9c5f9f7e13a5
+size 660308
diff --git a/DataStructure/PPT/5.3_4_线索二叉树的概念.pdf b/DataStructure/PPT/5.3_4_线索二叉树的概念.pdf
new file mode 100644
index 0000000..70e9e15
--- /dev/null
+++ b/DataStructure/PPT/5.3_4_线索二叉树的概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50a41ec5b5dfeb93c0799c96fca382964b5e8f63b6766c5320d57f3c13f9d416
+size 743870
diff --git a/DataStructure/PPT/5.3_5_二叉树的线索化.pdf b/DataStructure/PPT/5.3_5_二叉树的线索化.pdf
new file mode 100644
index 0000000..888baa3
--- /dev/null
+++ b/DataStructure/PPT/5.3_5_二叉树的线索化.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:789a95ea3ca6d0d970937bb1745165047b4aa1d382d453edd66dc6c452e7d914
+size 1434552
diff --git a/DataStructure/PPT/5.3_6_在线索二叉树中找前驱后继.pdf b/DataStructure/PPT/5.3_6_在线索二叉树中找前驱后继.pdf
new file mode 100644
index 0000000..806d208
--- /dev/null
+++ b/DataStructure/PPT/5.3_6_在线索二叉树中找前驱后继.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bf43b1931169886e8c2b8e854673b965f256847dd9c15c00233a0bdf1429414
+size 1079422
diff --git a/DataStructure/PPT/5.4_1_树的存储结构.pdf b/DataStructure/PPT/5.4_1_树的存储结构.pdf
new file mode 100644
index 0000000..d89d258
--- /dev/null
+++ b/DataStructure/PPT/5.4_1_树的存储结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:978b961ca5474b26c6513a05b200c8a38567fb1b06b9d79e3672a3cce0941c45
+size 943989
diff --git a/DataStructure/PPT/5.4_2_树和森林的遍历.pdf b/DataStructure/PPT/5.4_2_树和森林的遍历.pdf
new file mode 100644
index 0000000..44f8b51
--- /dev/null
+++ b/DataStructure/PPT/5.4_2_树和森林的遍历.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34aeb84b3af42c8a0b65e239a946c14ae8bc435f06c53b453738ad53cd35cda8
+size 426435
diff --git a/DataStructure/PPT/5.5_1_二叉排序树.pdf b/DataStructure/PPT/5.5_1_二叉排序树.pdf
new file mode 100644
index 0000000..f42edef
--- /dev/null
+++ b/DataStructure/PPT/5.5_1_二叉排序树.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3c9395cea7fef2b903b36d6cf0a6cbbecd38dab4217557625fe993070ef6c8b
+size 923615
diff --git a/DataStructure/PPT/5.5_2_平衡二叉树.pdf b/DataStructure/PPT/5.5_2_平衡二叉树.pdf
new file mode 100644
index 0000000..1888ae6
--- /dev/null
+++ b/DataStructure/PPT/5.5_2_平衡二叉树.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edf400f414c0b51ee4c047e8484d2e2616b44c3da73a6f703d1f729624267bd0
+size 1458525
diff --git a/DataStructure/PPT/5.5_3_哈夫曼树.pdf b/DataStructure/PPT/5.5_3_哈夫曼树.pdf
new file mode 100644
index 0000000..9254f7e
--- /dev/null
+++ b/DataStructure/PPT/5.5_3_哈夫曼树.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f21298a353970a0ed59e86e649764d85eb6e8793043b630c83c1c31eaa16f3a
+size 2869317
diff --git a/DataStructure/PPT/6.1_1_图的基本概念.pdf b/DataStructure/PPT/6.1_1_图的基本概念.pdf
new file mode 100644
index 0000000..f9c8c07
--- /dev/null
+++ b/DataStructure/PPT/6.1_1_图的基本概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f4d6322c0d49299fa25f1bb3d2aad8a5ab55411b5a6b72a07d27359f8e525ae
+size 6312190
diff --git a/DataStructure/PPT/6.2_1_邻接矩阵法.pdf b/DataStructure/PPT/6.2_1_邻接矩阵法.pdf
new file mode 100644
index 0000000..ed6a11b
--- /dev/null
+++ b/DataStructure/PPT/6.2_1_邻接矩阵法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:022a367d80075d8da9a221fa576017879b66300a0c10e860952d4a917ad8efb9
+size 779736
diff --git a/DataStructure/PPT/6.2_2_邻接表法.pdf b/DataStructure/PPT/6.2_2_邻接表法.pdf
new file mode 100644
index 0000000..89aaafc
--- /dev/null
+++ b/DataStructure/PPT/6.2_2_邻接表法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2862af720f62e8ccd43f46a0824b3ab4f2dcf0dc044e0934269acb13e629ef8b
+size 501821
diff --git a/DataStructure/PPT/6.2_3_十字链表、邻接多重表.pdf b/DataStructure/PPT/6.2_3_十字链表、邻接多重表.pdf
new file mode 100644
index 0000000..88bc707
--- /dev/null
+++ b/DataStructure/PPT/6.2_3_十字链表、邻接多重表.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e16be35aab87c1f73d1f5fd07f70abd3cbdb3a314e8599ec624d9a6530c59280
+size 417247
diff --git a/DataStructure/PPT/6.2_4_图的基本操作.pdf b/DataStructure/PPT/6.2_4_图的基本操作.pdf
new file mode 100644
index 0000000..78fc173
--- /dev/null
+++ b/DataStructure/PPT/6.2_4_图的基本操作.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:523d382f6320603f39ca42f4889cf4c7b0d4a9d060e6b3f3f79dedc9642678f1
+size 656231
diff --git a/DataStructure/PPT/6.3_1_图的广度优先遍历.pdf b/DataStructure/PPT/6.3_1_图的广度优先遍历.pdf
new file mode 100644
index 0000000..33c6889
--- /dev/null
+++ b/DataStructure/PPT/6.3_1_图的广度优先遍历.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34efb14a1f4a6a0380b86539b0260150c0627621f6450279557c5c2fb3cff0ff
+size 3210621
diff --git a/DataStructure/PPT/6.3_2_图的深度优先遍历.pdf b/DataStructure/PPT/6.3_2_图的深度优先遍历.pdf
new file mode 100644
index 0000000..91221e9
--- /dev/null
+++ b/DataStructure/PPT/6.3_2_图的深度优先遍历.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9ef290329e9a6a6e96d250dc607c6d25d58e6b77141fdaa430d62680f8f6045
+size 3287267
diff --git a/DataStructure/PPT/6.4_1_最小生成树.pdf b/DataStructure/PPT/6.4_1_最小生成树.pdf
new file mode 100644
index 0000000..3334a4a
--- /dev/null
+++ b/DataStructure/PPT/6.4_1_最小生成树.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd4953e55e89a9b06fbecfac8e0c46e48b5edc05b3714c907c60a4d105c2a9ac
+size 7619958
diff --git a/DataStructure/PPT/6.4_2_最短路径问题_BFS算法.pdf b/DataStructure/PPT/6.4_2_最短路径问题_BFS算法.pdf
new file mode 100644
index 0000000..511862d
--- /dev/null
+++ b/DataStructure/PPT/6.4_2_最短路径问题_BFS算法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d218b1c92b57fd71f73fd244ea1a6484dc342d88ecdf5f4a5039b53a471cbb44
+size 2433632
diff --git a/DataStructure/PPT/6.4_3_最短路径问题_Dijkstra算法.pdf b/DataStructure/PPT/6.4_3_最短路径问题_Dijkstra算法.pdf
new file mode 100644
index 0000000..625c440
--- /dev/null
+++ b/DataStructure/PPT/6.4_3_最短路径问题_Dijkstra算法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4981c553fb6807b91a2bcc46382422c3d34a034d3b5d1d5b87d7a8734eaaa3f
+size 1461897
diff --git a/DataStructure/PPT/6.4_4_最短路径问题_Floyd算法.pdf b/DataStructure/PPT/6.4_4_最短路径问题_Floyd算法.pdf
new file mode 100644
index 0000000..2841f2f
--- /dev/null
+++ b/DataStructure/PPT/6.4_4_最短路径问题_Floyd算法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92e25f4e0c38a90e140a42779cd5b38f9147d56cf93f172fc9ef5e45111a09cf
+size 1621884
diff --git a/DataStructure/PPT/6.4_5_有向无环图描述表达式.pdf b/DataStructure/PPT/6.4_5_有向无环图描述表达式.pdf
new file mode 100644
index 0000000..65ecfc6
--- /dev/null
+++ b/DataStructure/PPT/6.4_5_有向无环图描述表达式.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1ef3cf17b4cd668f01ca63eb2b0142b71e0fc4a39ae247a0fff6dda8f6b8b4b
+size 995448
diff --git a/DataStructure/PPT/6.4_6_拓扑排序.pdf b/DataStructure/PPT/6.4_6_拓扑排序.pdf
new file mode 100644
index 0000000..1422357
--- /dev/null
+++ b/DataStructure/PPT/6.4_6_拓扑排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4b212475edd4fbb2a0bd7dfcd31b80078cf403f172e7ae1aa3cafe713df6f77
+size 3272971
diff --git a/DataStructure/PPT/6.4_7_关键路径.pdf b/DataStructure/PPT/6.4_7_关键路径.pdf
new file mode 100644
index 0000000..375ef7e
--- /dev/null
+++ b/DataStructure/PPT/6.4_7_关键路径.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a44234d2c3cb57333a72b5a96274f29c1357b3a441b89feb1111c40352efd92
+size 1962156
diff --git a/DataStructure/PPT/7.1_查找的基本概念.pdf b/DataStructure/PPT/7.1_查找的基本概念.pdf
new file mode 100644
index 0000000..11a5984
--- /dev/null
+++ b/DataStructure/PPT/7.1_查找的基本概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4716846fff4ab0454fe821bcb802a6daba2f7474bba26e220ba803606bf8993
+size 687762
diff --git a/DataStructure/PPT/7.2_1_顺序查找.pdf b/DataStructure/PPT/7.2_1_顺序查找.pdf
new file mode 100644
index 0000000..baa8803
--- /dev/null
+++ b/DataStructure/PPT/7.2_1_顺序查找.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:650faf1be85ad89d5b440fdaf25adf67e93849be9d2fbe7a6c10cbc3ac48a1de
+size 1082299
diff --git a/DataStructure/PPT/7.2_2_折半查找.pdf b/DataStructure/PPT/7.2_2_折半查找.pdf
new file mode 100644
index 0000000..7e98b28
--- /dev/null
+++ b/DataStructure/PPT/7.2_2_折半查找.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dc17531148072c495bf3e84d152b5c50f4d77c6e4f3cc0bea04d4454634d6a37
+size 1720000
diff --git a/DataStructure/PPT/7.2_3_分块查找.pdf b/DataStructure/PPT/7.2_3_分块查找.pdf
new file mode 100644
index 0000000..61afadb
--- /dev/null
+++ b/DataStructure/PPT/7.2_3_分块查找.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cea0c4012b49e0ecf5f9bfc6a20bf953b69ea99648be6700afdbade47a163e78
+size 1862931
diff --git a/DataStructure/PPT/7.3_1_B树.pdf b/DataStructure/PPT/7.3_1_B树.pdf
new file mode 100644
index 0000000..bbe5caa
--- /dev/null
+++ b/DataStructure/PPT/7.3_1_B树.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d44b436be5988b1c1f06c51a1571c2368ad1ee73a72458b4a5ac8e77fdafa9ca
+size 1299550
diff --git a/DataStructure/PPT/7.3_2_B树的插入删除.pdf b/DataStructure/PPT/7.3_2_B树的插入删除.pdf
new file mode 100644
index 0000000..9c39c6f
--- /dev/null
+++ b/DataStructure/PPT/7.3_2_B树的插入删除.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa4887cab0aa8f6d9b3e2335596ca6e767b7f23289726b32b6d3289d10359158
+size 2409082
diff --git a/DataStructure/PPT/7.3_3_B+树.pdf b/DataStructure/PPT/7.3_3_B+树.pdf
new file mode 100644
index 0000000..cb53b98
--- /dev/null
+++ b/DataStructure/PPT/7.3_3_B+树.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8662becbdb66c57084ae14988cceb940ab8d2da4b1f7c9c05f793db73d085024
+size 963129
diff --git a/DataStructure/PPT/7.4_1_散列查找(上).pdf b/DataStructure/PPT/7.4_1_散列查找(上).pdf
new file mode 100644
index 0000000..180bafd
--- /dev/null
+++ b/DataStructure/PPT/7.4_1_散列查找(上).pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83e7017134694212926b93aac9014981629f9f7741b03dfc3973be139017b739
+size 2059051
diff --git a/DataStructure/PPT/7.4_2_散列查找(下).pdf b/DataStructure/PPT/7.4_2_散列查找(下).pdf
new file mode 100644
index 0000000..0d82c5a
--- /dev/null
+++ b/DataStructure/PPT/7.4_2_散列查找(下).pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e3d3d332f48f6054a027128bcdd92319312132c2405b49734933d3108de3c80
+size 2174132
diff --git a/DataStructure/PPT/8.1_排序的基本概念.pdf b/DataStructure/PPT/8.1_排序的基本概念.pdf
new file mode 100644
index 0000000..85d06d4
--- /dev/null
+++ b/DataStructure/PPT/8.1_排序的基本概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f549a926496082ac09e9d411d471dd5883ff0ca62edf8d7674b2ef8657c9a20
+size 1185875
diff --git a/DataStructure/PPT/8.2_1_插入排序.pdf b/DataStructure/PPT/8.2_1_插入排序.pdf
new file mode 100644
index 0000000..d2a471d
--- /dev/null
+++ b/DataStructure/PPT/8.2_1_插入排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0126f46814a34cc4f422109c2c3d9f8b094c9002d21b0d0b97fdac9b7c8c7ad9
+size 1480172
diff --git a/DataStructure/PPT/8.2_2_希尔排序.pdf b/DataStructure/PPT/8.2_2_希尔排序.pdf
new file mode 100644
index 0000000..1541edc
--- /dev/null
+++ b/DataStructure/PPT/8.2_2_希尔排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:448de980e70f9e0f363227fcab3554285695a893bba61e35226e16f3e6ab9b18
+size 1404812
diff --git a/DataStructure/PPT/8.3_1_冒泡排序.pdf b/DataStructure/PPT/8.3_1_冒泡排序.pdf
new file mode 100644
index 0000000..be1d55c
--- /dev/null
+++ b/DataStructure/PPT/8.3_1_冒泡排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70712718ca67d98e4bcbb5db8bf17d09fe07a136df5e5e2e291abfb49b93cda1
+size 1997065
diff --git a/DataStructure/PPT/8.3_2_快速排序.pdf b/DataStructure/PPT/8.3_2_快速排序.pdf
new file mode 100644
index 0000000..eaca1e4
--- /dev/null
+++ b/DataStructure/PPT/8.3_2_快速排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26da93ba290f2f3303321ff660fd8bd3f8deb514c68ddf5ba824759c2302feaf
+size 2284929
diff --git a/DataStructure/PPT/8.4_1_简单选择排序.pdf b/DataStructure/PPT/8.4_1_简单选择排序.pdf
new file mode 100644
index 0000000..4202ec4
--- /dev/null
+++ b/DataStructure/PPT/8.4_1_简单选择排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b9e9ad417751cc1ef91a734b89eb3c8587dfb0fadc16f5ecbc2f6719960417
+size 684416
diff --git a/DataStructure/PPT/8.4_2_堆排序.pdf b/DataStructure/PPT/8.4_2_堆排序.pdf
new file mode 100644
index 0000000..1d82344
--- /dev/null
+++ b/DataStructure/PPT/8.4_2_堆排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43a15158c5e36c274f2e6bba9ff7446bb197d0f4492ca5ca86279779cce93d6b
+size 3205129
diff --git a/DataStructure/PPT/8.4_3_堆的插入删除.pdf b/DataStructure/PPT/8.4_3_堆的插入删除.pdf
new file mode 100644
index 0000000..2a494e3
--- /dev/null
+++ b/DataStructure/PPT/8.4_3_堆的插入删除.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fac40e1bae206806259a452ac91850e4691d37109dfa6787a8dfb66d399948c1
+size 926269
diff --git a/DataStructure/PPT/8.5_1_归并排序.pdf b/DataStructure/PPT/8.5_1_归并排序.pdf
new file mode 100644
index 0000000..269e3e6
--- /dev/null
+++ b/DataStructure/PPT/8.5_1_归并排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d3e7486c1b8308c80233ca753796bfca117e3b588ac6d69145bd98c92a87240
+size 2154096
diff --git a/DataStructure/PPT/8.5_2_基数排序.pdf b/DataStructure/PPT/8.5_2_基数排序.pdf
new file mode 100644
index 0000000..89c4e1e
--- /dev/null
+++ b/DataStructure/PPT/8.5_2_基数排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ae22dade3cd387d021a321bba86218cd099c340e24c6e3cf66b2c69b54b5aa69
+size 1626882
diff --git a/DataStructure/PPT/8.7_1_外部排序.pdf b/DataStructure/PPT/8.7_1_外部排序.pdf
new file mode 100644
index 0000000..67a3f38
--- /dev/null
+++ b/DataStructure/PPT/8.7_1_外部排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b8090abbd1eee8ed739d0f5064ac09b3e484dd3b93c1da4e65486a8c1611711
+size 34760183
diff --git a/DataStructure/PPT/8.7_2_败者树.pdf b/DataStructure/PPT/8.7_2_败者树.pdf
new file mode 100644
index 0000000..2cb09e6
--- /dev/null
+++ b/DataStructure/PPT/8.7_2_败者树.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9cc9b855489e8a0ec0ad7608314492f7d647fee1ca1c67ffd681e4d31e51e21
+size 2797063
diff --git a/DataStructure/PPT/8.7_3_置换-选择排序.pdf b/DataStructure/PPT/8.7_3_置换-选择排序.pdf
new file mode 100644
index 0000000..442caf0
--- /dev/null
+++ b/DataStructure/PPT/8.7_3_置换-选择排序.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:599d170da255a8b12bd6e01018f2466cafcdbeec9361ea6f5133b53f0b8bb6f1
+size 1221783
diff --git a/DataStructure/PPT/8.7_4_最佳归并树.pdf b/DataStructure/PPT/8.7_4_最佳归并树.pdf
new file mode 100644
index 0000000..158e29b
--- /dev/null
+++ b/DataStructure/PPT/8.7_4_最佳归并树.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c94f0b866a6012c8107ab9b24a5eb16fc62e55a21e4880e1f7db8331693c6c2
+size 847093
diff --git a/DataStructure/README.md b/DataStructure/README.md
new file mode 100644
index 0000000..c54ba5c
--- /dev/null
+++ b/DataStructure/README.md
@@ -0,0 +1,10 @@
+# 数据结构
+
+2021 [王道考研](http://cskaoyan.com/forum.php)课程数据结构源代码！
+
+点击此下载[21 王道数据结构 PDF]()
+
+虽然是.cpp文件，但主要的是用C语言写的，而非C++。
+
+如果想要C++版本的源码，可以参考我学习数据结构时写的一些数据结构的C++版本源码！[传送门](https://github.com/KimYangOfCat/Data_Structure) 在此～
+
diff --git a/Documents.md b/Documents.md
new file mode 100644
index 0000000..3c3c40f
--- /dev/null
+++ b/Documents.md
@@ -0,0 +1,2 @@
+# Documents
+
diff --git a/OperatingSystem/PPT/1.1_1_操作系统的概念、功能.pdf b/OperatingSystem/PPT/1.1_1_操作系统的概念、功能.pdf
new file mode 100644
index 0000000..b3c6f3c
--- /dev/null
+++ b/OperatingSystem/PPT/1.1_1_操作系统的概念、功能.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e0abfd44539b1e71e4846050ca892e88fc53afc1a913bb5ea51f9ae227e82cf
+size 4877932
diff --git a/OperatingSystem/PPT/1.1_2_操作系统的特征.pdf b/OperatingSystem/PPT/1.1_2_操作系统的特征.pdf
new file mode 100644
index 0000000..c64ab14
--- /dev/null
+++ b/OperatingSystem/PPT/1.1_2_操作系统的特征.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32f4bd7480e3d5b1df2832345b8c21b560069f82a58b50951d61b03e741cd6d4
+size 1353304
diff --git a/OperatingSystem/PPT/1.1_3_操作系统的发展与分类.pdf b/OperatingSystem/PPT/1.1_3_操作系统的发展与分类.pdf
new file mode 100644
index 0000000..207cbe4
--- /dev/null
+++ b/OperatingSystem/PPT/1.1_3_操作系统的发展与分类.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:77795dbd5631280605c5e0d1a3e1282676382722b4c78af87f2325835fa421ee
+size 909680
diff --git a/OperatingSystem/PPT/1.1_4_操作系统的运行机制.pdf b/OperatingSystem/PPT/1.1_4_操作系统的运行机制.pdf
new file mode 100644
index 0000000..5f8f552
--- /dev/null
+++ b/OperatingSystem/PPT/1.1_4_操作系统的运行机制.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdfbdb883485d88fa640d38f5728eb7d2acc2ebb641523cd6e51802c6244201e
+size 945497
diff --git a/OperatingSystem/PPT/1.1_5_中断和异常.pdf b/OperatingSystem/PPT/1.1_5_中断和异常.pdf
new file mode 100644
index 0000000..9ba0df4
--- /dev/null
+++ b/OperatingSystem/PPT/1.1_5_中断和异常.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07be571d51ae2269ad6608f8350563c18e16c86ceb71ad2c4fd2e41a2cada69f
+size 541520
diff --git a/OperatingSystem/PPT/1.1_6_系统调用.pdf b/OperatingSystem/PPT/1.1_6_系统调用.pdf
new file mode 100644
index 0000000..c3b6052
--- /dev/null
+++ b/OperatingSystem/PPT/1.1_6_系统调用.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81e30a9fe398df414ace9fba71f4dc49911268e6a304d48a19ae0203154d7c6e
+size 490391
diff --git a/OperatingSystem/PPT/1.1_7_操作系统的体系结构.pdf b/OperatingSystem/PPT/1.1_7_操作系统的体系结构.pdf
new file mode 100644
index 0000000..bfb9eb1
--- /dev/null
+++ b/OperatingSystem/PPT/1.1_7_操作系统的体系结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10343a6815372f7cccf6f9372d7048862995686e593a82d4d91d6c8098f47594
+size 280165
diff --git a/OperatingSystem/PPT/1.1_8_第一章知识回顾.pdf b/OperatingSystem/PPT/1.1_8_第一章知识回顾.pdf
new file mode 100644
index 0000000..99b4ee3
--- /dev/null
+++ b/OperatingSystem/PPT/1.1_8_第一章知识回顾.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cf280a4d14c9f5846551438f89a2c882982c0098a8679ef1add1ef42734d153
+size 619864
diff --git a/OperatingSystem/PPT/2.1_1_进程的概念、组成、特征.pdf b/OperatingSystem/PPT/2.1_1_进程的概念、组成、特征.pdf
new file mode 100644
index 0000000..a977507
--- /dev/null
+++ b/OperatingSystem/PPT/2.1_1_进程的概念、组成、特征.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68b0610399d1b95263b768d01f7d65a08f9c54199f988d05d14c82e31298e81f
+size 1564721
diff --git a/OperatingSystem/PPT/2.1_2_进程的状态与转换、进程的组织.pdf b/OperatingSystem/PPT/2.1_2_进程的状态与转换、进程的组织.pdf
new file mode 100644
index 0000000..c5f6046
--- /dev/null
+++ b/OperatingSystem/PPT/2.1_2_进程的状态与转换、进程的组织.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:15a762f4b5b97d0d546bd8ab33bcfff74960ae0381bfdff839af252174acad36
+size 667347
diff --git a/OperatingSystem/PPT/2.1_3_进程控制.pdf b/OperatingSystem/PPT/2.1_3_进程控制.pdf
new file mode 100644
index 0000000..ca6c25d
--- /dev/null
+++ b/OperatingSystem/PPT/2.1_3_进程控制.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bee0842d5db3791267d8cc451773c28c70b09143bf34d1400bdac844094c7c59
+size 1557830
diff --git a/OperatingSystem/PPT/2.1_4_进程通信.pdf b/OperatingSystem/PPT/2.1_4_进程通信.pdf
new file mode 100644
index 0000000..9afb118
--- /dev/null
+++ b/OperatingSystem/PPT/2.1_4_进程通信.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bc01a87dfb0b7f6ed1445e00764a4d7ec9f6aad25c4b463415bf9d4dd6c5c93
+size 365704
diff --git a/OperatingSystem/PPT/2.1_5_线程的概念与特点.pdf b/OperatingSystem/PPT/2.1_5_线程的概念与特点.pdf
new file mode 100644
index 0000000..d28b31b
--- /dev/null
+++ b/OperatingSystem/PPT/2.1_5_线程的概念与特点.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc423bb2102c2b437fe8b12ef993b2147ec419763966963ffb5b7d47181926f0
+size 602446
diff --git a/OperatingSystem/PPT/2.1_6_线程的实现方式和多线程模型.pdf b/OperatingSystem/PPT/2.1_6_线程的实现方式和多线程模型.pdf
new file mode 100644
index 0000000..e228cfd
--- /dev/null
+++ b/OperatingSystem/PPT/2.1_6_线程的实现方式和多线程模型.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95c7e7ad3d6f102112b08f1075e3d25ff08cda830f11526e7b8283e32b2a8dd6
+size 508333
diff --git a/OperatingSystem/PPT/2.2_1_调度的概念、层次.pdf b/OperatingSystem/PPT/2.2_1_调度的概念、层次.pdf
new file mode 100644
index 0000000..3a12e69
--- /dev/null
+++ b/OperatingSystem/PPT/2.2_1_调度的概念、层次.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f95b8a89ae5e2ec60ec3de42e2d9bc3eb1217b0a8ac0fc23ecf8d67a1fda44b9
+size 543291
diff --git a/OperatingSystem/PPT/2.2_2_进程调度的时机、切换与过程、方式.pdf b/OperatingSystem/PPT/2.2_2_进程调度的时机、切换与过程、方式.pdf
new file mode 100644
index 0000000..b2047ec
--- /dev/null
+++ b/OperatingSystem/PPT/2.2_2_进程调度的时机、切换与过程、方式.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:521f155f32eac5407ae59f439b43aedf77f9ec9f3e0f867c26c9064f7a790064
+size 430446
diff --git a/OperatingSystem/PPT/2.2_3_调度算法的评价指标.pdf b/OperatingSystem/PPT/2.2_3_调度算法的评价指标.pdf
new file mode 100644
index 0000000..0d5d870
--- /dev/null
+++ b/OperatingSystem/PPT/2.2_3_调度算法的评价指标.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b8863fbe485bec5d5e0d1a157d8580bf13716542c62fe80cbaa826f76a58044
+size 626461
diff --git a/OperatingSystem/PPT/2.2_4_调度算法：先来先服务、最短作业优先、最高响应比优先.pdf b/OperatingSystem/PPT/2.2_4_调度算法：先来先服务、最短作业优先、最高响应比优先.pdf
new file mode 100644
index 0000000..0190924
--- /dev/null
+++ b/OperatingSystem/PPT/2.2_4_调度算法：先来先服务、最短作业优先、最高响应比优先.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd7379293a392389721d65f17b93c9921db880790205b1f1767707b8af00da7d
+size 403078
diff --git a/OperatingSystem/PPT/2.2_5_调度算法：时间片轮转、优先级、多级反馈队列.pdf b/OperatingSystem/PPT/2.2_5_调度算法：时间片轮转、优先级、多级反馈队列.pdf
new file mode 100644
index 0000000..a4541f9
--- /dev/null
+++ b/OperatingSystem/PPT/2.2_5_调度算法：时间片轮转、优先级、多级反馈队列.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df68b75c821fbf3c211597b1d17640255583fc2d3ba90c3fdb09b65b83ae5cd4
+size 476605
diff --git a/OperatingSystem/PPT/2.3_10_哲学家进餐问题.pdf b/OperatingSystem/PPT/2.3_10_哲学家进餐问题.pdf
new file mode 100644
index 0000000..a992609
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_10_哲学家进餐问题.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b53850ba7e19ecfa12ecc3032d9000458a1da910ad9b45b85d9058778251a783
+size 507261
diff --git a/OperatingSystem/PPT/2.3_11_管程.pdf b/OperatingSystem/PPT/2.3_11_管程.pdf
new file mode 100644
index 0000000..a03f251
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_11_管程.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c224a1cf3fb1aa2c5103687b945741987ab59754289cb2d584446d5ae2c18138
+size 469110
diff --git a/OperatingSystem/PPT/2.3_1_什么是进程同步、进程互斥.pdf b/OperatingSystem/PPT/2.3_1_什么是进程同步、进程互斥.pdf
new file mode 100644
index 0000000..3f7ed98
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_1_什么是进程同步、进程互斥.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4f697219eac28c46fb8ed05fae87dded0c37bb5cd57a82070a8da6a717b3617
+size 388244
diff --git a/OperatingSystem/PPT/2.3_2_进程互斥的软件实现方法.pdf b/OperatingSystem/PPT/2.3_2_进程互斥的软件实现方法.pdf
new file mode 100644
index 0000000..8a2f7b6
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_2_进程互斥的软件实现方法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b158f8c5acf65198bd8edc87adbdf05521f0e0f3416db058a09d853f49d362e9
+size 894669
diff --git a/OperatingSystem/PPT/2.3_3_进程互斥的硬件实现方法.pdf b/OperatingSystem/PPT/2.3_3_进程互斥的硬件实现方法.pdf
new file mode 100644
index 0000000..a70ec3e
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_3_进程互斥的硬件实现方法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5fbe90dfd31d5fe985804e23563c30b2ef4071a4c8d7dc23e35867a2525a1ee
+size 384409
diff --git a/OperatingSystem/PPT/2.3_4_信号量机制.pdf b/OperatingSystem/PPT/2.3_4_信号量机制.pdf
new file mode 100644
index 0000000..ca86a25
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_4_信号量机制.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f7025fd6cbd22daf32e95c0e6272f2f3a28509b1288260196c898dd52cba6a6f
+size 589220
diff --git a/OperatingSystem/PPT/2.3_5_用信号量实现进程互斥、同步、前驱关系.pdf b/OperatingSystem/PPT/2.3_5_用信号量实现进程互斥、同步、前驱关系.pdf
new file mode 100644
index 0000000..f178499
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_5_用信号量实现进程互斥、同步、前驱关系.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e02d8667705657c340931b587ba741a0322c5769d8c44f3b8f0fa0fc8d44561
+size 474832
diff --git a/OperatingSystem/PPT/2.3_6_生产者-消费者问题.pdf b/OperatingSystem/PPT/2.3_6_生产者-消费者问题.pdf
new file mode 100644
index 0000000..5fd4557
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_6_生产者-消费者问题.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d3e712876e0d2b9f3cddb82ff0f9952d5a31b9c0957db148096a2b49d04cee1
+size 263999
diff --git a/OperatingSystem/PPT/2.3_7_多生产者-多消费者.pdf b/OperatingSystem/PPT/2.3_7_多生产者-多消费者.pdf
new file mode 100644
index 0000000..1ca9781
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_7_多生产者-多消费者.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb6a351c9acaa35a9202e1962ae6f86f1796b3503c03bf6e06424c23c59363ec
+size 315195
diff --git a/OperatingSystem/PPT/2.3_8_吸烟者问题.pdf b/OperatingSystem/PPT/2.3_8_吸烟者问题.pdf
new file mode 100644
index 0000000..cfc0e6f
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_8_吸烟者问题.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c438ef203be94953e38e210143c561940d8dd73e22cbff50ffb48f35e3045b58
+size 283681
diff --git a/OperatingSystem/PPT/2.3_9_读者-写者问题.pdf b/OperatingSystem/PPT/2.3_9_读者-写者问题.pdf
new file mode 100644
index 0000000..dbf2524
--- /dev/null
+++ b/OperatingSystem/PPT/2.3_9_读者-写者问题.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8c3fa53d55392b91a6782d44b3fd9433628404eefd1e1253e0dd6c326d045ab
+size 187913
diff --git a/OperatingSystem/PPT/2.4_1_死锁的概念.pdf b/OperatingSystem/PPT/2.4_1_死锁的概念.pdf
new file mode 100644
index 0000000..bcb29ad
--- /dev/null
+++ b/OperatingSystem/PPT/2.4_1_死锁的概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:601a8df2c19c0f28a6773c652144060c8d9100900d2396a07895c67300dea625
+size 571357
diff --git a/OperatingSystem/PPT/2.4_2_死锁的处理策略—预防死锁.pdf b/OperatingSystem/PPT/2.4_2_死锁的处理策略—预防死锁.pdf
new file mode 100644
index 0000000..b3fca87
--- /dev/null
+++ b/OperatingSystem/PPT/2.4_2_死锁的处理策略—预防死锁.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02a4357c3563a3528c5e293311965357c67844a5e62420c7ab758caff2edbcef
+size 403111
diff --git a/OperatingSystem/PPT/2.4_3_死锁的处理策略—避免死锁.pdf b/OperatingSystem/PPT/2.4_3_死锁的处理策略—避免死锁.pdf
new file mode 100644
index 0000000..9c0c6e5
--- /dev/null
+++ b/OperatingSystem/PPT/2.4_3_死锁的处理策略—避免死锁.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5dbfa2574471a538e8de9144fd422956ff2b8e6b2f45275796ce015cfe677f91
+size 858346
diff --git a/OperatingSystem/PPT/2.4_4_死锁的处理策略—死锁的检测与解除.pdf b/OperatingSystem/PPT/2.4_4_死锁的处理策略—死锁的检测与解除.pdf
new file mode 100644
index 0000000..73ca5b5
--- /dev/null
+++ b/OperatingSystem/PPT/2.4_4_死锁的处理策略—死锁的检测与解除.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7b662da234277f2d54a76748253dfb0554c89cf9beb6dea79304f928eb82426
+size 389490
diff --git a/OperatingSystem/PPT/3.1_10_基本分段存储管理方式.pdf b/OperatingSystem/PPT/3.1_10_基本分段存储管理方式.pdf
new file mode 100644
index 0000000..b3d58e6
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_10_基本分段存储管理方式.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fe81532d6e569c6569b7eab9d4d18cbb3ae58b167ae7da65ab4874f97578c56
+size 411621
diff --git a/OperatingSystem/PPT/3.1_11_段页式管理方式.pdf b/OperatingSystem/PPT/3.1_11_段页式管理方式.pdf
new file mode 100644
index 0000000..8be4892
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_11_段页式管理方式.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36f0b750dbdb90ebce4bd27445aff22a147153abe87e21dc051fb95b26561f01
+size 377726
diff --git a/OperatingSystem/PPT/3.1_1_内存的基础知识.pdf b/OperatingSystem/PPT/3.1_1_内存的基础知识.pdf
new file mode 100644
index 0000000..c899678
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_1_内存的基础知识.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:803b61a67ed11da257883deb9f8dd5ab6b1b7c5b6784b3f277513b4768dbcbdf
+size 1562197
diff --git a/OperatingSystem/PPT/3.1_2_内存管理的概念.pdf b/OperatingSystem/PPT/3.1_2_内存管理的概念.pdf
new file mode 100644
index 0000000..9ee2dbb
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_2_内存管理的概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8cae2bb69f979946ff01154fa100f7ca69a12eb16d39813912a91c8706e7c17
+size 753263
diff --git a/OperatingSystem/PPT/3.1_3_覆盖与交换.pdf b/OperatingSystem/PPT/3.1_3_覆盖与交换.pdf
new file mode 100644
index 0000000..b0e3d5b
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_3_覆盖与交换.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:332ca22286986630f9df883793210c6eb5e8a5f1a2ad19a6052a6c9274c1e71a
+size 396284
diff --git a/OperatingSystem/PPT/3.1_4_连续分配管理方式.pdf b/OperatingSystem/PPT/3.1_4_连续分配管理方式.pdf
new file mode 100644
index 0000000..5fbd1e8
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_4_连续分配管理方式.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cbccea89dcf84eea16840104f32ad48b15fe3c6af713a5ca0a1093b13313dba
+size 459529
diff --git a/OperatingSystem/PPT/3.1_5_动态分区分配算法.pdf b/OperatingSystem/PPT/3.1_5_动态分区分配算法.pdf
new file mode 100644
index 0000000..713829e
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_5_动态分区分配算法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85d9e80ffa59e0c761c56e64e3ff4037d8d5368e854c7a2e4ec4f230185e3e48
+size 223144
diff --git a/OperatingSystem/PPT/3.1_6_基本分页存储管理的基本概念.pdf b/OperatingSystem/PPT/3.1_6_基本分页存储管理的基本概念.pdf
new file mode 100644
index 0000000..81614a6
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_6_基本分页存储管理的基本概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f326be4a1869c55a4e0fe98a2acd49e5cb216f7aa24fbe929b53fc5c38ef4d1
+size 547779
diff --git a/OperatingSystem/PPT/3.1_7_基本地址变换机构.pdf b/OperatingSystem/PPT/3.1_7_基本地址变换机构.pdf
new file mode 100644
index 0000000..f7d238c
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_7_基本地址变换机构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ce84f0021497499e4f73e2bb81a57f08f50ad1888a3dcb70a29ad8b86e71efa
+size 356014
diff --git a/OperatingSystem/PPT/3.1_8_具有快表的地址变换机构.pdf b/OperatingSystem/PPT/3.1_8_具有快表的地址变换机构.pdf
new file mode 100644
index 0000000..062403e
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_8_具有快表的地址变换机构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9056e8ff2e498d0749032cba87668afc648dffd56a27f83f3d549e0280523cd5
+size 617084
diff --git a/OperatingSystem/PPT/3.1_9_两级页表.pdf b/OperatingSystem/PPT/3.1_9_两级页表.pdf
new file mode 100644
index 0000000..da4664e
--- /dev/null
+++ b/OperatingSystem/PPT/3.1_9_两级页表.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac5b3221393b6cb913332e270a02974e4ed9db297f256cbcdb1ea98076c75ff6
+size 382265
diff --git a/OperatingSystem/PPT/3.2_1_虚拟内存的基本概念.pdf b/OperatingSystem/PPT/3.2_1_虚拟内存的基本概念.pdf
new file mode 100644
index 0000000..c29cb0e
--- /dev/null
+++ b/OperatingSystem/PPT/3.2_1_虚拟内存的基本概念.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bc4ef26729780db672111b0396fcde6dae972050bf5e2f19d9f833d0c16e807
+size 547661
diff --git a/OperatingSystem/PPT/3.2_2_请求分页管理方式.pdf b/OperatingSystem/PPT/3.2_2_请求分页管理方式.pdf
new file mode 100644
index 0000000..4f5d69e
--- /dev/null
+++ b/OperatingSystem/PPT/3.2_2_请求分页管理方式.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56e0c19aa7fb0364f418e6e23fbc716604da27328694cdbfb25b36fb8780cfa1
+size 1275747
diff --git a/OperatingSystem/PPT/3.2_3_页面置换算法.pdf b/OperatingSystem/PPT/3.2_3_页面置换算法.pdf
new file mode 100644
index 0000000..6a510ac
--- /dev/null
+++ b/OperatingSystem/PPT/3.2_3_页面置换算法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0eba28827fedbe1bdb4d853e360b42d8e1dccdd82e7837b14b5804155d58b401
+size 364482
diff --git a/OperatingSystem/PPT/3.2_4_页面分配策略.pdf b/OperatingSystem/PPT/3.2_4_页面分配策略.pdf
new file mode 100644
index 0000000..4985269
--- /dev/null
+++ b/OperatingSystem/PPT/3.2_4_页面分配策略.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86157a994d5bf7d8afc8a652295a52a4c02ab65bef08d6cc731f37d5d6dfcd73
+size 426088
diff --git a/OperatingSystem/PPT/4.1_10_文件保护.pdf b/OperatingSystem/PPT/4.1_10_文件保护.pdf
new file mode 100644
index 0000000..0597d63
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_10_文件保护.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6159d148dc7dc3d35a065404b0515b178cd0b33ecb40d0be36cc922a2c76064a
+size 1357166
diff --git a/OperatingSystem/PPT/4.1_11_文件系统的层次结构.pdf b/OperatingSystem/PPT/4.1_11_文件系统的层次结构.pdf
new file mode 100644
index 0000000..c5ab2a9
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_11_文件系统的层次结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ed343caa80bfe7c6480e1eb16cb09a5c4786bd7e9710ca43c62a0f93ea3a2ba
+size 139257
diff --git a/OperatingSystem/PPT/4.1_12_文件系统实例.png b/OperatingSystem/PPT/4.1_12_文件系统实例.png
new file mode 100644
index 0000000..342b026
Binary files /dev/null and b/OperatingSystem/PPT/4.1_12_文件系统实例.png differ
diff --git a/OperatingSystem/PPT/4.1_12_文件系统实例（补充）.png b/OperatingSystem/PPT/4.1_12_文件系统实例（补充）.png
new file mode 100644
index 0000000..36a664c
Binary files /dev/null and b/OperatingSystem/PPT/4.1_12_文件系统实例（补充）.png differ
diff --git a/OperatingSystem/PPT/4.1_1_初识文件管理.pdf b/OperatingSystem/PPT/4.1_1_初识文件管理.pdf
new file mode 100644
index 0000000..9aec439
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_1_初识文件管理.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:306902313d69a7a724e5fe8fb184cbc71fa1be164f7d0a2bd95fcbcfea590f82
+size 971238
diff --git a/OperatingSystem/PPT/4.1_2_文件的逻辑结构.pdf b/OperatingSystem/PPT/4.1_2_文件的逻辑结构.pdf
new file mode 100644
index 0000000..323b266
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_2_文件的逻辑结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:236b0e7b46c08203fbddf6ceef1d6212d1fe081991194bb029f9276b7d0503e3
+size 730743
diff --git a/OperatingSystem/PPT/4.1_3_文件目录.pdf b/OperatingSystem/PPT/4.1_3_文件目录.pdf
new file mode 100644
index 0000000..674c559
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_3_文件目录.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3c69a8f5abcbde94eed9f5c7523be16e6cd496aeb88bf971609761b0ea064f7
+size 535291
diff --git a/OperatingSystem/PPT/4.1_4+4.1_5_文件的物理结构.pdf b/OperatingSystem/PPT/4.1_4+4.1_5_文件的物理结构.pdf
new file mode 100644
index 0000000..edbd6a1
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_4+4.1_5_文件的物理结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13c3daf6860b056d12050c49a3287ecb5d6194e77784362ddb64deebcf10fa21
+size 522834
diff --git a/OperatingSystem/PPT/4.1_6_逻辑结构VS物理结构.pdf b/OperatingSystem/PPT/4.1_6_逻辑结构VS物理结构.pdf
new file mode 100644
index 0000000..29b60e5
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_6_逻辑结构VS物理结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1ca3190a5cbd67bdc67ea75c66bd8a894ac1fdcbd6a66e55cc406f754a01b55
+size 2937091
diff --git a/OperatingSystem/PPT/4.1_7_文件的基本操作.pdf b/OperatingSystem/PPT/4.1_7_文件的基本操作.pdf
new file mode 100644
index 0000000..38d61f4
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_7_文件的基本操作.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d75988b714eee24f38a03593569767522bd49fd3caf45c972315f73f610f5b24
+size 515858
diff --git a/OperatingSystem/PPT/4.1_8_文件存储空间管理.pdf b/OperatingSystem/PPT/4.1_8_文件存储空间管理.pdf
new file mode 100644
index 0000000..2dd7464
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_8_文件存储空间管理.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b9c57c7ac4db988097764487a9a94203926f7ee0200d04d1d82828f7a220daa
+size 604834
diff --git a/OperatingSystem/PPT/4.1_9_文件共享.pdf b/OperatingSystem/PPT/4.1_9_文件共享.pdf
new file mode 100644
index 0000000..d3efdb7
--- /dev/null
+++ b/OperatingSystem/PPT/4.1_9_文件共享.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67542015426f5a57a032828d7924faa562057cb1bf72fa007025ac09eec1d1a9
+size 1366066
diff --git a/OperatingSystem/PPT/4.2_1_磁盘的结构.pdf b/OperatingSystem/PPT/4.2_1_磁盘的结构.pdf
new file mode 100644
index 0000000..7dff8e9
--- /dev/null
+++ b/OperatingSystem/PPT/4.2_1_磁盘的结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a82f66959bd101d84702131d816487f483f3e7a86806522b8f63dec7094eecd6
+size 524992
diff --git a/OperatingSystem/PPT/4.2_2_磁盘调度算法.pdf b/OperatingSystem/PPT/4.2_2_磁盘调度算法.pdf
new file mode 100644
index 0000000..8f7f319
--- /dev/null
+++ b/OperatingSystem/PPT/4.2_2_磁盘调度算法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4b6a1d3524644a4241247a9bb7e190534f53b80bfd7c426f4ec17caf87052e73
+size 440080
diff --git a/OperatingSystem/PPT/4.2_3_减少磁盘延迟时间的方法.pdf b/OperatingSystem/PPT/4.2_3_减少磁盘延迟时间的方法.pdf
new file mode 100644
index 0000000..9643c4c
--- /dev/null
+++ b/OperatingSystem/PPT/4.2_3_减少磁盘延迟时间的方法.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2aa1538c88d54e98b3d2a2cd31b7ea0e69e4a141cfd95ec80d0ae75be25785a6
+size 337804
diff --git a/OperatingSystem/PPT/4.2_4_磁盘的管理.pdf b/OperatingSystem/PPT/4.2_4_磁盘的管理.pdf
new file mode 100644
index 0000000..bbc7edb
--- /dev/null
+++ b/OperatingSystem/PPT/4.2_4_磁盘的管理.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e42a2b1fc51c6d673d2bfe64080a7c8d06f60dc1e2f23d938e3869d0169d4f05
+size 290959
diff --git a/OperatingSystem/PPT/5.1_1_IO设备的基本概念和分类.pdf b/OperatingSystem/PPT/5.1_1_IO设备的基本概念和分类.pdf
new file mode 100644
index 0000000..35b39d8
--- /dev/null
+++ b/OperatingSystem/PPT/5.1_1_IO设备的基本概念和分类.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:749686221fcfaf663ac9966c80949b692b161c1dadd9ddac78630c2a775805b9
+size 1373064
diff --git a/OperatingSystem/PPT/5.1_2_IO控制器.pdf b/OperatingSystem/PPT/5.1_2_IO控制器.pdf
new file mode 100644
index 0000000..ddf5daa
--- /dev/null
+++ b/OperatingSystem/PPT/5.1_2_IO控制器.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e9adc29ae40b0bc6cb33473c7e45a258d6a915a82cfe3d3a0bfff0f89a38d45
+size 1030862
diff --git a/OperatingSystem/PPT/5.1_3_IO控制方式.pdf b/OperatingSystem/PPT/5.1_3_IO控制方式.pdf
new file mode 100644
index 0000000..eb8f332
--- /dev/null
+++ b/OperatingSystem/PPT/5.1_3_IO控制方式.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c301c44dbf6f55cb7a2ccb8364f66e6f80c8e2ab3a9bfa51ea726808b8dfd3c
+size 537605
diff --git a/OperatingSystem/PPT/5.1_4_IO软件层次结构.pdf b/OperatingSystem/PPT/5.1_4_IO软件层次结构.pdf
new file mode 100644
index 0000000..a6fbdba
--- /dev/null
+++ b/OperatingSystem/PPT/5.1_4_IO软件层次结构.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:321fb4558f65badecb724eccd833e755163b8e4181d3b20b3fd9b7f2055f97b3
+size 732779
diff --git a/OperatingSystem/PPT/5.1_5_IO核心子系统.pdf b/OperatingSystem/PPT/5.1_5_IO核心子系统.pdf
new file mode 100644
index 0000000..a9025f0
--- /dev/null
+++ b/OperatingSystem/PPT/5.1_5_IO核心子系统.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ba28eca7a57d12a6128c7b3a09cb966785b506c6668ff4b8cb06cea2c384a88
+size 170414
diff --git a/OperatingSystem/PPT/5.1_6_假脱机技术.pdf b/OperatingSystem/PPT/5.1_6_假脱机技术.pdf
new file mode 100644
index 0000000..7236562
--- /dev/null
+++ b/OperatingSystem/PPT/5.1_6_假脱机技术.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0411f9771975c81d38d491d8ee9a1806a6086a1bc8cb1a899055815ff8809eb1
+size 562100
diff --git a/OperatingSystem/PPT/5.1_7_设备的分配与回收.pdf b/OperatingSystem/PPT/5.1_7_设备的分配与回收.pdf
new file mode 100644
index 0000000..9e80a5c
--- /dev/null
+++ b/OperatingSystem/PPT/5.1_7_设备的分配与回收.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d53b5b7fbe8abd0946405b205830175e38b2d18e49a74f1a3de192598d0ad572
+size 540657
diff --git a/OperatingSystem/PPT/5.1_8_缓冲区管理.pdf b/OperatingSystem/PPT/5.1_8_缓冲区管理.pdf
new file mode 100644
index 0000000..4386a5c
--- /dev/null
+++ b/OperatingSystem/PPT/5.1_8_缓冲区管理.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4725ee2c9855c976b7b61cc612d156d0e4161bdb28f59dee810ba769a72a18f6
+size 477522
diff --git a/OperatingSystem/README.md b/OperatingSystem/README.md
new file mode 100644
index 0000000..e456a8b
--- /dev/null
+++ b/OperatingSystem/README.md
@@ -0,0 +1 @@
+# OperatingSystem
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..f1b17b6
--- /dev/null
+++ b/README.md
@@ -0,0 +1,73 @@
+# 2021-CSKaoYan-408
+
+![](https://img.shields.io/github/languages/top/KimYangOfCat/2021-CSKaoYan-408?color=F8008E)
+![](https://img.shields.io/static/v1?label=&message=DataStructure&color=brightgreen)
+![](https://img.shields.io/static/v1?label=&message=CpmputerOrganization&color=blueviolet)
+![](https://img.shields.io/static/v1?label=&message=NetWork&color=blue)
+![](https://img.shields.io/static/v1?label=&message=OperatingSystem&color=important)
+
+本仓库主要记录了一些我在学习408的过程中的笔记以及常见的DataStructure的算法源码。虽然408被誉为CS考研中最难的专业课，
+但是对我而言，学习它只是对我自己专业知识的弥补提升，对未来的职业发展也会有+∞益处。
+
+## 20年考408的院校(信息来源于网络，更准确的信息请于各高校官网查询)
+
+### 985高校
+
+-   浙江大学
+-   上海交通大学
+-   同济大学
+-   中国科学技术大学
+-   武汉大学【新增】
+-   南开大学【新增】
+-   复旦大学【新增】
+-   华东师范大学【新增】
+-   中山大学
+-   华南理工大学
+
+### 211高校
+
+-   海南大学
+-   广西大学
+-   宁夏大学
+-   贵州大学【新增】
+-   青海大学
+-   上海大学
+-   郑州大学【新增】
+-   云南大学【新增】
+-   河北工业大学【新增】
+-   华中农业大学【新增】
+-   西南财经大学
+-   武汉理工大学【新增】
+
+## 408 科目
+
+### [数据结构](DataStructure)
+
+
+### [计算机组成原理](ComputerOrganization)
+
+
+### [操作系统](OperatingSystem)
+
+
+### [计算机网络](ComputerNetwork)
+
+## 辅导书籍
+
+### [王道系列](/PDF/王道考研%20PDF)
+
+王道系列起源于[王道考研论坛](http://cskaoyan.com/)，从它的论坛中，你能找到不少经验贴，非常值得关注！而王道系列辅导书籍，题量充足，知识点全面，可能更适合科班考研🈶️一定专业课基础的同学。
+
+### [天勤系列](/PDF/天勤考研%20PDF)
+
+天勤系列，相比于王道更注重基础知识，，但是题量并没有王道的多。也正是由于它更注重基础，所以也许它更适合跨考计算机的同学。
+
+
+但是总的来说，辅导资料这一块儿还是适合自己的最好。所以对自己的知识储备有较为清晰的认识也许对你复习 408 更有帮助。
+
+## 贡献
+
+看到这里了，如果觉得对你有所帮助的话，不妨给本仓库点个Star吧！
+
+如果你有新的内容📜想要贡献到本仓库或者发现了本仓库的一些错误🐛，👏🏻欢迎阅读[贡献文档](Documents.md)提交Pr～
+