♻️ 重构算法为泛型算法

Author: dunwu

codes/pom.xml

@@ -59,7 +59,7 @@
   <!-- [Part 3] PROJECT INFO BEGIN -->
   <name>${artifactId}</name>
   <description>算法+数据结构学习笔记</description>
-  <url>https://github.com/dunwu/algorithms-notes</url>
+  <url>https://github.com/dunwu/algorithms</url>
   <inceptionYear>2016-2017</inceptionYear>
   <licenses>
     <license>
@@ -82,12 +82,12 @@
   <!-- [Part 4] ENVIRONMENT SETTINGS BEGIN -->
   <issueManagement>
     <system>Github</system>
-    <url>https://github.com/dunwu/algorithms-notes/issues</url>
+    <url>https://github.com/dunwu/algorithms/issues</url>
   </issueManagement>
   <scm>
-    <url>https://github.com/dunwu/algorithms-notes</url>
-    <connection>scm:git:git://github.com/dunwu/algorithms-notes.git</connection>
-    <developerConnection>scm:git:ssh://git@github.com:dunwu/algorithms-notes.git</developerConnection>
+    <url>https://github.com/dunwu/algorithms</url>
+    <connection>scm:git:git://github.com/dunwu/algorithms.git</connection>
+    <developerConnection>scm:git:ssh://git@github.com:dunwu/algorithms.git</developerConnection>
   </scm>
   <!-- [Part 4] ENVIRONMENT SETTINGS END -->
 

codes/src/main/java/io/github/dunwu/algorithm/search/Search.java

@@ -5,8 +5,9 @@
  */
 public interface Search {
     /**
-     * 排序接口
-     * @param list 数组
+     * @param array 要查找的数组
+     * @param key 要查找的 key
+     * @return 返回第一个匹配 key 值的数组元素所在位置
      */
-    int search(int[] list, int key);
+    <T extends Comparable<T>> int find(T array[], T key);
 }

codes/src/main/java/io/github/dunwu/algorithm/search/SearchStrategy.java

@@ -17,11 +17,12 @@ public SearchStrategy(Search search) {
         this.search = search;
     }
 
