JS-Sorting-Algorithm

Author: jsonlog

Algorithms/src/main/java/com/jsonlog/algorithms/helloWorld.java

@@ -1,5 +1,7 @@
 package com.jsonlog.algorithms;
 
+import com.jsonlog.algorithms.sort.BubbleSort;
+
 import java.util.Arrays;
 import java.util.Date;
 import java.util.Random;
@@ -13,14 +15,35 @@ public static void main(String[] args) {
 
 
 
-        random();
+//        random();
 //        array();
 //        movebit();
-//
+        sort();
+
+
+
 //        try {
 //            Thread.currentThread().sleep(5 * 1000);
 //        } catch(InterruptedException e) {}
     }
+    static void sort(){
+        // 生成随机数组
+        int[] array = randomArray(-1000, 1000, 100);
+        // 使用 Arrays.sort() 排序作为对比
+//        int[] sortedArray = Arrays.copyOf(array, array.length);
+//        Arrays.sort(sortedArray);
+
+        BubbleSort bubbleSort = new BubbleSort();
+        sout(bubbleSort.sort(array));
+    }
+
+    static void sout(int[] array){
+        for(int i : array){
+            System.out.print(i+" ");
+        }
+        System.out.println();
+    }
+
     static void random(){
         for (int i = 0; i < 10; i++) {
             Random rand = new Random(47);//no change
@@ -78,4 +101,41 @@ static void movebit(){
         i = 127 << 1;
         System.out.println(""+i);
     }
+    /**
+     * 随机指定范围内N个不重复的数
+     * 在初始化的无重复待选数组中随机产生一个数放入结果中，
+     * 将待选数组被随机到的数，用待选数组(len-1)下标对应的数替换
+     * 然后从len-2里随机产生下一个随机数，如此类推
+     *
+     * @param max 指定范围最大值
+     * @param min 指定范围最小值
+     * @param n   随机数个数
+     * @return int[] 随机数结果集
+     */
+    static public int[] randomArray(int min, int max, int n) {
+        int len = max - min + 1;
+
+        if (max < min || n > len) {
+            return null;
+        }
+
+        //初始化给定范围的待选数组
+        int[] source = new int[len];
+        for (int i = min; i < min + len; i++) {
+            source[i - min] = i;
+        }
+
+        int[] result = new int[n];
+        Random rd = new Random();
+        int index = 0;
+        for (int i = 0; i < result.length; i++) {
+            //待选数组0到(len-2)随机一个下标
+            index = Math.abs(rd.nextInt() % len--);
+            //将随机到的数放入结果集
+            result[i] = source[index];
+            //将待选数组中被随机到的数，用待选数组(len-1)下标对应的数替换
+            source[index] = source[len];
+        }
+        return result;
+    }
 }

Algorithms/src/main/java/com/jsonlog/algorithms/sort/BubbleSort.java

@@ -0,0 +1,34 @@
+package com.jsonlog.algorithms.sort;
+
+import java.util.Arrays;
+
+/**
+ * @author jsonlog
+ * @date 2019-08-24
+ */
+public class BubbleSort {
+    static public int[] sort(int[] sourceArray){
+        // 对 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;
+    }
+}

Algorithms/src/main/java/com/jsonlog/algorithms/sort/BucketSort.java

@@ -0,0 +1,70 @@
+package com.jsonlog.algorithms.sort;
+
+import java.util.Arrays;
+
+/**
+ * @author jsonlog
+ * @date 2019-08-24
+ */
+public class BucketSort {
+    private static final InsertSort insertSort = new InsertSort();
+
+    public int[] sort(int[] sourceArray) throws Exception {
+        // 对 arr 进行拷贝，不改变参数内容
+        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
+
+        return bucketSort(arr, 5);
+    }
+
+    private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
+        if (arr.length == 0) {
+            return arr;
+        }
+
+        int minValue = arr[0];
+        int maxValue = arr[0];
+        for (int value : arr) {
+            if (value < minValue) {
+                minValue = value;
+            } else if (value > maxValue) {
+                maxValue = value;
+            }
+        }
+
+        int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;
+        int[][] buckets = new int[bucketCount][0];
+
+        // 利用映射函数将数据分配到各个桶中
+        for (int i = 0; i < arr.length; i++) {
+            int index = (int) Math.floor((arr[i] - minValue) / bucketSize);
+            buckets[index] = arrAppend(buckets[index], arr[i]);
+        }
+
+        int arrIndex = 0;
+        for (int[] bucket : buckets) {
+            if (bucket.length <= 0) {
+                continue;
+            }
+            // 对每个桶进行排序，这里使用了插入排序
+            bucket = insertSort.sort(bucket);
+            for (int value : bucket) {
+                arr[arrIndex++] = value;
+            }
+        }
+
+        return arr;
+    }
+
+    /**
+     * 自动扩容，并保存数据
+     *
+     * @param arr
+     * @param value
+     */
+    private int[] arrAppend(int[] arr, int value) {
+        arr = Arrays.copyOf(arr, arr.length + 1);
+        arr[arr.length - 1] = value;
+        return arr;
+    }
+
+}

