sort

Author: Kuangcp

algorithms/src/main/java/com/github/kuangcp/found/BinarySearch.java

@@ -1,34 +1,34 @@
 package com.github.kuangcp.found;
 
 /**
- * TODO 当数据有重复的时候，这个算法并不能做到返回数据第一次出现的地方
+ * 当数据有重复的时候，这个算法并不能做到返回数据第一次出现的地方
  */
 public class BinarySearch {
-  private static int index = -2;
+    private static int index = -2;
 
-  private static void found(int[] arr, int left, int right, int data) {
+    private static void found(int[] arr, int left, int right, int data) {
 
-    int mid = (left + right) / 2;
-    if (arr[mid] == data) {
-      index = mid;
-    }
+        int mid = (left + right) / 2;
+        if (arr[mid] == data) {
+            index = mid;
+        }
 
-    if (arr[mid] > data && left < mid - 1) {
-      found(arr, left, mid, data);
-    }
+        if (arr[mid] > data && left < mid - 1) {
+            found(arr, left, mid, data);
+        }
 
-    if (arr[mid] < data && right > mid + 1) {
-      found(arr, mid, right, data);
+        if (arr[mid] < data && right > mid + 1) {
+            found(arr, mid, right, data);
+        }
     }
-  }
 
-  /**
-   * find num from arr
-   *
-   * @return index not found then return -1
-   */
-  public int find(int[] arr, int data) {
-    found(arr, 0, arr.length, data);
-    return index + 1;
-  }
+    /**
+     * find num from arr
+     *
+     * @return index not found then return -1
+     */
+    public int find(int[] arr, int data) {
+        found(arr, 0, arr.length, data);
+        return index + 1;
+    }
 }

algorithms/src/main/java/com/github/kuangcp/sort/Bubble.java

@@ -8,24 +8,22 @@
  *
  * @author kcp
  */
-public enum Bubble implements SortAlgorithm {
+public class Bubble {
 
-  INSTANCE;
+    public static int[] sort(int[] data) {
+        int[] result = Arrays.copyOf(data, data.length);
 
-  public int[] sort(int[] data) {
-    int[] result = Arrays.copyOf(data, data.length);
-
-    for (int i = 1; i < result.length; i++) {
-      //用来冒泡的语句，0到已排序的部分
-      for (int j = 0; j < result.length - i; j++) {
-        //大就交换，把最大的沉入最后
-        if (result[j] > result[j + 1]) {
-          int temp = result[j + 1];
-          result[j + 1] = result[j];
-          result[j] = temp;
+        for (int i = 1; i < result.length; i++) {
+            //用来冒泡的语句，0到已排序的部分
+            for (int j = 0; j < result.length - i; j++) {
+                //大就交换，把最大的沉入最后
+                if (result[j] > result[j + 1]) {
+                    int temp = result[j + 1];
+                    result[j + 1] = result[j];
+                    result[j] = temp;
+                }
+            }
         }
-      }
+        return result;
     }
-    return result;
-  }
 }

algorithms/src/main/java/com/github/kuangcp/sort/Insert.java

@@ -5,30 +5,28 @@
 /**
  * 插入法排序，由小到大
  * 最坏的情况就是数列是有序的大到小，那么需要比较和移动 n(n+1)/2 次 时间复杂度是O(n^2)
- *
+ * <p>
  * 指针从第二个数开始，后移，发现当前数比前面一个数小就把前面那个数后移，往前比较，知道找到那个数小于当前数为止，指针后移
  * 直至到最后一个
  * 思想是，指针位置之前的数都是有序的
  */
-public enum Insert implements SortAlgorithm {
+public class Insert {
 
-  INSTANCE;
+    public static int[] sort(int[] data) {
+        int[] result = Arrays.copyOf(data, data.length);
+        int i, j, tmp;
 
-  public int[] sort(int[] data) {
-    int[] result = Arrays.copyOf(data, data.length);
-    int i, j, tmp;
-
-    for (i = 1; i < result.length; i++) {
-      tmp = result[i];
-      j = i - 1;
-      //比较，如果是比前面还要小，就将数字往后移动一位。将小的那一位插入到合适位置
-      while (j >= 0 && tmp < result[j]) {
-        result[j + 1] = result[j];
-        j--;
-      }
-      result[j + 1] = tmp;
+        for (i = 1; i < result.length; i++) {
+            tmp = result[i];
+            j = i - 1;
+            //比较，如果是比前面还要小，就将数字往后移动一位。将小的那一位插入到合适位置
+            while (j >= 0 && tmp < result[j]) {
+                result[j + 1] = result[j];
+                j--;
+            }
+            result[j + 1] = tmp;
+        }
+        return result;
     }
-    return result;
-  }
 
 }

algorithms/src/main/java/com/github/kuangcp/sort/Quick.java

@@ -9,137 +9,134 @@
  *
  * @author Myth
  */
-public enum Quick implements SortAlgorithm {
+public class Quick {
 
-  INSTANCE;
-
-  @Override
-  public int[] sort(int[] data) {
-    int[] result = Arrays.copyOf(data, data.length);
-    QuickSort sort = new FirstImpl();
-    sort.sortData(result, 0, result.length - 1);
-    return result;
-  }
-
-
-  interface QuickSort {
-
-    void sortData(int[] data, int low, int high);
-  }
+    public static int[] sort(int[] data) {
+        int[] result = Arrays.copyOf(data, data.length);
+        QuickSort sort = new FirstImpl();
+        sort.sortData(result, 0, result.length - 1);
+        return result;
+    }
 
-  /**
-   * 高效的写法
-   */
-  static class FirstImpl implements QuickSort {
 
-    @Override
-    public void sortData(int[] data, int low, int high) {
-      if (low >= high) {
-        return;
-      }
+    interface QuickSort {
 
-      int lowIndex = low;
-      int highIndex = high;
+        void sortData(int[] data, int low, int high);
+    }
 
-      int value = data[low];
-      while (lowIndex < highIndex) {
-        // 找出右边小于低位所在的标识值
-        while (lowIndex < highIndex && data[highIndex] >= value) {
-          highIndex -= 1;
+    /**
+     * 高效的写法
+     */
+    static class FirstImpl implements QuickSort {
+
+        @Override
+        public void sortData(int[] data, int low, int high) {
+            if (low >= high) {
+                return;
+            }
+
+            int lowIndex = low;
+            int highIndex = high;
+
+            int value = data[low];
+            while (lowIndex < highIndex) {
+                // 找出右边小于低位所在的标识值
+                while (lowIndex < highIndex && data[highIndex] >= value) {
+                    highIndex -= 1;
+                }
+                data[lowIndex] = data[highIndex];
+
+                // 找出左边大于标识值
+                while (lowIndex < highIndex && data[lowIndex] <= value) {
+                    lowIndex += 1;
+                }
+                data[highIndex] = data[lowIndex];
+            }
+
+            data[lowIndex] = value;
+
+            sortData(data, low, lowIndex - 1);
+            sortData(data, highIndex + 1, high);
         }
-        data[lowIndex] = data[highIndex];
+    }
 
-        // 找出左边大于标识值
-        while (lowIndex < highIndex && data[lowIndex] <= value) {
-          lowIndex += 1;
+    /**
+     * 个人手写
+     */
+    static class SecondImpl implements QuickSort {
+
+        @Override
+        public void sortData(int[] data, int low, int high) {
+            int lowIndex = low;
+            int highIndex = high;
+            int index = data[low];
+
+            while (lowIndex < highIndex) {
+                while (lowIndex < highIndex && data[highIndex] >= index) {
+                    highIndex--;
+                }
+                if (lowIndex < highIndex) {
+                    int temp = data[highIndex];
+                    data[highIndex] = data[lowIndex];
+                    data[lowIndex] = temp;
+                    lowIndex++;
+                }
+
+                while (lowIndex < highIndex && data[lowIndex] <= index) {
+                    lowIndex++;
+                }
+                if (lowIndex < highIndex) {
+                    int temp = data[highIndex];
+                    data[highIndex] = data[lowIndex];
+                    data[lowIndex] = temp;
+                    highIndex--;
+                }
+            }
+
+            if (lowIndex > low) {
+                sortData(data, low, lowIndex - 1);
+            }
+            if (highIndex < high) {
+                sortData(data, lowIndex + 1, high);
+            }
         }
-        data[highIndex] = data[lowIndex];
-      }
+    }
 
-      data[lowIndex] = value;
+    /**
+     * 对象数组排序
+     */
+    public <T extends Comparable<? super T>> T[] quickSort(T[] data, int start, int end) {
+        int low = start + 1, high = end;
+        T key = data[start];
 
-      sortData(data, low, lowIndex - 1);
-      sortData(data, highIndex + 1, high);
-    }
-  }
-
-  /**
-   * 个人手写
-   */
-  static class SecondImpl implements QuickSort {
-
-    @Override
-    public void sortData(int[] data, int low, int high) {
-      int lowIndex = low;
-      int highIndex = high;
-      int index = data[low];
-
-      while (lowIndex < highIndex) {
-        while (lowIndex < highIndex && data[highIndex] >= index) {
-          highIndex--;
+        if (start >= end) {
+            return (data);
         }
-        if (lowIndex < highIndex) {
-          int temp = data[highIndex];
-          data[highIndex] = data[lowIndex];
-          data[lowIndex] = temp;
-          lowIndex++;
+
+        while (true) {
+            while (data[high].compareTo(key) > 0) {
+                high--;
+            }
+            while (data[low].compareTo(key) < 0 && low < high) {
+                low++;
+            }
+            if (low >= high) {
+                break;
+            }
+            if (data[low] == key) {
+                high--;
+            } else {
+                low++;
+            }
         }
 
-        while (lowIndex < highIndex && data[lowIndex] <= index) {
-          lowIndex++;
+        if (start < low - 1) {
+            this.quickSort(data, start, low - 1);
         }
-        if (lowIndex < highIndex) {
-          int temp = data[highIndex];
-          data[highIndex] = data[lowIndex];
-          data[lowIndex] = temp;
-          highIndex--;
+        if (high + 1 < end) {
+            this.quickSort(data, high + 1, end);
         }
-      }
-
-      if (lowIndex > low) {
-        sortData(data, low, lowIndex - 1);
-      }
-      if (highIndex < high) {
-        sortData(data, lowIndex + 1, high);
-      }
-    }
-  }
-
-  /**
-   * 对象数组排序
-   */
-  public <T extends Comparable<? super T>> T[] quickSort(T[] data, int start, int end) {
-    int low = start + 1, high = end;
-    T key = data[start];
-
-    if (start >= end) {
-      return (data);
-    }
 
-    while (true) {
-      while (data[high].compareTo(key) > 0) {
-        high--;
-      }
-      while (data[low].compareTo(key) < 0 && low < high) {
-        low++;
-      }
-      if (low >= high) {
-        break;
-      }
-      if (data[low] == key) {
-        high--;
-      } else {
-        low++;
-      }
+        return data;
     }
-
-    if (start < low - 1) {
-      this.quickSort(data, start, low - 1);
-    }
-    if (high + 1 < end) {
-      this.quickSort(data, high + 1, end);
-    }
-
-    return data;
-  }
 }