Update 01.md

Author: x1aoda1

docs/01.md

@@ -1,22 +1,23 @@
 
 - [1 时间复杂度、空间复杂度、排序、异或运算](#1)
-  * [1.1 时间复杂度](#11------)
-    + [1.1.1 排序操作](#111-----)
-      - [1.1.1.1 选择排序](#1111-----)
-      - [1.1.1.2 冒泡排序](#1112-----)
-      - [1.1.1.3 插入排序](#1113-----)
-  * [1.2 空间复杂度](#12------)
-  * [1.3 常数项时间复杂度](#13---------)
-  * [1.4 算法最优解](#14------)
-  * [1.5 常见时间复杂度](#15--------)
-  * [1.6 算法和数据结构脉络](#16----------)
-  * [1.7 认识对数器](#17------)
-  * [1.8 认识二分法](#18------)
-  * [1.9 认识异或运算](#19-------)
-
-<h1 id='1'>1 时间复杂度、空间复杂度、排序、异或运算</h2>
-
-##  1.1 时间复杂度
+  * [1.1 时间复杂度](#11)
+    + [1.1.1 排序操作](#111)
+      - [1.1.1.1 选择排序](#1111)
+      - [1.1.1.2 冒泡排序](#1112)
+      - [1.1.1.3 插入排序](#1113)
+  * [1.2 空间复杂度](#12)
+  * [1.3 常数项时间复杂度](#13)
+  * [1.4 算法最优解](#14)
+  * [1.5 常见时间复杂度](#15)
+  * [1.6 算法和数据结构脉络](#16)
+  * [1.7 认识对数器](#17)
+  * [1.8 认识二分法](#18)
+  * [1.9 认识异或运算](#19)
+
+<h1 id='1'>1 时间复杂度、空间复杂度、排序、异或运算</h1>
+
+<h2 id='11'>1.1 时间复杂度</h2>
+ 
 - 常数时间操作：
 1. 算数运算：+ - * /
 2. 位运算：>>（带符号右移动）、 >>>（不带符号右移动） 、 <<、 | 、& 、^ 
@@ -38,9 +39,10 @@ y = an^2 + bn + c
 
 ==忽略掉低阶项，忽略掉常数项，忽略掉高阶项的系数，得到时间复杂度为n^2==
 
-### 1.1.1 排序操作
+<h3 id='111'>1.1.1 排序操作</h3>
+
+<h4 id='1111'>1.1.1.1 选择排序</h4>
 
-#### 1.1.1.1 选择排序
 ```Java
 package class01;
 
@@ -159,7 +161,8 @@ public class Code01_SelectionSort {
 
 }
 ```
-#### 1.1.1.2 冒泡排序
+<h4 id='1112'>1.1.1.2 冒泡排序</h4>
+
 ```Java
 package class01;
 
@@ -272,7 +275,8 @@ public class Code02_BubbleSort {
 
 }
 ```
-#### 1.1.1.3 插入排序
+<h4 id='1113'>1.1.1.3 插入排序</h4>
+
 ```Java
 package class01;
 
@@ -392,28 +396,28 @@ public class Code03_InsertionSort {
 
 ==插入排序和前面两种排序的不同是在于，插入排序跟数组初始顺序有关，在初始有序的情况下，有可能时间复杂度为O(N),有可能为O(N ^2)，但是我们估计时间复杂度要按照最差的情况来估计，所以插入排序的时间复杂度仍然O(N ^2)==
 
-## 1.2 空间复杂度
+<h2 id='12'>1.2 空间复杂度</h2>
 
 申请有限几个变量，和样本量n没关系，就是空间复杂度O(1)，如果要开辟一个空间数组和样本量n是一样大，用来支持我们的算法流程那么O(N)。反之用户就是要实现数组拷贝，我们开辟一个新的n大小数组用来支撑用户的需求，那么仍然是O(1)
 
-
-## 1.3 常数项时间复杂度
+<h2 id='13'>1.3 常数项时间复杂度</h2>
 
 如果两个相同时间复杂度的算法要比较性能，这个时候需要比较单个常数项时间，对能力要求较高，没有意义，不如样本量试验实际测试来比较
 
-## 1.4 算法最优解
+<h2 id='14'>1.4 算法最优解</h2> 
 
 我们认为最优解的考虑顺序是，先满足时间复杂度指标，再去使用较少的空间。一般来说，算法题，ACM等不会卡常数项时间
 
-## 1.5 常见时间复杂度
+<h2 id='15'>1.5 常见时间复杂度</h2> 
+
 > 依次从好到坏 O(1) -> O(logN) -> O(N) -> O(N*logN) -> O(N^2) -> O(N^3) ... -> O(N!)
 
-## 1.6 算法和数据结构脉络
+<h2 id='16'>1.6 算法和数据结构脉络</h2> 
 
 1. 知道怎么算的算法
 2. 知道怎么试的算法(递归)
 
-## 1.7 认识对数器
+<h2 id='17'>1.7 认识对数器</h2> 
 
 1. 准备你想要测试的方法a
 2. 实现一个复杂度不好，但是容易实现的方法b
@@ -422,7 +426,7 @@ public class Code03_InsertionSort {
 5. 如果有一个随机样本使得对比结果不一致，打印样本进行人工干预，改对方法a和方法b
 6. 当样本数量很多，测试对比依然正确，可以确定方法a已经正确
 
-## 1.8 认识二分法
+<h2 id='18'>1.8 认识二分法</h2> 
 
 1. 在一个有序数组中，找某个数是否存在
 
@@ -703,8 +707,7 @@ public class Code06_BSAwesome {
 
 }
 ```
-
-## 1.9 认识异或运算
+<h2 id='19'>1.9 认识异或运算</h2>
 
 异或运算：相同为0，不同为1