auto commit

docs/notes/算法 - 排序.md

@@ -31,10 +31,10 @@
 
 待排序的元素需要实现 Java 的 Comparable 接口，该接口有 compareTo() 方法，可以用它来判断两个元素的大小关系。
 
-研究排序算法的成本模型时，统计的是比较和交换的次数。
-
 使用辅助函数 less() 和 swap() 来进行比较和交换的操作，使得代码的可读性和可移植性更好。
 
+排序算法的成本模型是比较和交换的次数。
+
 ```java
 public abstract class Sort<T extends Comparable<T>> {
 
@@ -54,7 +54,7 @@ public abstract class Sort<T extends Comparable<T>> {
 
 # 选择排序
 
-选择出数组中的最小元素，将它与数组的第一个元素交换位置。再从剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
+从数组中选择最小元素，将它与数组的第一个元素交换位置。再从数组剩下的元素中选择出最小的元素，将它与数组的第二个元素交换位置。不断进行这样的操作，直到将整个数组排序。
 
 选择排序需要 \~N<sup>2</sup>/2 次比较和 \~N 次交换，它的运行时间与输入无关，这个特点使得它对一个已经排序的数组也需要这么多的比较和交换操作。
 
@@ -83,7 +83,7 @@ public class Selection<T extends Comparable<T>> extends Sort<T> {
 
 从左到右不断交换相邻逆序的元素，在一轮的循环之后，可以让未排序的最大元素上浮到右侧。
 
-在一轮循环中，如果没有发生交换，就说明数组已经是有序的，此时可以直接退出。
+在一轮循环中，如果没有发生交换，那么说明数组已经是有序的，此时可以直接退出。
 
 <div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/31550398353573.gif"/> </div><br>
 
@@ -93,12 +93,12 @@ public class Bubble<T extends Comparable<T>> extends Sort<T> {
     @Override
     public void sort(T[] nums) {
         int N = nums.length;
-        boolean hasSorted = false;
-        for (int i = N - 1; i > 0 && !hasSorted; i--) {
+        boolean isSorted = false;
+        for (int i = N - 1; i > 0 && !isSorted; i--) {
             hasSorted = true;
             for (int j = 0; j < i; j++) {
                 if (less(nums[j + 1], nums[j])) {
-                    hasSorted = false;
+                    isSorted = false;
                     swap(nums, j, j + 1);
                 }
             }
@@ -113,14 +113,12 @@ public class Bubble<T extends Comparable<T>> extends Sort<T> {
 
 对于数组 {3, 5, 2, 4, 1}，它具有以下逆序：(3, 2), (3, 1), (5, 2), (5, 4), (5, 1), (2, 1), (4, 1)，插入排序每次只能交换相邻元素，令逆序数量减少 1，因此插入排序需要交换的次数为逆序数量。
 
-插入排序的复杂度取决于数组的初始顺序，如果数组已经部分有序了，逆序较少，那么插入排序会很快。
+插入排序的时间复杂度取决于数组的初始顺序，如果数组已经部分有序了，那么逆序较少，需要的交换次数也就较少，时间复杂度较低。
 
 - 平均情况下插入排序需要 \~N<sup>2</sup>/4 比较以及 \~N<sup>2</sup>/4 次交换；
 - 最坏的情况下需要 \~N<sup>2</sup>/2 比较以及 \~N<sup>2</sup>/2 次交换，最坏的情况是数组是倒序的；
 - 最好的情况下需要 N-1 次比较和 0 次交换，最好的情况就是数组已经有序了。
 
-以下演示了在一轮循环中，将元素 2 插入到左侧已经排序的数组中。
-
 <div align="center"> <img src="https://gitee.com/CyC2018/CS-Notes/raw/master/docs/pics/51550399426594.gif"/> </div><br>
 
 ```java