update

Author: longshilin

Diff for: README.md

@@ -78,9 +78,9 @@ CBTType root = null;			// 定义二叉树根结点引用
 
 # 排序算法总结 :elephant:
 
-![](https://i.imgur.com/1OW23bg.png)
+![](https://i.imgur.com/UsDuUM6.png)
 
-[点击详见](./src/sortingAlgorithm/README.md)
+[点击详见](./src/sortingAlgorithm/#top)
 # 数据结构与算法 面试题(Java版) :sparkles:
 
 - [单例模式的六种实现](./src/review02#top)

Diff for: src/sortingAlgorithm/README.md

@@ -1,7 +1,7 @@
 # <a id="top"></a>排序算法 ✈
 排序算法的分类
 
-![](https://i.imgur.com/1OW23bg.png)
+![](https://i.imgur.com/UsDuUM6.png)
 
 ## 冒泡排序
 冒泡排序算法通过多次比较和交换来实现排序，其排序流程如下：
@@ -29,6 +29,7 @@ public void bubbleSort(int[] a,int n){
 }
 ```
 完整示例代码：[bubble.java](./bubble.java)
+
 ## 快速排序
 快速排序算法通过多次比较和交换来实现排序，其排序流程如下：
 1. 首先设定一个分界值，通过该分界值来将数组分成两部分。
@@ -64,10 +65,10 @@ public void quickSort(int[] a, int left, int right){		// 快速排序算法
 		ltemp++;
 	}
 	if(left<rtemp){
-		quickSort(a, left, ltemp-1);		// 递归调用
+		quickSort(a, left, ltemp-1);		// 左递归调用
 	}
 	if(ltemp<right){
-		quickSort(a, rtemp+1, right);		// 递归调用
+		quickSort(a, rtemp+1, right);		// 右递归调用
 	}
 }
 ```
@@ -102,7 +103,7 @@ public void bubbleSort(int[] a,int n){
 完整示例代码：[select.java](./select.java)
 ## 堆排序
 堆排序（Heap Sort）算法是基于选择排序思想的算法，其利用堆结构和二叉树的一些性质来完成数据的排序。堆结构是一种树结构，准确的说是一个完全二叉树。在这个树中每个结点对应于原始数据的一个记录，并且每个结点应满足以下条件：
-- 如果按照从小到打的顺序排序，要求非叶结点的数据要大于或等于其左、右子结点的数据。
+- 如果按照从小到大的顺序排序，要求非叶结点的数据要大于或等于其左、右子结点的数据。
 - 如果按照从大到小的顺序排列，要求非叶结点的数据要小于或等于其左、右子结点的数据。
 
 #### 堆排序过程
@@ -129,7 +130,7 @@ public void bubbleSort(int[] a,int n){
 			a[j+1]=a[j];
 			j--;
 		}
-		a[j+1]=t;
+		a[j+1]=t;		// 将腾出来的那个位置插入新元素
 	}
 }
 ```
@@ -181,7 +182,7 @@ public void bubbleSort(int[] a,int n){
 				a[j+r]=a[j];
 				j-=r;
 			}
-			a[j+r]=t;
+			a[j+r]=t;	// 将腾出来的那个位置插入新元素
 		}
 	}
 }
@@ -194,3 +195,11 @@ public void bubbleSort(int[] a,int n){
 
 一个待排序的原始数据序列进行合并排序的基本思路是，首先将含有n个结点的待排序数据序列看作由n个长度为1的有序子表组成，将其依次两两合并，得到长度为4的若干有序子表······，重复上述过程，一直到最后的子表长度为n，从而完成排序过程。
 
+# 算法时间复杂度分析
+- 冒泡排序算法：冒泡排序中，存在二层循环遍历，所以平均时间复杂度为O(n²)，最坏情况下的时间复杂度为O(n²)；
+- 快速排序算法：快序中，while循环部分时间复杂度为O(logn),左递归和右递归总和的时间复杂度为O(n),所以总的平均时间复杂度为O(n²)；
+- 选择排序算法：选择排序中，依次从数组中选取最小的，次小的，... 从而得到整个序列。两层循环遍历，所以时间复杂度为O(n²)，最坏情况下的时间复杂度为O(n²)；
+- 堆排序算法：从堆中，一次堆排序挑选最小(或最大)元素的时间复杂度为O(logn)，一共要进行n次堆排序得到有序队列，所以平均时间复杂度为O(nlogn)，最坏情况下的时间复杂度为O(nlogn)；
+- 插入排序算法：插入排序中，两层循环，第一层遍历n个元素，第二层遍历在已排序队列中逐一向前比较，找到合适的位置插入，所以平均时间复杂度为O(n²)，最坏情况下的时间复杂度为O(n²)；
+- 折半插入排序算法：在插入排序的基础上进行优化，在第二层遍历在已排序队列中通过二分查找的方式，找到合适的位置插入，所以平均时间复杂度为O(n²)，最坏情况下的时间复杂度为O(n²)；
+- 合并排序算法：均时间复杂度为O(nlogn)，最坏情况下的时间复杂度为O(n²)；：

Diff for: src/sortingAlgorithm/insert.java

@@ -30,12 +30,12 @@ public void bubbleSort(int[] a,int n){
 		for(i=1; i<n; i++){
 			t=a[i];
 			j=i-1;
-			while(j>=0 && t<a[j]){	// 后移每个比t大的元素
+			while(j>=0 && t<a[j]){		// 后移每个比t大的元素
 				a[j+1]=a[j];
 				j--;
 				ex++;
 			}
-			a[j+1]=t;
+			a[j+1]=t;		// 将腾出来的那个位置插入新元素
 			count++;
 			System.out.print("第"+count+"趟排序结果：");
 			for (int k = 0; k < a.length; k++) {