Algorithms/src/main/java/com/jsonlog/algorithms/sort/CountingSort.java

@@ -0,0 +1,47 @@
+package com.jsonlog.algorithms.sort;
+
+import java.util.Arrays;
+
+/**
+ * @author jsonlog
+ * @date 2019-08-24
+ */
+public class CountingSort {
+    static public int[] sort(int[] sourceArray){
+        // 对 arr 进行拷贝，不改变参数内容
+        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
+
+        int maxValue = getMaxValue(arr);
+
+        return countingSort(arr, maxValue);
+    }
+
+    static private int[] countingSort(int[] arr, int maxValue) {
+        int bucketLen = maxValue + 1;
+        int[] bucket = new int[bucketLen];
+
+        for (int value : arr) {
+            bucket[value]++;
+        }
+
+        int sortedIndex = 0;
+        for (int j = 0; j < bucketLen; j++) {
+            while (bucket[j] > 0) {
+                arr[sortedIndex++] = j;
+                bucket[j]--;
+            }
+        }
+        return arr;
+    }
+
+    static private int getMaxValue(int[] arr) {
+        int maxValue = arr[0];
+        for (int value : arr) {
+            if (maxValue < value) {
+                maxValue = value;
+            }
+        }
+        return maxValue;
+    }
+
+}

Algorithms/src/main/java/com/jsonlog/algorithms/sort/HeapSort.java

@@ -0,0 +1,57 @@
+package com.jsonlog.algorithms.sort;
+
+import java.util.Arrays;
+
+/**
+ * @author jsonlog
+ * @date 2019-08-24
+ */
+public class HeapSort {
+    static public int[] sort(int[] sourceArray){
+        // 对 arr 进行拷贝，不改变参数内容
+        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
+
+        int len = arr.length;
+
+        buildMaxHeap(arr, len);
+
+        for (int i = len - 1; i > 0; i--) {
+            swap(arr, 0, i);
+            len--;
+            heapify(arr, 0, len);
+        }
+        return arr;
+    }
+
+    static private void buildMaxHeap(int[] arr, int len) {
+        for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
+            heapify(arr, i, len);
+        }
+    }
+
+    static private void heapify(int[] arr, int i, int len) {
+        int left = 2 * i + 1;
+        int right = 2 * i + 2;
+        int largest = i;
+
+        if (left < len && arr[left] > arr[largest]) {
+            largest = left;
+        }
+
+        if (right < len && arr[right] > arr[largest]) {
+            largest = right;
+        }
+
+        if (largest != i) {
+            swap(arr, i, largest);
+            heapify(arr, largest, len);
+        }
+    }
+
+    static private void swap(int[] arr, int i, int j) {
+        int temp = arr[i];
+        arr[i] = arr[j];
+        arr[j] = temp;
+    }
+
+}

Algorithms/src/main/java/com/jsonlog/algorithms/sort/InsertSort.java

@@ -0,0 +1,35 @@
+package com.jsonlog.algorithms.sort;
+
+import java.util.Arrays;
+
+/**
+ * @author jsonlog
+ * @date 2019-08-24
+ */
+public class InsertSort {
+    static public int[] sort(int[] sourceArray){
+        // 对 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;
+    }
+}

Algorithms/src/main/java/com/jsonlog/algorithms/sort/MergeSort.java

@@ -0,0 +1,51 @@
+package com.jsonlog.algorithms.sort;
+
+import java.util.Arrays;
+
+/**
+ * @author jsonlog
+ * @date 2019-08-24
+ */
+public class MergeSort {
+    static public int[] sort(int[] sourceArray){
+        // 对 arr 进行拷贝，不改变参数内容
+        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
+
+        if (arr.length < 2) {
+            return arr;
+        }
+        int middle = (int) Math.floor(arr.length / 2);
+
+        int[] left = Arrays.copyOfRange(arr, 0, middle);
+        int[] right = Arrays.copyOfRange(arr, middle, arr.length);
+
+        return merge(sort(left), sort(right));
+    }
+
+    static protected int[] merge(int[] left, int[] right) {
+        int[] result = new int[left.length + right.length];
+        int l = 0, r = 0, len = 0;
+        while (len < left.length + right.length) {
+            if (left[l] <= right[r]) {
+                result[len++] = left[l++];
+
+                if (l == left.length) {
+                    for (int i = r; i < right.length; i++) {
+                        result[len++] = right[r++];
+                    }
+                }
+            } else {
+                result[len++] = right[r++];
+
+                if (r == right.length) {
+                    for (int i = l; i < left.length; i++) {
+                        result[len++] = left[l++];
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+}