-    public int search(int[] list, int key) {
+    public int find(Integer[] list, int key) {
         logger.info(this.search.getClass().getSimpleName() + " 查找开始：");
         logger.info("要查找的线性表：{}", ArrayUtil.getArrayString(list, 0, list.length - 1));
         logger.info("要查找的 key：{}", key);
-        int index = this.search.search(list, key);
+
+        int index = this.search.find(list, key);
         logger.info("{} 的位置是：{}", key, index);
         return index;
     }

codes/src/main/java/io/github/dunwu/algorithm/search/strategy/BinarySearch.java

@@ -3,24 +3,50 @@
 import io.github.dunwu.algorithm.search.Search;
 
 /**
+ * 二分查找又称折半查找，它是一种效率较高的查找方法。
+ * 二分查找需要两个前提：(1) 必须是顺序存储结构。(2) 必须是有序的表。
+ * 算法：
+ * 从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；
+ * 若扫描结束仍没有找到等于关键字的结点，表示查找失败。
+ * 算法分析：
+ * 最坏情况	O(log n)
+ * 最好情况	O(1)
+ * 平均情况	O(log n)
+ * 最坏情况下的空间复杂性 O(1)
+ *
  * @author Zhang Peng
- * @date 2018/4/18
  */
 public class BinarySearch implements Search {
 
+    /**
+     * 查找方法
+     *
+     * @param array 被查找的线性表
+     * @param key 被查找的 key
+     * @return 成功返回 key 的位置；失败返回 -1
+     */
     @Override
-    public int search(int[] list, int key) {
-        int low = 0, mid = 0, high = list.length - 1;
-        while (low <= high) {
-            mid = (low + high) / 2;
-            if (list[mid] == key) {
-                return mid; // 查找成功，直接返回位置
-            } else if (list[mid] < key) {
-                low = mid + 1; // 关键字大于中间位置的值，则在大值区间[mid+1, high]继续查找
-            } else {
-                high = mid - 1; // 关键字小于中间位置的值，则在小值区间[low, mid-1]继续查找
-            }
+    public <T extends Comparable<T>> int find(T array[], T key) {
+        return search(array, key, 0, array.length);
+    }
+
+    private <T extends Comparable<T>> int search(T array[], T key, int left, int right) {
+        // this means that the key not found
+        if (right < left) {
+            return -1;
+        }
+
+        int mid = (left + right) >>> 1;
+        int comp = key.compareTo(array[mid]);
+
+        if (comp < 0) {
+            return search(array, key, left, mid - 1);
+        }
+
+        if (comp > 0) {
+            return search(array, key, mid + 1, right);
         }
-        return -1;
+
+        return mid;
     }
 }

codes/src/main/java/io/github/dunwu/algorithm/search/strategy/OrderSearch.java

@@ -3,21 +3,34 @@
 import io.github.dunwu.algorithm.search.Search;
 
 /**
+ * 顺序查找是一种最简单的查找算法。它的查找效率不高。
+ * 算法：
+ * 从数据结构线形表的一端开始，顺序扫描，依次将扫描到的结点关键字与给定值k相比较，若相等则表示查找成功；
+ * 若扫描结束仍没有找到关键字等于k的结点，表示查找失败。
+ * 算法分析：
+ * 最坏情况	O(n)
+ * 最好情况	O(1)
+ * 平均情况	O(n)
+ * 最坏情况下的空间复杂性
+ *
  * @author Zhang Peng
- * @date 2018/4/18
  */
 public class OrderSearch implements Search {
 
+    /**
+     * 查找方法
+     *
+     * @param array 被查找的线性表
+     * @param key 被查找的 key
+     * @return 成功返回 key 的位置；失败返回 -1
+     */
     @Override
-    public int search(int[] list, int key) {
-        // 从前往后扫描list数组，如果有元素的值与key相等，直接返回其位置
-        for (int i = 0; i < list.length; i++) {
-            if (key == list[i]) {
+    public <T extends Comparable<T>> int find(T[] array, T key) {
+        for (int i = 0; i < array.length; i++) {
+            if (array[i].compareTo(key) == 0) {
                 return i;
             }
         }
-
-        // 如果扫描完，说明没有元素的值匹配key，返回-1，表示查找失败
         return -1;
     }
 }

codes/src/main/java/io/github/dunwu/algorithm/sort/Sort.java

@@ -6,7 +6,7 @@
 public interface Sort {
     /**
      * 排序接口
-     * @param list 数组
+     * @param list 要排序的数组
      */
-    void sort(int[] list);
+    <T extends Comparable<T>> void sort(T[] list);
 }

codes/src/main/java/io/github/dunwu/algorithm/sort/SortStrategy.java

@@ -16,7 +16,7 @@ public SortStrategy(Sort sort) {
         this.sort = sort;
     }
 
-    public void sort(int[] list) {
+    public void sort(Integer[] list) {
         logger.info(this.sort.getClass().getSimpleName() + " 排序开始：");
         logger.info("排序前: {}", ArrayUtil.getArrayString(list, 0, list.length - 1));
         this.sort.sort(list);

codes/src/main/java/io/github/dunwu/algorithm/sort/strategy/BubbleSort.java

@@ -9,17 +9,14 @@
  */
 public class BubbleSort implements Sort {
     @Override
-    public void sort(int[] list) {
-        // 用来交换的临时数
-        int temp = 0;
-
+    public <T extends Comparable<T>> void sort(T[] list) {
         // 要遍历的次数
         for (int i = 0; i < list.length - 1; i++) {
             // 从后向前依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
             for (int j = list.length - 1; j > i; j--) {
                 // 比较相邻的元素，如果前面的数大于后面的数，则交换
-                if (list[j - 1] > list[j]) {
-                    temp = list[j - 1];
+                if (list[j - 1].compareTo(list[j]) > 0) {
+                    T temp = list[j - 1];
                     list[j - 1] = list[j];
                     list[j] = temp;
                 }

codes/src/main/java/io/github/dunwu/algorithm/sort/strategy/BubbleSort2.java

@@ -9,9 +9,7 @@
  */
 public class BubbleSort2 implements Sort {
     @Override
-    public void sort(int[] list) {
-        // 用来交换的临时数
-        int temp = 0;
+    public <T extends Comparable<T>> void sort(T[] list) {
         // 交换标志
         boolean bChange = false;
 
@@ -21,8 +19,8 @@ public void sort(int[] list) {
             // 从后向前依次的比较相邻两个数的大小，遍历一次后，把数组中第i小的数放在第i个位置上
             for (int j = list.length - 1; j > i; j--) {
                 // 比较相邻的元素，如果前面的数大于后面的数，则交换
-                if (list[j - 1] > list[j]) {
-                    temp = list[j - 1];
+                if (list[j - 1].compareTo(list[j]) > 0) {
+                    T temp = list[j - 1];
                     list[j - 1] = list[j];
                     list[j] = temp;
                     bChange = true;

codes/src/main/java/io/github/dunwu/algorithm/sort/strategy/HeapSort.java

@@ -8,20 +8,20 @@
  * @author Zhang Peng
  */
 public class HeapSort implements Sort {
-    private static void adjustHeat(int[] array, int parent, int length) {
+    private static <T extends Comparable<T>> void adjustHeat(T[] array, int parent, int length) {
         // temp保存当前父节点
-        int temp = array[parent];
+        T temp = array[parent];
         // 先获得左孩子
         int child = 2 * parent + 1;
 
         while (child < length) {
             // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
-            if (child + 1 < length && array[child] < array[child + 1]) {
+            if (child + 1 < length && array[child].compareTo(array[child + 1]) < 0) {
                 child++;
             }
 
             // 如果父结点的值已经大于孩子结点的值，则直接结束
-            if (temp >= array[child]) {
+            if (temp.compareTo(array[child]) >= 0) {
                 break;
             }
 
@@ -37,7 +37,7 @@ private static void adjustHeat(int[] array, int parent, int length) {
     }
 
     @Override
-    public void sort(int[] list) {
+    public <T extends Comparable<T>> void sort(T[] list) {
         // 循环建立初始堆
         for (int i = list.length / 2; i >= 0; i--) {
             adjustHeat(list, i, list.length);
@@ -46,7 +46,7 @@ public void sort(int[] list) {
         // 进行n-1次循环，完成排序
         for (int i = list.length - 1; i > 0; i--) {
             // 最后一个元素和第一元素进行交换
-            int temp = list[i];
+            T temp = list[i];
             list[i] = list[0];
             list[0] = temp;