0.整个工具的代码都在Gitee或者Github地址内
gitee：solomon-parent: 这个项目主要是总结了工作上遇到的问题以及学习一些框架用于整合例如:rabbitMq、reids、Mqtt、S3协议的文件服务器、mongodb
/**
* 对给定的列表进行排序
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparators 用于比较列表元素的比较器
* @return 排序后的列表
*/
<T> Collection<T> sort(Collection<T> list, List<Comparator<? super T>> comparators);
/**
* 对给定的列表进行排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparator 用于比较列表元素的比较器
* @param ascending 如果为 true，则进行升序排序；如果为 false，则进行降序排序
* @return 排序后的列表
*/
<T> Collection<T> sort(Collection<T> list, Comparator<? super T> comparator, boolean ascending);1.实现冒泡排序算法
/**
* 冒泡排序
*/
public class BubbleSortService implements SortService{
@Override
public <T> Collection<T> sort(Collection<T> list, Comparator<? super T> comparator, boolean ascending) {
List<T> sortedList = new ArrayList<>(list); // 创建一个副本以避免修改原始列表
boolean swapped;
int n = sortedList.size();
// 根据 ascending 参数决定是否反转比较器
if (!ascending) {
comparator = comparator.reversed(); // 如果是降序排序，反转比较器
}
do {
swapped = false;
for (int i = 1; i < n; i++) {
// 使用比较器比较相邻元素
if (comparator.compare(sortedList.get(i - 1), sortedList.get(i)) > 0) {
// 如果前一个元素大于后一个元素，则交换它们
Collections.swap(sortedList, i - 1, i);
swapped = true;
}
}
// 减少下一次遍历的范围，因为每轮遍历都会将最大的元素移动到正确的位置
n--;
} while (swapped); // 如果某轮遍历没有发生交换，说明列表已经排序完成
return sortedList; // 返回排序后的列表
}
@Override
public <T> Collection<T> sort(Collection<T> list, List<Comparator<? super T>> comparators) {
List<T> sortedList = new ArrayList<>(list); // 创建一个副本以避免修改原始列表
boolean swapped;
int n = sortedList.size();
// 创建一个复合的Comparator
Comparator<? super T> compositeComparator = null;
for (Comparator comparator : comparators) {
if (compositeComparator == null) {
compositeComparator = comparator;
} else {
compositeComparator = compositeComparator.thenComparing(comparator);
}
}
do {
swapped = false;
for (int i = 1; i < n; i++) {
// 使用复合比较器比较相邻元素
if (compositeComparator.compare(sortedList.get(i - 1), sortedList.get(i)) > 0) {
// 如果前一个元素大于后一个元素，则交换它们
Collections.swap(sortedList, i - 1, i);
swapped = true;
}
}
// 减少下一次遍历的范围，因为每轮遍历都会将最大的元素移动到正确的位置
n--;
} while (swapped); // 如果某轮遍历没有发生交换，说明列表已经排序完成
return sortedList; // 返回排序后的列表
}
}2.实现桶排序算法
/**
* 桶排序
*/
public class BucketSortService implements SortService{
@Override
public <T> Collection<T> sort(Collection<T> list, Comparator<? super T> comparator, boolean ascending) {
if (list == null || list.isEmpty()) {
return Collections.emptyList(); // 如果列表为空，直接返回空列表
}
// 找到列表中的最大值和最小值
T min = Collections.min(list, comparator);
T max = Collections.max(list, comparator);
// 计算桶的数量
int bucketCount = Math.max(1, (comparator.compare(max, min) / list.size()) + 1);
List<List<T>> buckets = new ArrayList<>(bucketCount);
for (int i = 0; i < bucketCount; i++) {
buckets.add(new ArrayList<>());
}
// 将元素分配到各个桶中
for (T element : list) {
int bucketIndex = (comparator.compare(element, min) * bucketCount) / (comparator.compare(max, min) + 1);
buckets.get(bucketIndex).add(element);
}
// 对每个桶内的元素进行排序
for (List<T> bucket : buckets) {
Collections.sort(bucket, comparator);
}
// 合并所有桶中的元素
List<T> sortedList = new ArrayList<>();
for (Collection<T> bucket : buckets) {
sortedList.addAll(bucket);
}
// 如果需要降序排序，则反转列表
if (!ascending) {
Collections.reverse(sortedList);
}
return sortedList;
}
@Override
public <T> Collection<T> sort(Collection<T> list, List<Comparator<? super T>> comparators) {
if (list == null || list.isEmpty()) {
return Collections.emptyList(); // 如果列表为空，直接返回空列表
}
// 创建一个复合的Comparator
Comparator<? super T> compositeComparator = null;
for (Comparator comparator : comparators) {
if (compositeComparator == null) {
compositeComparator = comparator;
} else {
compositeComparator = compositeComparator.thenComparing(comparator);
}
}
// 找到列表中的最大值和最小值
T min = Collections.min(list, compositeComparator);
T max = Collections.max(list, compositeComparator);
// 计算桶的数量
int bucketCount = Math.max(1, (compositeComparator.compare(max, min) / list.size()) + 1);
List<List<T>> buckets = new ArrayList<>(bucketCount);
for (int i = 0; i < bucketCount; i++) {
buckets.add(new ArrayList<>());
}
// 将元素分配到各个桶中
for (T element : list) {
int bucketIndex = (compositeComparator.compare(element, min) * bucketCount) / (compositeComparator.compare(max, min) + 1);
buckets.get(bucketIndex).add(element);
}
// 对每个桶内的元素进行排序
for (List<T> bucket : buckets) {
bucket.sort(compositeComparator);
}
// 合并所有桶中的元素
List<T> sortedList = new ArrayList<>();
for (Collection<T> bucket : buckets) {
sortedList.addAll(bucket);
}
return sortedList;
}
}3.实现堆排序算法
/**
* 堆排序
*/
public class HeapSortService implements SortService{
@Override
public <T> Collection<T> sort(Collection<T> list, Comparator<? super T> comparator, boolean ascending) {
int n = list.size();
List<T> data = new ArrayList<>(list);
// 构建最大堆
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(data, i, n, comparator);
}
// 一个一个地从堆中取出元素
for (int i = n - 1; i >= 0; i--) {
swap(data, 0, i);
// 重新对堆进行调整
heapify(data, 0, i, comparator);
}
// 如果需要升序排序，我们需要反转列表
if (!ascending) {
List<T> reversed = new ArrayList<>(data);
for (int i = 0; i < data.size(); i++) {
data.set(i, reversed.get(data.size() - 1 - i));
}
}
return data;
}
@Override
public <T> Collection<T> sort(Collection<T> list, List<Comparator<? super T>> comparators) {
int n = list.size();
List<T> data = new ArrayList<>(list);
// 创建一个复合的Comparator
Comparator<? super T> compositeComparator = null;
for (Comparator comparator : comparators) {
if (compositeComparator == null) {
compositeComparator = comparator;
} else {
compositeComparator = compositeComparator.thenComparing(comparator);
}
}
// 构建最大堆
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(data, i, n, compositeComparator);
}
// 一个一个地从堆中取出元素
for (int i = n - 1; i >= 0; i--) {
swap(data, 0, i);
// 重新对堆进行调整
heapify(data, 0, i, compositeComparator);
}
return data;
}
private static <T> void heapify(List<T> list, int i, int n, Comparator<? super T> comparator) {
int largest = i; // 初始化最大值为根节点
int left = 2 * i + 1; // 左子节点
int right = 2 * i + 2; // 右子节点
// 如果左子节点在范围内且大于根节点
if (left < n && comparator.compare(list.get(left), list.get(largest)) > 0) {
largest = left;
}
// 如果右子节点在范围内且大于当前最大值
if (right < n && comparator.compare(list.get(right), list.get(largest)) > 0) {
largest = right;
}
// 如果最大值不是根节点
if (largest != i) {
swap(list, i, largest);
// 递归地调整受影响的子树
heapify(list, largest, n, comparator);
}
}
private static <T> void swap(List<T> list, int i, int j) {
T temp = list.get(i);
list.set(i, list.get(j));
list.set(j, temp);
}
}4.插入排序算法
/**
* 插入排序
*/
public class InsertionSortService implements SortService{
@Override
public <T> Collection<T> sort(Collection<T> list, Comparator<? super T> comparator, boolean ascending) {
List<T> sortedList = new ArrayList<>(list); // 创建一个副本以避免修改原始列表
int n = sortedList.size();
// 根据 ascending 参数决定是否反转比较器
if (!ascending) {
comparator = comparator.reversed(); // 如果是降序排序，反转比较器
}
for (int i = 1; i < n; i++) {
T key = sortedList.get(i);
int j = i - 1;
// 将比 key 大的元素都向右移动
while (j >= 0 && comparator.compare(sortedList.get(j), key) > 0) {
sortedList.set(j + 1, sortedList.get(j));
j--;
}
// 插入 key 到正确的位置
sortedList.set(j + 1, key);
}
return sortedList; // 返回排序后的列表
}
@Override
public <T> Collection<T> sort(Collection<T> list, List<Comparator<? super T>> comparators) {
List<T> sortedList = new ArrayList<>(list); // 创建一个副本以避免修改原始列表
int n = sortedList.size();
// 创建一个复合的Comparator
Comparator<? super T> compositeComparator = null;
for (Comparator comparator : comparators) {
if (compositeComparator == null) {
compositeComparator = comparator;
} else {
compositeComparator = compositeComparator.thenComparing(comparator);
}
}
for (int i = 1; i < n; i++) {
T key = sortedList.get(i);
int j = i - 1;
// 将比 key 大的元素都向右移动
while (j >= 0 && compositeComparator.compare(sortedList.get(j), key) > 0) {
sortedList.set(j + 1, sortedList.get(j));
j--;
}
// 插入 key 到正确的位置
sortedList.set(j + 1, key);
}
return sortedList; // 返回排序后的列表
}
}5.归并排序算法
/**
* 归并排序
*/
public class MergeSortService implements SortService{
@Override
public <T> Collection<T> sort(Collection<T> list, Comparator<? super T> comparator, boolean ascending) {
if (list.size() <= 1) {
return list;
}
List<T> data = new ArrayList<>(list);
// 分割列表
int middle = list.size() / 2;
Collection<T> left = new ArrayList<>(data.subList(0, middle));
Collection<T> right = new ArrayList<>(data.subList(middle, list.size()));
// 递归排序左右两部分
left = sort(left, comparator, ascending);
right = sort(right, comparator, ascending);
// 合并排序后的左右两部分
return merge((List)left, (List)right, comparator, ascending);
}
@Override
public <T> Collection<T> sort(Collection<T> list, List<Comparator<? super T>> comparators) {
if (list.size() <= 1) {
return list;
}
List<T> data = new ArrayList<>(list);
// 分割列表
int middle = list.size() / 2;
Collection<T> left = new ArrayList<>(data.subList(0, middle));
Collection<T> right = new ArrayList<>(data.subList(middle, list.size()));
// 递归排序左右两部分
left = sort(left, comparators);
right = sort(right, comparators);
// 合并排序后的左右两部分
return merge((List<T>) left, (List<T>) right, comparators);
}
private static <T> Collection<T> merge(List<T> left, List<T> right, List<Comparator<? super T>> comparators) {
List<T> result = new ArrayList<>();
int leftIndex = 0;
int rightIndex = 0;
// 创建一个复合的Comparator
Comparator<? super T> compositeComparator = null;
for (Comparator comparator : comparators) {
if (compositeComparator == null) {
compositeComparator = comparator;
} else {
compositeComparator = compositeComparator.thenComparing(comparator);
}
}
// 合并两个有序列表
while (leftIndex < left.size() && rightIndex < right.size()) {
if (compositeComparator.compare(left.get(leftIndex), right.get(rightIndex)) <= 0) {
result.add(left.get(leftIndex));
leftIndex++;
} else {
result.add(right.get(rightIndex));
rightIndex++;
}
}
// 添加剩余的元素
while (leftIndex < left.size()) {
result.add(left.get(leftIndex));
leftIndex++;
}
while (rightIndex < right.size()) {
result.add(right.get(rightIndex));
rightIndex++;
}
return result;
}
private static <T> Collection<T> merge(List<T> left, List<T> right, Comparator<? super T> comparator, boolean ascending) {
List<T> result = new ArrayList<>();
int leftIndex = 0;
int rightIndex = 0;
// 合并两个有序列表
while (leftIndex < left.size() && rightIndex < right.size()) {
int comparison = comparator.compare(left.get(leftIndex), right.get(rightIndex));
if (ascending ? comparison <= 0 : comparison >= 0) {
result.add(left.get(leftIndex));
leftIndex++;
} else {
result.add(right.get(rightIndex));
rightIndex++;
}
}
// 添加剩余的元素
while (leftIndex < left.size()) {
result.add(left.get(leftIndex));
leftIndex++;
}
while (rightIndex < right.size()) {
result.add(right.get(rightIndex));
rightIndex++;
}
return result;
}
}6.快速排序算法
/**
* 快速排序
*/
public class QuickSortService implements SortService{
@Override
public <T> Collection<T> sort(Collection<T> list, Comparator<? super T> comparator, boolean ascending) {
List<T> sortedList = new ArrayList<>(list); // 创建一个副本以避免修改原始列表
// 根据 ascending 参数决定是否反转比较器
if (!ascending) {
comparator = comparator.reversed(); // 如果是降序排序，反转比较器
}
quickSortHelper(sortedList, 0, sortedList.size() - 1, comparator);
return sortedList; // 返回排序后的列表
}
@Override
public <T> Collection<T> sort(Collection<T> list, List<Comparator<? super T>> comparators) {
List<T> sortedList = new ArrayList<>(list); // 创建一个副本以避免修改原始列表
// 创建一个复合的Comparator
Comparator<? super T> compositeComparator = null;
for (Comparator comparator : comparators) {
if (compositeComparator == null) {
compositeComparator = comparator;
} else {
compositeComparator = compositeComparator.thenComparing(comparator);
}
}
quickSortHelper(sortedList, 0, sortedList.size() - 1, compositeComparator);
return sortedList; // 返回排序后的列表
}
private static <T> void quickSortHelper(List<T> list, int low, int high, Comparator<? super T> comparator) {
if (low < high) {
int pivotIndex = partition(list, low, high, comparator);
quickSortHelper(list, low, pivotIndex - 1, comparator);
quickSortHelper(list, pivotIndex + 1, high, comparator);
}
}
private static <T> int partition(List<T> list, int low, int high, Comparator<? super T> comparator) {
T pivot = list.get(high); // 选择高位为基准
int i = low - 1; // 指定小于基准的区域
for (int j = low; j < high; j++) {
if (comparator.compare(list.get(j), pivot) <= 0) {
i++;
swap(list, i, j);
}
}
swap(list, i + 1, high); // 将基准元素放置在正确位置
return i + 1;
}
private static <T> void swap(List<T> list, int i, int j) {
T temp = list.get(i);
list.set(i, list.get(j));
list.set(j, temp);
}
}7.选择排序算法
/**
* 选择排序
*/
public class SelectionSortService implements SortService{
@Override
public <T> Collection<T> sort(Collection<T> list, Comparator<? super T> comparator, boolean ascending) {
List<T> sortedList = new ArrayList<>(list); // 创建一个副本以避免修改原始列表
int n = sortedList.size();
// 根据 ascending 参数决定是否反转比较器
if (!ascending) {
comparator = comparator.reversed(); // 如果是降序排序，反转比较器
}
for (int i = 0; i < n - 1; i++) {
int selectedIndex = i;
for (int j = i + 1; j < n; j++) {
// 使用比较器比较元素
if (comparator.compare(sortedList.get(j), sortedList.get(selectedIndex)) < 0) {
selectedIndex = j; // 找到更小（或更大）的元素索引
}
}
// 交换 selectedIndex 和 i 位置上的元素
if (selectedIndex != i) {
T temp = sortedList.get(selectedIndex);
sortedList.set(selectedIndex, sortedList.get(i));
sortedList.set(i, temp);
}
}
return sortedList; // 返回排序后的列表
}
@Override
public <T> Collection<T> sort(Collection<T> list, List<Comparator<? super T>> comparators) {
List<T> sortedList = new ArrayList<>(list); // 创建一个副本以避免修改原始列表
int n = sortedList.size();
// 创建一个复合的Comparator
Comparator<? super T> compositeComparator = null;
for (Comparator comparator : comparators) {
if (compositeComparator == null) {
compositeComparator = comparator;
} else {
compositeComparator = compositeComparator.thenComparing(comparator);
}
}
for (int i = 0; i < n - 1; i++) {
int selectedIndex = i;
for (int j = i + 1; j < n; j++) {
// 使用复合比较器比较元素
if (compositeComparator.compare(sortedList.get(j), sortedList.get(selectedIndex)) < 0) {
selectedIndex = j; // 找到更小（或更大）的元素索引
}
}
// 交换 selectedIndex 和 i 位置上的元素
if (selectedIndex != i) {
T temp = sortedList.get(selectedIndex);
sortedList.set(selectedIndex, sortedList.get(i));
sortedList.set(i, temp);
}
}
return sortedList; // 返回排序后的列表
}
}8.希尔排序算法
/**
* 希尔排序
*/
public class ShellSortService implements SortService{
@Override
public <T> Collection<T> sort(Collection<T> list, Comparator<? super T> comparator, boolean ascending) {
// 创建列表的副本，以避免修改原始列表
List<T> sortedList = new ArrayList<>(list);
// 初始化间隔gap为列表大小的一半
int gap = sortedList.size() / 2;
// 逐步减小间隔，直到gap为0
while (gap > 0) {
// 从gap位置开始遍历列表
for (int i = gap; i < sortedList.size(); i++) {
T temp = sortedList.get(i);
int j = i;
// 根据ascending参数判断排序顺序
if (ascending) {
// 升序排序
while (j >= gap && comparator.compare(sortedList.get(j - gap), temp) > 0) {
sortedList.set(j, sortedList.get(j - gap));
j -= gap;
}
} else {
// 降序排序
while (j >= gap && comparator.compare(sortedList.get(j - gap), temp) < 0) {
sortedList.set(j, sortedList.get(j - gap));
j -= gap;
}
}
sortedList.set(j, temp);
}
// 缩小间隔
gap /= 2;
}
// 返回排序后的列表
return sortedList;
}
@Override
public <T> Collection<T> sort(Collection<T> list, List<Comparator<? super T>> comparators) {
// 创建列表的副本，以避免修改原始列表
List<T> sortedList = new ArrayList<>(list);
// 初始化间隔gap为列表大小的一半
int gap = sortedList.size() / 2;
// 创建一个复合的Comparator
Comparator<? super T> compositeComparator = null;
for (Comparator comparator : comparators) {
if (compositeComparator == null) {
compositeComparator = comparator;
} else {
compositeComparator = compositeComparator.thenComparing(comparator);
}
}
// 逐步减小间隔，直到gap为0
while (gap > 0) {
// 从gap位置开始遍历列表
for (int i = gap; i < sortedList.size(); i++) {
T temp = sortedList.get(i);
int j = i;
// 使用复合比较器进行比较
while (j >= gap && compositeComparator.compare(sortedList.get(j - gap), temp) > 0) {
sortedList.set(j, sortedList.get(j - gap));
j -= gap;
}
sortedList.set(j, temp);
}
// 缩小间隔
gap /= 2;
}
// 返回排序后的列表
return sortedList;
}
}9.实现排序工具类
public class SortUtil {
private static BubbleSortService bubbleSortService = new BubbleSortService();
private static BucketSortService bucketSortService = new BucketSortService();
private static HeapSortService heapSortService = new HeapSortService();
private static InsertionSortService insertionSortService = new InsertionSortService();
private static MergeSortService mergeSortService = new MergeSortService();
private static QuickSortService quickSortService = new QuickSortService();
private static SelectionSortService selectionSortService = new SelectionSortService();
private static ShellSortService shellSortService = new ShellSortService();
/**
* 对给定的列表进行冒泡排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparatorList 用于比较列表元素的比较器
* @return 排序后的列表
*/
public static <T> Collection<T> bubbleSort(Collection<T> list, Comparator<? super T>... comparatorList){
return bubbleSortService.sort(list, Arrays.asList(comparatorList));
}
/**
* 对给定的列表进行桶排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparatorList 用于比较列表元素的比较器
* @return 排序后的列表
*/
public static <T> Collection<T> bucketSort(Collection<T> list, Comparator<? super T>... comparatorList){
return bucketSortService.sort(list,Arrays.asList(comparatorList));
}
/**
* 对给定的列表进行堆排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparatorList 用于比较列表元素的比较器
* @return 排序后的列表
*/
public static <T> Collection<T> heapSort(Collection<T> list, Comparator<? super T>... comparatorList){
return heapSortService.sort(list,Arrays.asList(comparatorList));
}
/**
* 对给定的列表进行插入排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparatorList 用于比较列表元素的比较器
* @return 排序后的列表
*/
public static <T> Collection<T> insertionSort(Collection<T> list, Comparator<? super T>... comparatorList){
return insertionSortService.sort(list,Arrays.asList(comparatorList));
}
/**
* 对给定的列表进行归并排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparatorList 用于比较列表元素的比较器
* @return 排序后的列表
*/
public static <T> Collection<T> mergeSort(Collection<T> list, Comparator<? super T>... comparatorList){
return mergeSortService.sort(list,Arrays.asList(comparatorList));
}
/**
* 对给定的列表进行快速排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparatorList 用于比较列表元素的比较器
* @return 排序后的列表
*/
public static <T> Collection<T> quickSort(Collection<T> list, Comparator<? super T>... comparatorList){
return quickSortService.sort(list,Arrays.asList(comparatorList));
}
/**
* 对给定的列表进行选择排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparatorList 用于比较列表元素的比较器
* @return 排序后的列表
*/
public static <T> Collection<T> selectionSort(Collection<T> list, Comparator<? super T>... comparatorList){
return selectionSortService.sort(list,Arrays.asList(comparatorList));
}
/**
* 对给定的列表进行希尔排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparatorList 用于比较列表元素的比较器
* @return 排序后的列表
*/
public static <T> Collection<T> shellSort(Collection<T> list, Comparator<? super T>... comparatorList){
return shellSortService.sort(list,Arrays.asList(comparatorList));
}
/**
* 对给定的列表进行冒泡排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparator 用于比较列表元素的比较器
* @param ascending 如果为 true，则进行升序排序；如果为 false，则进行降序排序
* @return 排序后的列表
*/
public static <T> Collection<T> bubbleSort(Collection<T> list, Comparator<? super T> comparator, boolean ascending){
return bubbleSortService.sort(list,comparator,ascending);
}
/**
* 对给定的列表进行桶排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparator 用于比较列表元素的比较器
* @param ascending 如果为 true，则进行升序排序；如果为 false，则进行降序排序
* @return 排序后的列表
*/
public static <T> Collection<T> bucketSort(Collection<T> list, Comparator<? super T> comparator, boolean ascending){
return bucketSortService.sort(list,comparator,ascending);
}
/**
* 对给定的列表进行堆排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparator 用于比较列表元素的比较器
* @param ascending 如果为 true，则进行升序排序；如果为 false，则进行降序排序
* @return 排序后的列表
*/
public static <T> Collection<T> heapSort(Collection<T> list, Comparator<? super T> comparator, boolean ascending){
return heapSortService.sort(list,comparator,ascending);
}
/**
* 对给定的列表进行插入排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparator 用于比较列表元素的比较器
* @param ascending 如果为 true，则进行升序排序；如果为 false，则进行降序排序
* @return 排序后的列表
*/
public static <T> Collection<T> insertionSort(Collection<T> list, Comparator<? super T> comparator, boolean ascending){
return insertionSortService.sort(list,comparator,ascending);
}
/**
* 对给定的列表进行归并排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparator 用于比较列表元素的比较器
* @param ascending 如果为 true，则进行升序排序；如果为 false，则进行降序排序
* @return 排序后的列表
*/
public static <T> Collection<T> mergeSort(Collection<T> list, Comparator<? super T> comparator, boolean ascending){
return mergeSortService.sort(list,comparator,ascending);
}
/**
* 对给定的列表进行快速排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparator 用于比较列表元素的比较器
* @param ascending 如果为 true，则进行升序排序；如果为 false，则进行降序排序
* @return 排序后的列表
*/
public static <T> Collection<T> quickSort(Collection<T> list, Comparator<? super T> comparator, boolean ascending){
return quickSortService.sort(list,comparator,ascending);
}
/**
* 对给定的列表进行选择排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparator 用于比较列表元素的比较器
* @param ascending 如果为 true，则进行升序排序；如果为 false，则进行降序排序
* @return 排序后的列表
*/
public static <T> Collection<T> selectionSort(Collection<T> list, Comparator<? super T> comparator, boolean ascending){
return selectionSortService.sort(list,comparator,ascending);
}
/**
* 对给定的列表进行希尔排序，支持升序和降序排序。
*
* @param <T> 列表元素的类型
* @param list 要排序的列表
* @param comparator 用于比较列表元素的比较器
* @param ascending 如果为 true，则进行升序排序；如果为 false，则进行降序排序
* @return 排序后的列表
*/
public static <T> Collection<T> shellSort(Collection<T> list, Comparator<? super T> comparator, boolean ascending){
return shellSortService.sort(list,comparator,ascending);
}
}10.测试方法
public static void main(String[] args) {
Set<Integer> a = new HashSet<>();
for(Integer i = 0;i<=20;i++){
a.add(Integer.valueOf((int) (Math.random()*100)));
}
List<Person> b = new ArrayList<>();
b.add(new Person("1",1));
b.add(new Person("2",2));
System.out.println("冒泡排序算法：降序:"+ SortUtil.bubbleSort(b,Comparator.comparing(Person::getName).reversed(),Comparator.comparing(Person::getAge).reversed()));
System.out.println("桶排序算法: 降序:"+ SortUtil.bucketSort(b,Comparator.comparing(Person::getName).reversed(),Comparator.comparing(Person::getAge).reversed()));
System.out.println("堆排序算法: 降序:"+ SortUtil.heapSort(b,Comparator.comparing(Person::getName).reversed(),Comparator.comparing(Person::getAge).reversed()));
System.out.println("插入排序算法：降序:"+ SortUtil.insertionSort(b,Comparator.comparing(Person::getName).reversed(),Comparator.comparing(Person::getAge).reversed()));
System.out.println("归并排序算法：降序:"+ SortUtil.mergeSort(b,Comparator.comparing(Person::getName).reversed(),Comparator.comparing(Person::getAge).reversed()));
System.out.println("快速排序算法：降序:"+ SortUtil.quickSort(b,Comparator.comparing(Person::getName).reversed(),Comparator.comparing(Person::getAge).reversed()));
System.out.println("选择排序算法：降序:"+ SortUtil.selectionSort(b,Comparator.comparing(Person::getName).reversed(),Comparator.comparing(Person::getAge).reversed()));
System.out.println("希尔排序算法：降序:"+ SortUtil.shellSort(b,Comparator.comparing(Person::getName).reversed(),Comparator.comparing(Person::getAge).reversed()));
System.out.println("===================================");
System.out.println("冒泡排序算法：升序:"+ SortUtil.bubbleSort(b,Comparator.comparing(Person::getName),Comparator.comparing(Person::getAge)));
System.out.println("桶排序算法: 升序:"+ SortUtil.bucketSort(b,Comparator.comparing(Person::getName),Comparator.comparing(Person::getAge)));
System.out.println("堆排序算法: 升序:"+ SortUtil.heapSort(b,Comparator.comparing(Person::getName),Comparator.comparing(Person::getAge)));
System.out.println("插入排序算法：升序:"+ SortUtil.insertionSort(b,Comparator.comparing(Person::getName),Comparator.comparing(Person::getAge)));
System.out.println("归并排序算法：升序:"+ SortUtil.mergeSort(b,Comparator.comparing(Person::getName),Comparator.comparing(Person::getAge)));
System.out.println("快速排序算法：升序:"+ SortUtil.quickSort(b,Comparator.comparing(Person::getName),Comparator.comparing(Person::getAge)));
System.out.println("选择排序算法：升序:"+ SortUtil.selectionSort(b,Comparator.comparing(Person::getName),Comparator.comparing(Person::getAge)));
System.out.println("希尔排序算法：升序:"+ SortUtil.shellSort(b,Comparator.comparing(Person::getName),Comparator.comparing(Person::getAge)));
}
static class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}11.测试结果
冒泡排序算法：降序:[Person{name='2', age=2}, Person{name='1', age=1}]
桶排序算法: 降序:[Person{name='2', age=2}, Person{name='1', age=1}]
堆排序算法: 降序:[Person{name='2', age=2}, Person{name='1', age=1}]
插入排序算法：降序:[Person{name='2', age=2}, Person{name='1', age=1}]
归并排序算法：降序:[Person{name='2', age=2}, Person{name='1', age=1}]
快速排序算法：降序:[Person{name='2', age=2}, Person{name='1', age=1}]
选择排序算法：降序:[Person{name='2', age=2}, Person{name='1', age=1}]
希尔排序算法：降序:[Person{name='2', age=2}, Person{name='1', age=1}]
===================================
冒泡排序算法：升序:[Person{name='1', age=1}, Person{name='2', age=2}]
桶排序算法: 升序:[Person{name='1', age=1}, Person{name='2', age=2}]
堆排序算法: 升序:[Person{name='1', age=1}, Person{name='2', age=2}]
插入排序算法：升序:[Person{name='1', age=1}, Person{name='2', age=2}]
归并排序算法：升序:[Person{name='1', age=1}, Person{name='2', age=2}]
快速排序算法：升序:[Person{name='1', age=1}, Person{name='2', age=2}]
选择排序算法：升序:[Person{name='1', age=1}, Person{name='2', age=2}]
希尔排序算法：升序:[Person{name='1', age=1}, Person{name='2', age=2}]
12.测试一百万数据耗时：
============多字段排序算法降序开始=======================
总记录数:1000000排序测试
冒泡排序算法：降序耗时:13582秒
桶排序算法: 降序耗时:0秒
堆排序算法: 降序耗时:1秒
插入排序算法：降序耗时:14144秒
归并排序算法：降序耗时:0秒
快速排序算法：降序耗时:2秒
选择排序算法：降序耗时:13388秒
希尔排序算法：降序耗时:1秒
417
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
