Revert "auto commit"

This reverts commit 77e6e9e846.
2019-04-25 17:39:10 +08:00
parent 77e6e9e846
commit 761a9ecd9a
835 changed files with 0 additions and 32626 deletions
@@ -1,95 +0,0 @@
-<!-- GFM-TOC -->
-* [一、解决的问题](#一解决的问题)
-* [二、与虚拟机的比较](#二与虚拟机的比较)
-* [三、优势](#三优势)
-* [四、使用场景](#四使用场景)
-* [五、镜像与容器](#五镜像与容器)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 一、解决的问题
-
-由于不同的机器有不同的操作系统，以及不同的库和组件，在将一个应用部署到多台机器上需要进行大量的环境配置操作。
-
-Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其它机器上。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/011f3ef6-d824-4d43-8b2c-36dab8eaaa72-1.png" width="400px"/> </div><br>
-
-# 二、与虚拟机的比较
-
-虚拟机也是一种虚拟化技术，它与 Docker 最大的区别在于它是通过模拟硬件，并在硬件上安装操作系统来实现。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/be608a77-7b7f-4f8e-87cc-f2237270bf69.png" width="500"/> </div><br>
-
-## 启动速度
-
-启动虚拟机需要先启动虚拟机的操作系统，再启动应用，这个过程非常慢；
-
-而启动 Docker 相当于启动宿主操作系统上的一个进程。
-
-## 占用资源
-
-虚拟机是一个完整的操作系统，需要占用大量的磁盘、内存和 CPU 资源，一台机器只能开启几十个的虚拟机。
-
-而 Docker 只是一个进程，只需要将应用以及相关的组件打包，在运行时占用很少的资源，一台机器可以开启成千上万个 Docker。
-
-# 三、优势
-
-除了启动速度快以及占用资源少之外，Docker 具有以下优势：
-
-## 更容易迁移
-
-提供一致性的运行环境。已经打包好的应用可以在不同的机器上进行迁移，而不用担心环境变化导致无法运行。
-
-## 更容易维护
-
-使用分层技术和镜像，使得应用可以更容易复用重复的部分。复用程度越高，维护工作也越容易。
-
-## 更容易扩展
-
-可以使用基础镜像进一步扩展得到新的镜像，并且官方和开源社区提供了大量的镜像，通过扩展这些镜像可以非常容易得到我们想要的镜像。
-
-# 四、使用场景
-
-## 持续集成
-
-持续集成指的是频繁地将代码集成到主干上，这样能够更快地发现错误。
-
-Docker 具有轻量级以及隔离性的特点，在将代码集成到一个 Docker 中不会对其它 Docker 产生影响。
-
-## 提供可伸缩的云服务
-
-根据应用的负载情况，可以很容易地增加或者减少 Docker。
-
-## 搭建微服务架构
-
-Docker 轻量级的特点使得它很适合用于部署、维护、组合微服务。
-
-# 五、镜像与容器
-
-镜像是一种静态的结构，可以看成面向对象里面的类，而容器是镜像的一个实例。
-
-镜像包含着容器运行时所需要的代码以及其它组件，它是一种分层结构，每一层都是只读的（read-only layers）。构建镜像时，会一层一层构建，前一层是后一层的基础。镜像的这种分层存储结构很适合镜像的复用以及定制。
-
-构建容器时，通过在镜像的基础上添加一个可写层（writable layer），用来保存着容器运行过程中的修改。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/docker-filesystems-busyboxrw.png"/> </div><br>
-
-# 参考资料
-
- [DOCKER 101: INTRODUCTION TO DOCKER WEBINAR RECAP](https://blog.docker.com/2017/08/docker-101-introduction-docker-webinar-recap/)
- [Docker 入门教程](http://www.ruanyifeng.com/blog/2018/02/docker-tutorial.html)
- [Docker container vs Virtual machine](http://www.bogotobogo.com/DevOps/Docker/Docker_Container_vs_Virtual_Machine.php)
- [How to Create Docker Container using Dockerfile](https://linoxide.com/linux-how-to/dockerfile-create-docker-container/)
- [理解 Docker（2）：Docker 镜像](http://www.cnblogs.com/sammyliu/p/5877964.html)
- [为什么要使用 Docker？](https://yeasy.gitbooks.io/docker_practice/introduction/why.html)
- [What is Docker](https://www.docker.com/what-docker)
- [持续集成是什么？](http://www.ruanyifeng.com/blog/2015/09/continuous-integration.html)
-
-
-
-
-
-</br><div align="center">🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。</div></br>
-<div align="center"><img width="180px" src="https://cyc-1256109796.cos.ap-guangzhou.myqcloud.com/%E5%85%AC%E4%BC%97%E5%8F%B7.jpg"></img></div>
@@ -1,166 +0,0 @@
-<!-- GFM-TOC -->
-* [集中式与分布式](#集中式与分布式)
-* [中心服务器](#中心服务器)
-* [工作流](#工作流)
-* [分支实现](#分支实现)
-* [冲突](#冲突)
-* [Fast forward](#fast-forward)
-* [分支管理策略](#分支管理策略)
-* [储藏（Stashing）](#储藏stashing)
-* [SSH 传输设置](#ssh-传输设置)
-* [.gitignore 文件](#gitignore-文件)
-* [Git 命令一览](#git-命令一览)
-* [参考资料](#参考资料)
-<!-- GFM-TOC -->
-
-
-# 集中式与分布式
-
-Git 属于分布式版本控制系统，而 SVN 属于集中式。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/1fe2dc77-9a2d-4643-90b3-bbf50f649bac.png" width="600px"> </div><br>
-
-集中式版本控制只有中心服务器拥有一份代码，而分布式版本控制每个人的电脑上就有一份完整的代码。
-
-集中式版本控制有安全性问题，当中心服务器挂了所有人都没办法工作了。
-
-集中式版本控制需要连网才能工作，如果网速过慢，那么提交一个文件的会慢的无法让人忍受。而分布式版本控制不需要连网就能工作。
-
-分布式版本控制新建分支、合并分支操作速度非常快，而集中式版本控制新建一个分支相当于复制一份完整代码。
-
-# 中心服务器
-
-中心服务器用来交换每个用户的修改，没有中心服务器也能工作，但是中心服务器能够 24 小时保持开机状态，这样就能更方便的交换修改。
-
-Github 就是一个中心服务器。
-
-# 工作流
-
-新建一个仓库之后，当前目录就成为了工作区，工作区下有一个隐藏目录 .git，它属于 Git 的版本库。
-
-Git 的版本库有一个称为 Stage 的暂存区以及最后的 History 版本库，History 中存有所有分支，使用一个 HEAD 指针指向当前分支。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/71b97a50-a49f-4f1a-81d1-48c3364d61b3.png" width="700px"> </div><br>
-
- git add files 把文件的修改添加到暂存区
- git commit 把暂存区的修改提交到当前分支，提交之后暂存区就被清空了
- git reset -- files 使用当前分支上的修改覆盖暂存区，用来撤销最后一次 git add files
- git checkout -- files 使用暂存区的修改覆盖工作目录，用来撤销本地修改
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/603dbb49-dac5-4825-9694-5f1d65cefd44.png" width="320px"> </div><br>
-
-可以跳过暂存区域直接从分支中取出修改，或者直接提交修改到分支中。
-
- git commit -a 直接把所有文件的修改添加到暂存区然后执行提交
- git checkout HEAD -- files 取出最后一次修改，可以用来进行回滚操作
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/265bab88-7be9-44c5-a33f-f93d9882c096.png" width="500px"> </div><br>
-
-# 分支实现
-
-使用指针将每个提交连接成一条时间线，HEAD 指针指向当前分支指针。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/ec4d7464-7140-46d8-827e-d63634202e1e.png" width="220px"> </div><br>
-
-新建分支是新建一个指针指向时间线的最后一个节点，并让 HEAD 指针指向新分支表示新分支成为当前分支。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/66d00642-ce37-466c-8f7a-143d0bf84cd6.png" width="220px"> </div><br>
-
-每次提交只会让当前分支指针向前移动，而其它分支指针不会移动。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/72a01242-e6b4-46c5-a285-24e754d63093.png" width="300px"> </div><br>
-
-合并分支也只需要改变指针即可。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/94617147-0cbd-4a28-847d-81e52efb1b1e.png" width="300px"> </div><br>
-
-# 冲突
-
-当两个分支都对同一个文件的同一行进行了修改，在分支合并时就会产生冲突。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/32b05e81-41b3-414a-8656-736c9604e3d6.png" width="300px"> </div><br>
-
-Git 会使用 <<<<<<< ，======= ，>>>>>>> 标记出不同分支的内容，只需要把不同分支中冲突部分修改成一样就能解决冲突。
-
-```
-<<<<<<< HEAD
-Creating a new branch is quick & simple.
-=======
-Creating a new branch is quick AND simple.
->>>>>>> feature1
-```
-
-# Fast forward
-
-"快进式合并"（fast-farward merge），会直接将 master 分支指向合并的分支，这种模式下进行分支合并会丢失分支信息，也就不能在分支历史上看出分支信息。
-
-可以在合并时加上 --no-ff 参数来禁用 Fast forward 模式，并且加上 -m 参数让合并时产生一个新的 commit。
-
-```
-$ git merge --no-ff -m "merge with no-ff" dev
-```
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/9a519773-84b2-4c81-81cf-4e7dd739a97a.png" width="350px"> </div><br>
-
-# 分支管理策略
-
-master 分支应该是非常稳定的，只用来发布新版本；
-
-日常开发在开发分支 dev 上进行。
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/245fd2fb-209c-4ad5-bc5e-eb5664966a0e.jpg" width=""> </div><br>
-
-# 储藏（Stashing）
-
-在一个分支上操作之后，如果还没有将修改提交到分支上，此时进行切换分支，那么另一个分支上也能看到新的修改。这是因为所有分支都共用一个工作区的缘故。
-
-可以使用 git stash 将当前分支的修改储藏起来，此时当前工作区的所有修改都会被存到栈上，也就是说当前工作区是干净的，没有任何未提交的修改。此时就可以安全的切换到其它分支上了。
-
-```
-$ git stash
-Saved working directory and index state \ "WIP on master: 049d078 added the index file"
-HEAD is now at 049d078 added the index file (To restore them type "git stash apply")
-```
-
-该功能可以用于 bug 分支的实现。如果当前正在 dev 分支上进行开发，但是此时 master 上有个 bug 需要修复，但是 dev 分支上的开发还未完成，不想立即提交。在新建 bug 分支并切换到 bug 分支之前就需要使用 git stash 将 dev 分支的未提交修改储藏起来。
-
-# SSH 传输设置
-
-Git 仓库和 Github 中心仓库之间的传输是通过 SSH 加密。
-
-如果工作区下没有 .ssh 目录，或者该目录下没有 id_rsa 和 id_rsa.pub 这两个文件，可以通过以下命令来创建 SSH Key：
-
-```
-$ ssh-keygen -t rsa -C "youremail@example.com"
-```
-
-然后把公钥 id_rsa.pub 的内容复制到 Github "Account settings" 的 SSH Keys 中。
-
-# .gitignore 文件
-
-忽略以下文件：
-
- 操作系统自动生成的文件，比如缩略图；
- 编译生成的中间文件，比如 Java 编译产生的 .class 文件；
- 自己的敏感信息，比如存放口令的配置文件。
-
-不需要全部自己编写，可以到 [https://github.com/github/gitignore](https://github.com/github/gitignore) 中进行查询。
-
-# Git 命令一览
-
-<div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/7a29acce-f243-4914-9f00-f2988c528412.jpg" width=""> </div><br>
-
-比较详细的地址：http://www.cheat-sheets.org/saved-copy/git-cheat-sheet.pdf
-
-# 参考资料
-
- [Git - 简明指南](http://rogerdudler.github.io/git-guide/index.zh.html)
- [图解 Git](http://marklodato.github.io/visual-git-guide/index-zh-cn.html)
- [廖雪峰 : Git 教程](https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000)
- [Learn Git Branching](https://learngitbranching.js.org/)
-
-
-
-
-</br><div align="center">🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。</div></br>
-<div align="center"><img width="180px" src="https://cyc-1256109796.cos.ap-guangzhou.myqcloud.com/%E5%85%AC%E4%BC%97%E5%8F%B7.jpg"></img></div>
@@ -1,109 +0,0 @@
-<!-- GFM-TOC -->
-* [1. 给表达式加括号](#1-给表达式加括号)
-* [2. 不同的二叉搜索树](#2-不同的二叉搜索树)
-<!-- GFM-TOC -->
-
-
-# 1. 给表达式加括号
-
-[241. Different Ways to Add Parentheses (Medium)](https://leetcode.com/problems/different-ways-to-add-parentheses/description/)
-
-```html
-Input: "2-1-1".
-
-((2-1)-1) = 0
-(2-(1-1)) = 2
-
-Output : [0, 2]
-```
-
-```java
-public List<Integer> diffWaysToCompute(String input) {
-    List<Integer> ways = new ArrayList<>();
-    for (int i = 0; i < input.length(); i++) {
-        char c = input.charAt(i);
-        if (c == '+' || c == '-' || c == '*') {
-            List<Integer> left = diffWaysToCompute(input.substring(0, i));
-            List<Integer> right = diffWaysToCompute(input.substring(i + 1));
-            for (int l : left) {
-                for (int r : right) {
-                    switch (c) {
-                        case '+':
-                            ways.add(l + r);
-                            break;
-                        case '-':
-                            ways.add(l - r);
-                            break;
-                        case '*':
-                            ways.add(l * r);
-                            break;
-                    }
-                }
-            }
-        }
-    }
-    if (ways.size() == 0) {
-        ways.add(Integer.valueOf(input));
-    }
-    return ways;
-}
-```
-
-# 2. 不同的二叉搜索树
-
-[95. Unique Binary Search Trees II (Medium)](https://leetcode.com/problems/unique-binary-search-trees-ii/description/)
-
-给定一个数字 n，要求生成所有值为 1...n 的二叉搜索树。
-
-```html
-Input: 3
-Output:
-[
-  [1,null,3,2],
-  [3,2,null,1],
-  [3,1,null,null,2],
-  [2,1,3],
-  [1,null,2,null,3]
-]
-Explanation:
-The above output corresponds to the 5 unique BST's shown below:
-
-   1         3     3      2      1
-    \       /     /      / \      \
-     3     2     1      1   3      2
-    /     /       \                 \
-   2     1         2                 3
-```
-
-```java
-public List<TreeNode> generateTrees(int n) {
-    return generateSubtrees(1, n);
-}
-
-private List<TreeNode> generateSubtrees(int s, int e) {
-    List<TreeNode> res = new LinkedList<TreeNode>();
-    if (s > e) {
-        res.add(null);
-        return res;
-    }
-    for (int i = s; i <= e; ++i) {
-        List<TreeNode> leftSubtrees = generateSubtrees(s, i - 1);
-        List<TreeNode> rightSubtrees = generateSubtrees(i + 1, e);
-        for (TreeNode left : leftSubtrees) {
-            for (TreeNode right : rightSubtrees) {
-                TreeNode root = new TreeNode(i);
-                root.left = left;
-                root.right = right;
-                res.add(root);
-            }
-        }
-    }
-    return res;
-}
-```
-
-
-
-
-</br><div align="center">🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。</div></br>
-<div align="center"><img width="180px" src="https://cyc-1256109796.cos.ap-guangzhou.myqcloud.com/%E5%85%AC%E4%BC%97%E5%8F%B7.jpg"></img></div>
@@ -1,129 +0,0 @@
-<!-- GFM-TOC -->
-* [1. 数组中两个数的和为给定值](#1-数组中两个数的和为给定值)
-* [2. 判断数组是否含有重复元素](#2-判断数组是否含有重复元素)
-* [3. 最长和谐序列](#3-最长和谐序列)
-* [4. 最长连续序列](#4-最长连续序列)
-<!-- GFM-TOC -->
-
-
-哈希表使用 O(N) 空间复杂度存储数据，并且以 O(1) 时间复杂度求解问题。
-
- Java 中的  **HashSet**  用于存储一个集合，可以查找元素是否在集合中。如果元素有穷，并且范围不大，那么可以用一个布尔数组来存储一个元素是否存在。例如对于只有小写字符的元素，就可以用一个长度为 26 的布尔数组来存储一个字符集合，使得空间复杂度降低为 O(1)。
-
- Java 中的  **HashMap**  主要用于映射关系，从而把两个元素联系起来。HashMap 也可以用来对元素进行计数统计，此时键为元素，值为计数。和 HashSet 类似，如果元素有穷并且范围不大，可以用整型数组来进行统计。在对一个内容进行压缩或者其它转换时，利用 HashMap 可以把原始内容和转换后的内容联系起来。例如在一个简化 url 的系统中 [Leetcdoe : 535. Encode and Decode TinyURL (Medium)](https://leetcode.com/problems/encode-and-decode-tinyurl/description/)，利用 HashMap 就可以存储精简后的 url 到原始 url 的映射，使得不仅可以显示简化的 url，也可以根据简化的 url 得到原始 url 从而定位到正确的资源。
-
-
-# 1. 数组中两个数的和为给定值
-
-[1. Two Sum (Easy)](https://leetcode.com/problems/two-sum/description/)
-
-可以先对数组进行排序，然后使用双指针方法或者二分查找方法。这样做的时间复杂度为 O(NlogN)，空间复杂度为 O(1)。
-
-用 HashMap 存储数组元素和索引的映射，在访问到 nums[i] 时，判断 HashMap 中是否存在 target - nums[i]，如果存在说明 target - nums[i] 所在的索引和 i 就是要找的两个数。该方法的时间复杂度为 O(N)，空间复杂度为 O(N)，使用空间来换取时间。
-
-```java
-public int[] twoSum(int[] nums, int target) {
-    HashMap<Integer, Integer> indexForNum = new HashMap<>();
-    for (int i = 0; i < nums.length; i++) {
-        if (indexForNum.containsKey(target - nums[i])) {
-            return new int[]{indexForNum.get(target - nums[i]), i};
-        } else {
-            indexForNum.put(nums[i], i);
-        }
-    }
-    return null;
-}
-```
-
-# 2. 判断数组是否含有重复元素
-
-[217. Contains Duplicate (Easy)](https://leetcode.com/problems/contains-duplicate/description/)
-
-```java
-public boolean containsDuplicate(int[] nums) {
-    Set<Integer> set = new HashSet<>();
-    for (int num : nums) {
-        set.add(num);
-    }
-    return set.size() < nums.length;
-}
-```
-
-# 3. 最长和谐序列
-
-[594. Longest Harmonious Subsequence (Easy)](https://leetcode.com/problems/longest-harmonious-subsequence/description/)
-
-```html
-Input: [1,3,2,2,5,2,3,7]
-Output: 5
-Explanation: The longest harmonious subsequence is [3,2,2,2,3].
-```
-
-和谐序列中最大数和最小数之差正好为 1，应该注意的是序列的元素不一定是数组的连续元素。
-
-```java
-public int findLHS(int[] nums) {
-    Map<Integer, Integer> countForNum = new HashMap<>();
-    for (int num : nums) {
-        countForNum.put(num, countForNum.getOrDefault(num, 0) + 1);
-    }
-    int longest = 0;
-    for (int num : countForNum.keySet()) {
-        if (countForNum.containsKey(num + 1)) {
-            longest = Math.max(longest, countForNum.get(num + 1) + countForNum.get(num));
-        }
-    }
-    return longest;
-}
-```
-
-# 4. 最长连续序列
-
-[128. Longest Consecutive Sequence (Hard)](https://leetcode.com/problems/longest-consecutive-sequence/description/)
-
-```html
-Given [100, 4, 200, 1, 3, 2],
-The longest consecutive elements sequence is [1, 2, 3, 4]. Return its length: 4.
-```
-
-要求以 O(N) 的时间复杂度求解。
-
-```java
-public int longestConsecutive(int[] nums) {
-    Map<Integer, Integer> countForNum = new HashMap<>();
-    for (int num : nums) {
-        countForNum.put(num, 1);
-    }
-    for (int num : nums) {
-        forward(countForNum, num);
-    }
-    return maxCount(countForNum);
-}
-
-private int forward(Map<Integer, Integer> countForNum, int num) {
-    if (!countForNum.containsKey(num)) {
-        return 0;
-    }
-    int cnt = countForNum.get(num);
-    if (cnt > 1) {
-        return cnt;
-    }
-    cnt = forward(countForNum, num + 1) + 1;
-    countForNum.put(num, cnt);
-    return cnt;
-}
-
-private int maxCount(Map<Integer, Integer> countForNum) {
-    int max = 0;
-    for (int num : countForNum.keySet()) {
-        max = Math.max(max, countForNum.get(num));
-    }
-    return max;
-}
-```
-
-
-
-
-</br><div align="center">🎨️欢迎关注我的公众号 CyC2018，在公众号后台回复关键字 **资料** 可领取复习大纲，这份大纲是我花了一整年时间整理的面试知识点列表，不仅系统整理了面试知识点，而且标注了各个知识点的重要程度，从而帮你理清多而杂的面试知识点。可以说我基本是按照这份大纲来进行复习的，这份大纲对我拿到了 BAT 头条等 Offer 起到很大的帮助。你们完全可以和我一样根据大纲上列的知识点来进行复习，就不用看很多不重要的内容，也可以知道哪些内容很重要从而多安排一些复习时间。</div></br>
-<div align="center"><img width="180px" src="https://cyc-1256109796.cos.ap-guangzhou.myqcloud.com/%E5%85%AC%E4%BC%97%E5%8F%B7.jpg"></img></div>
--- a/Show More
+++ b/Show More