O(n)~O(n^2)~O(n^2)
* 稳定 + * + * @author linqiankun */ public class BubbleSort { @@ -14,8 +16,8 @@ public class BubbleSort { /** * 冒泡排序 * - * @param array - * @param sortStatusCode + * @param array 需要排序的数组 + * @param sortStatusCode 排序方式 */ public static void bubbleSorted(int[] array, SortStatusCode sortStatusCode) { for (int i = 0; i < array.length; i++) { @@ -33,22 +35,23 @@ public class BubbleSort { /** * 鸡尾酒排序 * - * @param array - * @param n + * @param array 需要排序的数组 + * @param n 数组大小 */ public static void CocktailSort(int[] array, int n) { - int left = 0; // 初始化边界 + // 初始化边界 + int left = 0; int right = n - 1; while (left < right) { - for (int i = left; i < right; i++) // 前半轮,将最大元素放到后面 - { + // 前半轮,将最大元素放到后面 + for (int i = left; i < right; i++) { if (array[i] > array[i + 1]) { SortUtil.swap(array, i, i + 1); } } right--; - for (int i = right; i > left; i--) // 后半轮,将最小元素放到前面 - { + // 后半轮,将最小元素放到前面 + for (int i = right; i > left; i--) { if (array[i - 1] > array[i]) { SortUtil.swap(array, i - 1, i); } diff --git a/src/main/java/com/lin/sort/BucketSort.java b/src/main/java/com/lin/sort/BucketSort.java index 45020c7..c966feb 100644 --- a/src/main/java/com/lin/sort/BucketSort.java +++ b/src/main/java/com/lin/sort/BucketSort.java @@ -6,6 +6,8 @@ import java.util.Arrays; /** * 桶排序 + * + * @author linqiankun */ public class BucketSort { @@ -13,9 +15,8 @@ public class BucketSort { /** * 桶排序 * - * @param sourceArray - * @return - * @throws Exception + * @param sourceArray 需要排序的数组 + * @return 排序后的数组 */ public static int[] bucketSorted(int[] sourceArray) { // 对 arr 进行拷贝,不改变参数内容 @@ -27,10 +28,9 @@ public class BucketSort { /** * 桶排序 * - * @param arr - * @param bucketSize - * @return - * @throws Exception + * @param arr 需要排序的数组 + * @param bucketSize 桶大小 + * @return 排序后的数组 */ private static int[] bucketSort(int[] arr, int bucketSize) { if (arr.length == 0) { @@ -51,9 +51,9 @@ public class BucketSort { 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]); + for (int item : arr) { + int index = (int) Math.floor((item - minValue) / bucketSize); + buckets[index] = arrAppend(buckets[index], item); } int arrIndex = 0; @@ -62,10 +62,8 @@ public class BucketSort { continue; } // 对每个桶进行排序,这里使用了插入排序 - InsertionSort.insertionSorted(bucket, SortStatusCode.MIX_SORT); - -// bucket = insertSort.sort(bucket); + // bucket = insertSort.sort(bucket); for (int value : bucket) { arr[arrIndex++] = value; } @@ -77,8 +75,9 @@ public class BucketSort { /** * 自动扩容,并保存数据 * - * @param arr - * @param value + * @param arr 桶 + * @param value 值 + * @return 桶 */ private static int[] arrAppend(int[] arr, int value) { arr = Arrays.copyOf(arr, arr.length + 1); diff --git a/src/main/java/com/lin/sort/CountingSort.java b/src/main/java/com/lin/sort/CountingSort.java index f000a3a..9cf6589 100644 --- a/src/main/java/com/lin/sort/CountingSort.java +++ b/src/main/java/com/lin/sort/CountingSort.java @@ -4,6 +4,8 @@ import java.util.Arrays; /** * 计数排序 + * + * @author linqiankun */ public class CountingSort { @@ -11,7 +13,7 @@ public class CountingSort { /** * 计数排序 * - * @param sourceArray + * @param sourceArray 需要排序的数组 * @return 返回排序后的数组 */ public static int[] countingsorted(int[] sourceArray) { @@ -26,9 +28,9 @@ public class CountingSort { /** * 统计排序 * - * @param arr - * @param maxValue - * @return + * @param arr 排序的数组 + * @param maxValue 最大值 + * @return 排序后的数组 */ private static int[] sort(int[] arr, int maxValue) { int bucketLen = maxValue + 1; @@ -51,8 +53,8 @@ public class CountingSort { /** * 获取最大值 * - * @param arr - * @return + * @param arr 需要排序的数组 + * @return 最大值 */ private static int getMaxValue(int[] arr) { int maxValue = arr[0]; diff --git a/src/main/java/com/lin/sort/HeapSort.java b/src/main/java/com/lin/sort/HeapSort.java index 45955ca..caa6de8 100644 --- a/src/main/java/com/lin/sort/HeapSort.java +++ b/src/main/java/com/lin/sort/HeapSort.java @@ -7,63 +7,81 @@ import com.lin.sort.util.SortUtil; * 堆排序 *O(nlogn)~O(nlogn)~O(nlogn)
* 不稳定 + * + * @author linqiankun */ public class HeapSort { /** * 堆排序 * - * @param array - * @param sortStatusCode + * @param array 需要排序的数组 + * @param sortStatusCode 排序方式 */ public static void heapSorted(int[] array, SortStatusCode sortStatusCode) { - int heap_size = buildHeap(array, array.length, sortStatusCode); // 建立一个最大堆 - while (heap_size > 1) { // 堆(无序区)元素个数大于1,未完成排序 + // 建立一个最大堆 + int heapSize = buildHeap(array, array.length, sortStatusCode); + // 堆(无序区)元素个数大于1,未完成排序 + while (heapSize > 1) { // 将堆顶元素与堆的最后一个元素互换,并从堆中去掉最后一个元素 // 此处交换操作很有可能把后面元素的稳定性打乱,所以堆排序是不稳定的排序算法 - SortUtil.swap(array, 0, --heap_size); - heapify(array, 0, heap_size, sortStatusCode); // 从新的堆顶元素开始向下进行堆调整,时间复杂度O(logn) + SortUtil.swap(array, 0, --heapSize); + // 从新的堆顶元素开始向下进行堆调整,时间复杂度O(logn) + heapify(array, 0, heapSize, sortStatusCode); } } /** * 堆结构调整 + * 从A[i]向下进行堆调整 * - * @param array - * @param i + * @param array 堆数组 + * @param i 当前节点索引 * @param size + * @param sortStatusCode 排序方式 */ - private static void heapify(int[] array, int i, int size, SortStatusCode sortStatusCode) // 从A[i]向下进行堆调整 - { - int left_child = 2 * i + 1; // 左孩子索引 - int right_child = 2 * i + 2; // 右孩子索引 - int max = i; // 选出当前结点与其左右孩子三者之中的最大值 - if (left_child < size && sortStatusCode.getCode() == SortUtil.compare(array[max], array[left_child])) -// if (left_child < size && array[left_child] > array[max]) - max = left_child; - if (right_child < size && sortStatusCode.getCode() == SortUtil.compare(array[max], array[right_child])) -// if (right_child < size && array[right_child] > array[max]) - max = right_child; + private static void heapify(int[] array, int i, int size, SortStatusCode sortStatusCode) { + // 左孩子索引 + int leftChild = 2 * i + 1; + // 右孩子索引 + int rightChild = 2 * i + 2; + // 选出当前结点与其左右孩子三者之中的最大值 + int max = i; + if (leftChild < size && sortStatusCode.getCode() == SortUtil.compare(array[max], array[leftChild])) + // if (leftChild < size && array[leftChild] > array[max]) + { + max = leftChild; + } + if (rightChild < size && sortStatusCode.getCode() == SortUtil.compare(array[max], array[rightChild])) + // if (rightChild < size && array[rightChild] > array[max]) + { + max = rightChild; + } if (max != i) { - SortUtil.swap(array, i, max); // 把当前结点和它的最大(直接)子节点进行交换 - heapify(array, max, size, sortStatusCode); // 递归调用,继续从当前结点向下进行堆调整 + // 把当前结点和它的最大(直接)子节点进行交换 + SortUtil.swap(array, i, max); + // 递归调用,继续从当前结点向下进行堆调整 + heapify(array, max, size, sortStatusCode); } } /** * 构造堆 + * 建堆,时间复杂度O(n) * - * @param array - * @param n + * @param array 堆数组 + * @param n 当前节点 + * @param sortStatusCode 排序方式 * @return */ - private static int buildHeap(int[] array, int n, SortStatusCode sortStatusCode) // 建堆,时间复杂度O(n) - { - int heap_size = n; - for (int i = heap_size / 2 - 1; i >= 0; i--) // 从每一个非叶结点开始向下进行堆调整 - heapify(array, i, heap_size, sortStatusCode); - return heap_size; + private static int buildHeap(int[] array, int n, SortStatusCode sortStatusCode) { + int heapSize = n; + // 从每一个非叶结点开始向下进行堆调整 + for (int i = heapSize / 2 - 1; i >= 0; i--) { + heapify(array, i, heapSize, sortStatusCode); + } + return heapSize; } diff --git a/src/main/java/com/lin/sort/InsertionSort.java b/src/main/java/com/lin/sort/InsertionSort.java index f574250..78767d5 100644 --- a/src/main/java/com/lin/sort/InsertionSort.java +++ b/src/main/java/com/lin/sort/InsertionSort.java @@ -7,6 +7,8 @@ import com.lin.sort.util.SortUtil; * 插入排序 *O(n)~O(n^2)~O(n^2)
* 稳定 + * + * @author linqiankun */ public class InsertionSort { @@ -14,8 +16,8 @@ public class InsertionSort { /** * 插入排序 * - * @param array - * @param sortStatusCode + * @param array 需要排序的数组 + * @param sortStatusCode 排序方式 */ public static void insertionSorted(int[] array, SortStatusCode sortStatusCode) { //默认第0个是排好序的,i以前的排好序 @@ -36,8 +38,8 @@ public class InsertionSort { /** * 二分插入排序 * - * @param array - * @param sortStatusCode + * @param array 需要排序的数组 + * @param sortStatusCode 排序方式 */ public static void insertionSortedDichotomy(int[] array, SortStatusCode sortStatusCode) { for (int i = 1; i < array.length; i++) { @@ -45,19 +47,19 @@ public class InsertionSort { int left = 0; int right = i - 1; //二分查找数据所处的位置,也是在之前的队列中 - while (left <= right) - { + while (left <= right) { int mid = (left + right) / 2; - if (sortStatusCode.getCode() == SortUtil.compare(get,array[mid])) -// if (array[mid] > get) + if (sortStatusCode.getCode() == SortUtil.compare(get, array[mid])) + // if (array[mid] > get) + { right = mid - 1; - else + } else { left = mid + 1; + } } //拿走的是位置i的数据,left之后的往后移动 - for (int j = i - 1; j >= left; j--) - { - array[j + 1] = array[j]; + if (i - left >= 0) { + System.arraycopy(array, left, array, left + 1, i - left); } array[left] = get; } diff --git a/src/main/java/com/lin/sort/MergeSort.java b/src/main/java/com/lin/sort/MergeSort.java index 8602c1c..389abc3 100644 --- a/src/main/java/com/lin/sort/MergeSort.java +++ b/src/main/java/com/lin/sort/MergeSort.java @@ -7,6 +7,8 @@ import com.lin.sort.util.SortUtil; * 归并排序 *O(nlogn)~O(nlogn)~O(nlogn)
* 稳定 + * + * @author linqiankun */ public class MergeSort { @@ -14,10 +16,10 @@ public class MergeSort { /** * 非递归归并排序(错误) * - * @param array - * @param sortStatusCode + * @param array 需要排序的数组 + * @param sortStatusCode 排序方式 */ - public static void mergeSortedIteration(int array[], SortStatusCode sortStatusCode) { + public static void mergeSortedIteration(int[] array, SortStatusCode sortStatusCode) { int left, mid, right; for (int i = 1; i < array.length; i *= 2) { left = 0; @@ -34,14 +36,15 @@ public class MergeSort { /** * 递归使用归并排序 * - * @param array - * @param sortStatusCode - * @param left - * @param right + * @param array 需要排序的数组 + * @param sortStatusCode 排序方式 + * @param left 左边界 + * @param right 右边界 */ public static void mergeSortedRecursion(int[] array, SortStatusCode sortStatusCode, int left, int right) { - if (left == right) + if (left == right) { return; + } int mid = (left + right) / 2; //前半段数组归并 mergeSortedRecursion(array, sortStatusCode, left, mid); @@ -54,11 +57,11 @@ public class MergeSort { /** * 数组合并 * - * @param array - * @param sortStatusCode - * @param left - * @param mid - * @param right + * @param array 需要合并的数组 + * @param sortStatusCode 排序方式 + * @param left 左边界 + * @param mid 中间位置 + * @param right 有边界 */ private static void merge(int[] array, SortStatusCode sortStatusCode, int left, int mid, int right) { int len = right - left + 1; diff --git a/src/main/java/com/lin/sort/QuickSort.java b/src/main/java/com/lin/sort/QuickSort.java index 0d03637..5c48f17 100644 --- a/src/main/java/com/lin/sort/QuickSort.java +++ b/src/main/java/com/lin/sort/QuickSort.java @@ -7,6 +7,8 @@ import com.lin.sort.util.SortUtil; * 快速排序 *O(nlogn)~O(nlogn)~O(n^2)
* 不稳定 + * + * @author linqiankun */ public class QuickSort { @@ -14,38 +16,45 @@ public class QuickSort { /** * 分治块 * - * @param array - * @param left - * @param right - * @param sortStatusCode - * @return + * @param array 分治数组 + * @param left 左边界 + * @param right 右边界 + * @param sortStatusCode 排序方式 + * @return 基准的索引 */ private static int partition(int[] array, int left, int right, SortStatusCode sortStatusCode) // 划分函数 { - int pivot = array[right]; // 这里每次都选择最后一个元素作为基准 - int tail = left - 1; // tail为小于基准的子数组最后一个元素的索引 - for (int i = left; i < right; i++) // 遍历基准以外的其他元素 - { - if (SortUtil.compare(pivot, array[i]) == 0 || !(sortStatusCode.getCode() == SortUtil.compare(pivot, array[i]))) //会破环稳定性 -// if (array[i] <= pivot) // 把小于等于基准的元素放到前一个子数组末尾 + // 这里每次都选择最后一个元素作为基准 + int pivot = array[right]; + // tail为小于基准的子数组最后一个元素的索引 + int tail = left - 1; + // 遍历基准以外的其他元素 + for (int i = left; i < right; i++) { + // 把小于等于基准的元素放到前一个子数组末尾 + //会破环稳定性 + if (SortUtil.compare(pivot, array[i]) == 0 || (sortStatusCode.getCode() != SortUtil.compare(pivot, array[i]))) + // if (array[i] <= pivot) { SortUtil.swap(array, ++tail, i); } - } - SortUtil.swap(array, tail + 1, right); // 最后把基准放到前一个子数组的后边,剩下的子数组既是大于基准的子数组 + } // 最后把基准放到前一个子数组的后边,剩下的子数组既是大于基准的子数组 // 该操作很有可能把后面元素的稳定性打乱,所以快速排序是不稳定的排序算法 - return tail + 1; // 返回基准的索引 + SortUtil.swap(array, tail + 1, right); + // 返回基准的索引 + return tail + 1; } /** * 快速排序 */ public static void quickSorted(int[] array, int left, int right, SortStatusCode sortStatusCode) { - if (left >= right) + if (left >= right) { return; - int pivot_index = partition(array, left, right, sortStatusCode); // 基准的索引 - quickSorted(array, left, pivot_index - 1, sortStatusCode); - quickSorted(array, pivot_index + 1, right, sortStatusCode); + } + // 基准的索引 + int pivotIndex = partition(array, left, right, sortStatusCode); + quickSorted(array, left, pivotIndex - 1, sortStatusCode); + quickSorted(array, pivotIndex + 1, right, sortStatusCode); } diff --git a/src/main/java/com/lin/sort/RadixSort.java b/src/main/java/com/lin/sort/RadixSort.java index 6c66253..9b4bf18 100644 --- a/src/main/java/com/lin/sort/RadixSort.java +++ b/src/main/java/com/lin/sort/RadixSort.java @@ -4,6 +4,8 @@ import java.util.Arrays; /** * 基数排序 + * + * @author linqiankun */ public class RadixSort { @@ -11,8 +13,8 @@ public class RadixSort { /** * 基数排序 * - * @param sourceArray - * @return + * @param sourceArray 需要排序的数组 + * @return 排序后的数组 */ public static int[] radixSorted(int[] sourceArray) { // 对 arr 进行拷贝,不改变参数内容 @@ -25,7 +27,7 @@ public class RadixSort { /** * 获取最高位数 * - * @param arr + * @param arr 需要排序的数组 * @return */ private static int getMaxDigit(int[] arr) { @@ -36,8 +38,8 @@ public class RadixSort { /** * 获取最大值 * - * @param arr - * @return + * @param arr 排序数组 + * @return 最大值 */ private static int getMaxValue(int[] arr) { int maxValue = arr[0]; @@ -49,7 +51,7 @@ public class RadixSort { return maxValue; } - protected static int getNumLenght(long num) { + private static int getNumLenght(long num) { if (num == 0) { return 1; } @@ -63,9 +65,9 @@ public class RadixSort { /** * 基数排序 * - * @param arr + * @param arr 排序数组 * @param maxDigit - * @return + * @return 排序后数组 */ private static int[] radixSort(int[] arr, int maxDigit) { int mod = 10; @@ -75,9 +77,9 @@ public class RadixSort { // 考虑负数的情况,这里扩展一倍队列数,其中 [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]); + for (int item : arr) { + int bucket = ((item % mod) / dev) + mod; + counter[bucket] = arrayAppend(counter[bucket], item); } int pos = 0; @@ -94,8 +96,8 @@ public class RadixSort { /** * 自动扩容,并保存数据 * - * @param arr - * @param value + * @param arr 数组 + * @param value 扩容后数组 */ private static int[] arrayAppend(int[] arr, int value) { arr = Arrays.copyOf(arr, arr.length + 1); diff --git a/src/main/java/com/lin/sort/SelectionSort.java b/src/main/java/com/lin/sort/SelectionSort.java index 1d94a9f..af7ee00 100644 --- a/src/main/java/com/lin/sort/SelectionSort.java +++ b/src/main/java/com/lin/sort/SelectionSort.java @@ -7,6 +7,8 @@ import com.lin.sort.util.SortUtil; * 选择排序 *O(n^2)~O(n^2)~O(n^2)
* 不稳定 + * + * @author linqiankun */ public class SelectionSort { @@ -14,8 +16,8 @@ public class SelectionSort { /** * 选择排序 * - * @param array - * @param sortStatusCode + * @param array 需要排序的数组 + * @param sortStatusCode 排序方式 */ public static void selectionSorted(int[] array, SortStatusCode sortStatusCode) { //确定最小的位置 diff --git a/src/main/java/com/lin/sort/ShellSort.java b/src/main/java/com/lin/sort/ShellSort.java index ada460a..76ffd6d 100644 --- a/src/main/java/com/lin/sort/ShellSort.java +++ b/src/main/java/com/lin/sort/ShellSort.java @@ -7,6 +7,8 @@ import com.lin.sort.util.SortUtil; * 希尔排序 *O(n^1.3)~O(nlogn)~O(n^2)~O(n^2)
* 不稳定 + * + * @author linqiankun */ public class ShellSort { @@ -14,8 +16,8 @@ public class ShellSort { /** * 希尔排序 * - * @param array - * @param sortStatusCode + * @param array 需要排序的数组 + * @param sortStatusCode 排序方式 */ public static void shellSorted(int[] array, SortStatusCode sortStatusCode) { int shell = 0; diff --git a/src/main/java/com/lin/sort/util/SortUtil.java b/src/main/java/com/lin/sort/util/SortUtil.java index 331e81f..e65c31e 100644 --- a/src/main/java/com/lin/sort/util/SortUtil.java +++ b/src/main/java/com/lin/sort/util/SortUtil.java @@ -2,15 +2,17 @@ package com.lin.sort.util; /** * 排序工具 + * + * @author linqiankun */ public class SortUtil { /** * 交换 * - * @param array - * @param a - * @param b + * @param array 数组 + * @param a 索引 + * @param b 索引 */ public static void swap(int[] array, int a, int b) { int temp = array[a]; @@ -21,18 +23,12 @@ public class SortUtil { /** * 比较器 * - * @param a - * @param b - * @return + * @param a 索引 + * @param b 索引 + * @return 结果,0,—1,1 */ public static int compare(int a, int b) { - if (a > b) { - return 1; - } else if (a < b) { - return -1; - } else { - return 0; - } + return Integer.compare(a, b); } } diff --git a/src/main/java/com/lin/Util/ArraySortUtil.java b/src/main/java/com/lin/util/ArraySortUtil.java similarity index 86% rename from src/main/java/com/lin/Util/ArraySortUtil.java rename to src/main/java/com/lin/util/ArraySortUtil.java index f9154eb..bfc191b 100644 --- a/src/main/java/com/lin/Util/ArraySortUtil.java +++ b/src/main/java/com/lin/util/ArraySortUtil.java @@ -1,4 +1,4 @@ -package com.lin.Util; +package com.lin.util; import lombok.extern.slf4j.Slf4j; diff --git a/src/main/java/com/lin/util/ExcelExportUtil.java b/src/main/java/com/lin/util/ExcelExportUtil.java index bd26336..458cd00 100644 --- a/src/main/java/com/lin/util/ExcelExportUtil.java +++ b/src/main/java/com/lin/util/ExcelExportUtil.java @@ -35,8 +35,9 @@ public class ExcelExportUtil { public staticRbZmL;+w$(u<
zclqh^t4DLh)3NJaw;S~OF;_iQOZMtgD_?P-8S$Zq^xcP;WS}O!Wy?lP=k6H=w&m##
z$b#I(A(MxFdb6?1asd18i_N;GYAzpJHu^%FP5$mfO~p>m-@H&Z)mL5Y#Uq!4tvLM2
zdwc3}KgrqKF}Ccw8~Wmq%b5?pbNShT_|;!6&4-*!9Dk39!M~XlLoekg%TI02`Scx^
zlRYYync|aI2P&r+cyka7UygNNa<=N}U6EBUA9^v#n@RU1zgntOY(D(y*x|{X#Q;1x
zo{zXt|73V|RYQHC>G{(GnYbZcae5co6@xwAzLv|}_?1&Eb70qO&s=yu>dcm3y>(Ay
z@}wi@CoZ|!^A{V){MJ;1Gr73c?JS1h8Fu-ieQWx*m@PTVr#kT7y8L*tQT3^foJ`*C
zSe+o&x=-=zA%8L0fVkzThw`y29-I0h2WPhUe8n{Py?SzWcz@YDR}+6|9`dr|M~=!@
zz3k}4C|{I)J^RL#n~!@ql~V@t|$+re?>B-khG
zIZwV34lYbAShJUMz$G_xNIp2clh{r!;4vRt&|iHqHxA_fRLCA?Ewz$zppT9C5Zms4
zievBCT9;#YzVT5<#(a$B8y)|k`^
CJDhR$8H?s`HGla0
zv*s_Hf8l}$&N}(5FD^W1;kk>BU-Z#Mw=MemqP2_9Uwpyhe_#B?bB;LY$n(xS@BH)r
zeBNKqA9enz=g+?2D;Ioq$=OSmEj?`Mlx0Jf^)6en?1AM6Enm0%(F=cl;cqTnf8pO(
z^sU%)#po4dR$RPd)kVWE>bvM~7Y(f3edWlNm#=)m#V1~T(yB?TZe9JX)w`{pu=