update

.gitignore

@@ -13,4 +13,9 @@ _book
 # eBook build output
 *.epub
 *.mobi
-*.pdf
+*.pdf
+\.idea/
+
+*.iml
+
+src/javaSortTest/target/

1.bubbleSort.md

@@ -36,7 +36,7 @@
 ```js
 function bubbleSort(arr) {
     var len = arr.length;
-    for (var i = 0; i < len; i++) {
+    for (var i = 0; i < len - 1; i++) {
         for (var j = 0; j < len - 1 - i; j++) {
             if (arr[j] > arr[j+1]) {        // 相邻元素两两对比
                 var temp = arr[j+1];        // 元素交换
@@ -61,3 +61,71 @@ def bubbleSort(arr):
                 arr[j], arr[j + 1] = arr[j + 1], arr[j]
     return arr
 ```
+
+## 7. Go 代码实现
+
+```go
+func bubbleSort(arr []int) []int {
+	length := len(arr)
+	for i := 0; i < length; i++ {
+		for j := 0; j < length-1-i; j++ {
+			if arr[j] > arr[j+1] {
+				arr[j], arr[j+1] = arr[j+1], arr[j]
+			}
+		}
+	}
+	return arr
+}
+```
+
+## 8. Java 代码实现
+
+```java
+public class BubbleSort implements IArraySort {
+
+    @Override
+    public int[] sort(int[] sourceArray) throws Exception {
+        // 对 arr 进行拷贝，不改变参数内容
+        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
+
+        for (int i = 1; i < arr.length; i++) {
+            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
+            boolean flag = true;
+
+            for (int j = 0; j < arr.length - i; j++) {
+                if (arr[j] > arr[j + 1]) {
+                    int tmp = arr[j];
+                    arr[j] = arr[j + 1];
+                    arr[j + 1] = tmp;
+
+                    flag = false;
+                }
+            }
+
+            if (flag) {
+                break;
+            }
+        }
+        return arr;
+    }
+}
+```
+
+## 9. PHP 代码实现
+
+```php
+function bubbleSort($arr)
+{
+    $len = count($arr);
+    for ($i = 0; $i < $len - 1; $i++) {
+        for ($j = 0; $j < $len - 1 - $i; $j++) {
+            if ($arr[$j] > $arr[$j+1]) {
+                $tmp = $arr[$j];
+                $arr[$j] = $arr[$j+1];
+                $arr[$j+1] = $tmp;
+            }
+        }
+    }
+    return $arr;
+}
+```

10.radixSort.md

@@ -47,4 +47,126 @@ function radixSort(arr, maxDigit) {
     }
     return arr;
 }
+```
+
+## 4. Java 代码实现
+
+```java
+/**
+ * 基数排序
+ * 考虑负数的情况还可以参考： https://code.i-harness.com/zh-CN/q/e98fa9
+ */
+public class RadixSort implements IArraySort {
+
+    @Override
+    public int[] sort(int[] sourceArray) throws Exception {
+        // 对 arr 进行拷贝，不改变参数内容
+        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
+
+        int maxDigit = getMaxDigit(arr);
+        return radixSort(arr, maxDigit);
+    }
+
+    /**
+     * 获取最高位数
+     */
+    private int getMaxDigit(int[] arr) {
+        int maxValue = getMaxValue(arr);
+        return getNumLenght(maxValue);
+    }
+
+    private int getMaxValue(int[] arr) {
+        int maxValue = arr[0];
+        for (int value : arr) {
+            if (maxValue < value) {
+                maxValue = value;
+            }
+        }
+        return maxValue;
+    }
+
+    protected int getNumLenght(long num) {
+        if (num == 0) {
+            return 1;
+        }
+        int lenght = 0;
+        for (long temp = num; temp != 0; temp /= 10) {
+            lenght++;
+        }
+        return lenght;
+    }
+
+    private int[] radixSort(int[] arr, int maxDigit) {
+        int mod = 10;
+        int dev = 1;
+
+        for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
+            // 考虑负数的情况，这里扩展一倍队列数，其中 [0-9]对应负数，[10-19]对应正数 (bucket + 10)
+            int[][] counter = new int[mod * 2][0];
+
+            for (int j = 0; j < arr.length; j++) {
+                int bucket = ((arr[j] % mod) / dev) + mod;
+                counter[bucket] = arrayAppend(counter[bucket], arr[j]);
+            }
+
+            int pos = 0;
+            for (int[] bucket : counter) {
+                for (int value : bucket) {
+                    arr[pos++] = value;
+                }
+            }
+        }
+
+        return arr;
+    }
+
+    /**
+     * 自动扩容，并保存数据
+     *
+     * @param arr
+     * @param value
+     */
+    private int[] arrayAppend(int[] arr, int value) {
+        arr = Arrays.copyOf(arr, arr.length + 1);
+        arr[arr.length - 1] = value;
+        return arr;
+    }
+}
+```
+
+## 5. PHP 代码实现
+
+```php
+function radixSort($arr, $maxDigit = null)
+{
+    if ($maxDigit === null) {
+        $maxDigit = max($arr);
+    }
+    $counter = [];
+    for ($i = 0; $i < $maxDigit; $i++) {
+        for ($j = 0; $j < count($arr); $j++) {
+            preg_match_all('/\d/', (string) $arr[$j], $matches);
+            $numArr = $matches[0];
+            $lenTmp = count($numArr);
+            $bucket = array_key_exists($lenTmp - $i - 1, $numArr)
+                ? intval($numArr[$lenTmp - $i - 1])
+                : 0;
+            if (!array_key_exists($bucket, $counter)) {
+                $counter[$bucket] = [];
+            }
+            $counter[$bucket][] = $arr[$j];
+        }
+        $pos = 0;
+        for ($j = 0; $j < count($counter); $j++) {
+            $value = null;
+            if ($counter[$j] !== null) {
+                while (($value = array_shift($counter[$j])) !== null) {
+                    $arr[$pos++] = $value;
+                }
+          }
+        }
+    }
+
+    return $arr;
+}
 ```

2.selectionSort.md

@@ -1,6 +1,6 @@
 # 选择排序
 
-选择排序是一种简单直观的排序算法，是表现最稳定的排序算法之一，因为无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
+选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
 
 
 ## 1. 算法步骤
@@ -42,9 +42,87 @@ function selectionSort(arr) {
 
 ```python
 def selectionSort(arr):
