Java排序方法及效率测试
为了方便测试，排序方法必须实现该接口。
public interface SortMethod { int[] sortAlgorithm(int[] data); default void swap(int[] data, int i, int j) { int temp = data[i]; data[i] = data[j]; data[j] = temp; } }
排序方法：
1、冒泡排序法
package arithmetic.sort_method; import arithmetic.test_environment.strategy.SortMethod; public class BubbleSort implements SortMethod { public int[] sortAlgorithm(int[] data) { int temp = 0; for (int i = 1; i < data.length; i++) { for (int j = 0; j < data.length - i; j++) { if (data[j] > data[j + 1]) { swap(data, j, j + 1); } } } return data; } }
2、选择排序
package arithmetic.sort_method; import arithmetic.test_environment.strategy.SortMethod; public class SelectSort implements SortMethod { @Override public int[] sortAlgorithm(int[] data) { int min,temp; for (int i = 0; i < data.length - 1; i++){ min = i; for (int k = i + 1; k < data.length; k++){ if (data[min] > data[k]) min = k; } if (min != i){ swap(data, min, i); } } return data; } }
3、插入排序
package arithmetic.sort_method; import arithmetic.test_environment.strategy.SortMethod; public class InsertSort implements SortMethod { @Override public int[] sortAlgorithm(int[] data) { int k,temp; for (int i = 1;i < data.length; i++){ temp = data[i]; k = i; while (k > 0 && temp < data[k - 1]){ data[k] = data[k - 1]; k--; } if (k != i){ data[k] = temp; } } return data; } }
4、希尔排序
package arithmetic.sort_method; import arithmetic.test_environment.strategy.SortMethod; public class ShellSort implements SortMethod { @Override public int[] sortAlgorithm(int[] data) { int step = 1; while (step < data.length) { step = step * 3 + 1; } int k,temp; while (step > 0) { for (int i = step; i < data.length; i++) { //括号内是一个插入排序 temp = data[i]; k = i; while (k >= step && temp < data[k - step]) { data[k] = data[k - step]; k -= step; } if (k != i) data[k] = temp; } step = (int) Math.floor(step / 3); } return data; } }
5、归并排序
package arithmetic.sort_method; import arithmetic.test_environment.strategy.SortMethod; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; public class MergeSort implements SortMethod { @Override public int[] sortAlgorithm(int[] data) { mergeSort(data, 0, data.length - 1); return data; } private void mergeSort(int[] data, int low, int high){ if (low < high){ int middle = (low + high) / 2; mergeSort(data,low,middle); mergeSort(data,middle + 1, high); merge(data,low,middle,high); } } @ParameterizedTest @MethodSource("arithmetic.test_method.ProvideData#provideSourceData") public void merge(int[] data, int start, int middle, int end){ int[] temp = new int[end - start + 1]; int low = start; int high = middle + 1; int index = 0; while (low <= middle && high <= end){ if (data[low] <= data[high]){ temp[index] = data[low]; low++; } else { temp[index] = data[high]; high++; } index++; } while (low <= middle){ temp[index] = data[low]; low++; index++; } while (high <= end){ temp[index] = data[high]; high++; index++; } for (int i = 0; i < temp.length; i++){ data[start] = temp[i]; start++; } } }
6、单指针快速排序
package arithmetic.sort_method.quick_sort; import arithmetic.test_environment.strategy.SortMethod; public class QuickSortSingleNeedle implements SortMethod { @Override public int[] sortAlgorithm(int[] data) { return quickSort(data,0,data.length); } private int[] quickSort(int[] data, int left, int right) { //递归约束 if (left < right) { int partitionIndex = partition(data, left, right); quickSort(data, left, partitionIndex); quickSort(data, partitionIndex + 1, right); } return data; } private int partition(int[] data, int left, int right) { // 设定基准值（pivot） int pivot = left; int index = pivot + 1; for (int i = index; i < right; i++) { if (data[i] < data[pivot]) { swap(data, i, index); index++; } } swap(data, pivot, index - 1); return index - 1; } }
7、双指针快速排序
package arithmetic.sort_method.quick_sort; import arithmetic.test_environment.strategy.SortMethod; public class QuickSortDoubleNeedle implements SortMethod { @Override public int[] sortAlgorithm(int[] data) { return quickSort(data,0,data.length -1); } private int[] quickSort(int[] data, int start, int end) { if (start < end){ int partition = partition(data, start, end); quickSort(data,start,partition); quickSort(data,partition + 1,end); } return data; } private int partition(int[] data, int start, int end){ int left = start; int right = end; int pivot = data[left]; while (left < right) { while (right > left && data[right] >= pivot) { right--; } data[left] = data[right]; while (right > left && data[left] <= pivot) { left++; } data[right] = data[left]; } data[left] = pivot; return left; } }
8、堆排序
package arithmetic.sort_method; import arithmetic.test_environment.strategy.SortMethod; public class HeapSort implements SortMethod { @Override public int[] sortAlgorithm(int[] data) { int size = data.length - 1; int start = size / 2; for (int i = start; i >= 0; i--){ MaxHeap(data, data.length, i); } for (int i = size; i > 0; i--){ swap(data, 0 ,i); MaxHeap(data, i, 0); } return data; } private void MaxHeap(int[] data, int size, int index){ int leftNode = 2 * index + 1; int rightNode = 2 * index + 2; int max = index; if (leftNode < size && data[max] < data[leftNode]) max = leftNode; if (rightNode < size && data[max] < data[rightNode]) max = rightNode; if (max != index){ swap(data, max, index); MaxHeap(data, size, max); } } }
9、计数排序
package arithmetic.sort_method; import arithmetic.test_environment.strategy.SortMethod; public class CountSort implements SortMethod { @Override public int[] sortAlgorithm(int[] data) { int maxValue = getMaxValue(data); return countingSort(data, maxValue); } 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; } private int getMaxValue(int[] arr) { int maxValue = arr[0]; for (int value : arr) { if (maxValue < value) { maxValue = value; } } return maxValue; } }
10、桶排序
package arithmetic.sort_method; import arithmetic.test_environment.strategy.SortMethod; import java.util.Arrays; public class BucketSort implements SortMethod { private static final SortMethod sortMethod = new InsertSort(); @Override public int[] sortAlgorithm(int[] data) { try { bucketSort(data, 100); } catch (Exception e) { e.printStackTrace(); } return data; } 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 = sortMethod.sortAlgorithm(bucket); for (int value : bucket) { arr[arrIndex++] = value; } } return arr; } private int[] arrAppend(int[] arr, int value) { arr = Arrays.copyOf(arr, arr.length + 1); arr[arr.length - 1] = value; return arr; } }
11、基数排序
package arithmetic.sort_method; import arithmetic.test_environment.strategy.SortMethod; import java.util.Arrays; public class RadixSort implements SortMethod { @Override public int[] sortAlgorithm(int[] data) { int maxBit = getMaxBit(data); return radixSort(data, maxBit); } private int[] radixSort(int[] data, int max) { int mod = 10; int dev = 1; int index; for (int i = 0; i < max; i++, dev *= 10, mod *= 10){ //乘以2是用于处理负数情况 int[][] queues = new int[10 * 2][0]; for (int k = 0; k < data.length; k++){ index = data[k] % mod / dev + 10; queues[index] = queueAppend(queues[index],data[k]); } index = 0; for (int[] queue : queues){ for (int value : queue){ data[index] = value; index++; } } } return data; } private int getMaxBit(int data[]){ int max = 0; for (int k = 1; k < data.length; k++){ if (data[max] < data[k]) max = k; } return (data[max] + "").length(); } private int[] queueAppend(int[] queue, int value) { queue = Arrays.copyOf(queue, queue.length + 1); queue[queue.length - 1] = value; return queue; } }
测试方法：