-    for i in range(len(arr)-1):
-        for j in range(i+1, len(arr)):
-            if arr[j] < arr[i]:
-                arr[i], arr[j] = arr[j], arr[i]
+    for i in range(len(arr) - 1):
+        # 记录最小数的索引
+        minIndex = i
+        for j in range(i + 1, len(arr)):
+            if arr[j] < arr[minIndex]:
+                minIndex = j
+        # i 不是最小数时，将 i 和最小数进行交换
+        if i != minIndex:
+            arr[i], arr[minIndex] = arr[minIndex], arr[i]
     return arr
 ```
+
+## 5. Go 代码实现
+
+```go
+func selectionSort(arr []int) []int {
+	length := len(arr)
+	for i := 0; i < length-1; i++ {
+		min := i
+		for j := i + 1; j < length; j++ {
+			if arr[min] > arr[j] {
+				min = j
+			}
+		}
+		arr[i], arr[min] = arr[min], arr[i]
+	}
+	return arr
+}
+```
+
+## 6. Java 代码实现
+
+```java
+public class SelectionSort implements IArraySort {
+
+    @Override
+    public int[] sort(int[] sourceArray) throws Exception {
+        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
+
+        // 总共要经过 N-1 轮比较
+        for (int i = 0; i < arr.length - 1; i++) {
+            int min = i;
+
+            // 每轮需要比较的次数 N-i
+            for (int j = i + 1; j < arr.length; j++) {
+                if (arr[j] < arr[min]) {
+                    // 记录目前能找到的最小值元素的下标
+                    min = j;
+                }
+            }
+
+            // 将找到的最小值和i位置所在的值进行交换
+            if (i != min) {
+                int tmp = arr[i];
+                arr[i] = arr[min];
+                arr[min] = tmp;
+            }
+
+        }
+        return arr;
+    }
+}
+```
+
+## 7. PHP 代码实现
+
+```php
+function selectionSort($arr)
+{
+    $len = count($arr);
+    for ($i = 0; $i < $len - 1; $i++) {
+        $minIndex = $i;
+        for ($j = $i + 1; $j < $len; $j++) {
+            if ($arr[$j] < $arr[$minIndex]) {
+                $minIndex = $j;
+            }
+        }
+        $temp = $arr[$i];
+        $arr[$i] = $arr[$minIndex];
+        $arr[$minIndex] = $temp;
+    }
+    return $arr;
+}
+```

3.insertionSort.md

@@ -49,3 +49,72 @@ def insertionSort(arr):
         arr[preIndex+1] = current
     return arr
 ```
+
+## 5. Go 代码实现
+```go
+func insertionSort(arr []int) []int {
+	for i := range arr {
+		preIndex := i - 1
+		current := arr[i]
+		for preIndex >= 0 && arr[preIndex] > current {
+			arr[preIndex+1] = arr[preIndex]
+			preIndex -= 1
+		}
+		arr[preIndex+1] = current
+	}
+	return arr
+}
+```
+
+## 6. Java 代码实现
+
+```java
+public class InsertSort implements IArraySort {
+
+    @Override
+    public int[] sort(int[] sourceArray) throws Exception {
+        // 对 arr 进行拷贝，不改变参数内容
+        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
+
+        // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
+        for (int i = 1; i < arr.length; i++) {
+
+            // 记录要插入的数据
+            int tmp = arr[i];
+
+            // 从已经排序的序列最右边的开始比较，找到比其小的数
+            int j = i;
+            while (j > 0 && tmp < arr[j - 1]) {
+                arr[j] = arr[j - 1];
+                j--;
+            }
+
+            // 存在比其小的数，插入
+            if (j != i) {
+                arr[j] = tmp;
+            }
+
+        }
+        return arr;
+    }
+}
+```
+
+## 7. PHP 代码实现
+
+```php
+function insertionSort($arr)
+{
+    $len = count($arr);
+    for ($i = 1; $i < $len; $i++) {
+        $preIndex = $i - 1;
+        $current = $arr[$i];
+        while($preIndex >= 0 && $arr[$preIndex] > $current) {
+            $arr[$preIndex+1] = $arr[$preIndex];
+            $preIndex--;
+        }
+        $arr[$preIndex+1] = $current;
+    }
+    return $arr;
+}
+```