这个AI的代码注释很清晰啊，不过感觉5次不够用，能不能提供一些常用的代码案例，这样我们不用问可以直接使用。

暂无描述。

我要是来一个双向冒泡排序，阁下怎么应对？
// 类名：CocktailSort
// 函数名：cocktailSort
// 函数功能：使用鸡尾酒算法对数组进行排序
// POM依赖包：无

public class CocktailSort {
    /**
     * 使用鸡尾酒算法对数组进行排序
     * @param array 要排序的数组
     */
    public static void cocktailSort(int[] array) {
        if (array == null || array.length <= 1) { // 检查数组是否为空或只有一个元素
            return; // 如果是，直接返回
        }

int left = 0; // 左边界
        int right = array.length - 1; // 右边界

while (left < right) { // 当左边界小于右边界时
            boolean swapped = false; // 标记是否有元素交换

for (int i = left; i < right; i++) { // 从左到右遍历，将最大的元素放到右边
                if (array[i] > array[i + 1]) { // 如果当前元素大于下一个元素
                    swap(array, i, i + 1); // 交换两个元素
                    swapped = true; // 设置交换标记为true
                }
            }

if (!swapped) { // 如果没有元素交换，说明数组已经有序
                break; // 结束排序
            }

right--; // 右边界左移一位

for (int i = right; i > left; i--) { // 从右到左遍历，将最小的元素放到左边
                if (array[i] < array[i - 1]) { // 如果当前元素小于上一个元素
                    swap(array, i, i - 1); // 交换两个元素
      swapped = true; // 设置交换标记为true
                }
            }

if (!swapped) { // 如果没有元素交换，说明数组已经有序
                break; // 结束排序
            }

left++; // 左边界右移一位
        }
    }

private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

// 函数示例
// 使用鸡尾酒算法对数组进行排序示例
// 入参：array，要排序的数组
// 出参：无
// 调用示例：
// int[] array = {4, 2, 6, 1, 3, 5};
// CocktailSort.cocktailSort(array);
// System.out.println(Arrays.toString(array));
// 输出结果：例如，对数组[4, 2, 6, 1, 3, 5]进行排序后的结果为：[1, 2, 3, 4, 5, 6]
// 则输出结果为：[1, 2, 3, 4, 5, 6]

快速排序：
// 类名：QuickSort
// 函数名：quickSort
// 函数功能：使用快速排序算法对数组进行排序
// POM依赖包：无

public class QuickSort {
    /**
     * 使用快速排序算法对数组进行排序
     * @param arr 要排序的数组
     */
    public static void quickSort(int[] arr) {
        if (arr == null || arr.length == 0) { // 检查数组是否为空或长度为0
            return; // 如果是，则直接返回
        }
        sort(arr, 0, arr.length - 1); // 调用递归函数进行排序
    }

private static void sort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high); // 将数组划分为两部分，并获取基准元素的索引
            sort(arr, low, pivotIndex - 1); // 对基准元素左边的子数组进行排序
            sort(arr, pivotIndex + 1, high); // 对基准元素右边的子数组进行排序
        }
    }

private static int partition(int[] arr, int low, int high) {
        int pivot = arr[low]; // 选择第一个元素作为基准元素
        int i = low + 1; // 从基准元素的下一个位置开始遍历数组
        int j = high;

while (i <= j) {
            while (i <= j && arr[i] <= pivot) { // 从左往右找到第一个大于基准元素的元素
                i++;
            }
            while (i <= j && arr[j] > pivot) { // 从右往左找到第一个小于等于基准元素的元素
                j--;
            }
            if (i < j) { // 如果左指针小于右指针，交换两个元素
                swap(arr, i, j);
            }
        }

swap(arr, low, j); // 将基准元素放到正确的位置

return j; // 返回基准元素的索引
    }

private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

// 函数示例
// 使用快速排序算法对数组进行排序示例
// 入参：arr，要排序的数组
// 出参：无，直接对数组进行排序
// 调用示例：
// int[] arr = {5, 2, 8, 3, 1};
// QuickSort.quickSort(arr);
// for (int num : arr) {
//     System.out.print(num + " ");
// }
// 输出结果：例如，对数组{5, 2, 8, 3, 1}进行快速排序后的结果为：1 2 3 5 8
// 则输出结果为：1 2 3 5 8
直接插入排序：
// 类名：InsertionSort
// 函数名：insertionSort
// 函数功能：使用直接插入排序算法对数组进行排序
// POM依赖包：无

public class InsertionSort {
    /**
     * 使用直接插入排序算法对数组进行排序
     * @param array 要排序的数组
     */
    public static void insertionSort(int[] array) {
        if (array == null || array.length <= 1) { // 检查数组是否为空或只有一个元素
            return; // 如果是，则直接返回
        }

for (int i = 1; i < array.length; i++) { // 从第二个元素开始遍历数组
            int key = array[i]; // 当前要插入的元素
            int j = i - 1; // 已排序部分的最后一个元素的索引

while (j >= 0 && array[j] > key) { // 将大于key的元素后移一位
                array[j + 1] = array[j];
                j--;
            }

array[j + 1] = key; // 将key插入到正确的位置
        }
    }
}

// 函数示例
// 使用直接插入排序算法对数组进行排序示例
// 入参：array，要排序的数组
// 出参：无
// 调用示例：
// int[] array = {5, 2, 8, 3, 1};
// InsertionSort.insertionSort(array);
// for (int num : array) {
//     System.out.print(num + " ");
// }
// 输出结果：例如，对数组{5, 2, 8, 3, 1}进行直接插入排序后的结果为：1 2 3 5 8
// 则输出结果为：1 2 3 5 8
今天额度用完了，下一位

简单选择排序：
// 类名：SelectionSort
// 函数名：selectionSort
// 函数功能：使用简单选择排序算法对数组进行排序
// POM依赖包：无

public class SelectionSort {
    /**
     * 使用简单选择排序算法对数组进行排序
     * @param array 要排序的数组
     */
    public static void selectionSort(int[] array) {
        if (array == null || array.length <= 1) { // 检查数组是否为空或只有一个元素，无需排序
            return;
        }

for (int i = 0; i < array.length - 1; i++) { // 遍历数组
            int minIndex = i; // 假设当前索引处的元素为最小值

for (int j = i + 1; j < array.length; j++) { // 在剩余的元素中查找最小值的索引
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }

if (minIndex != i) { // 如果最小值的索引不等于当前索引，则交换两个元素的位置
                int temp = array[i];
                array[i] = array[minIndex];
                array[minIndex] = temp;
            }
        }
    }
}

// 函数示例
// 使用简单选择排序算法对数组进行排序示例
// 入参：array，要排序的数组
// 出参：无
// 调用示例：
// int[] array = {5, 2, 8, 3, 1};
// SelectionSort.selectionSort(array);
// for (int num : array) {
//     System.out.print(num + " ");
// }
// 输出结果：例如，对数组{5, 2, 8, 3, 1}使用简单选择排序算法进行排序后的结果为：1 2 3 5 8
// 则输出结果为：1 2 3 5 8
堆排序：
// 类名：HeapSortAlgorithm
// 函数名：heapSort
// 函数功能：使用堆排序算法对数组进行排序
// POM依赖包：无

public class HeapSortAlgorithm {
    /**
     * 使用堆排序算法对数组进行排序
     * @param array 要排序的数组
     */
    public static void heapSort(int[] array) {
        int n = array.length;

// 构建最大堆
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(array, n, i);
        }

// 交换堆顶元素和最后一个元素，然后重新调整堆
        for (int i = n - 1; i >= 0; i--) {
            int temp = array[0];
            array[0] = array[i];
            array[i] = temp;

heapify(array, i, 0);
        }
    }

/**
     * 调整堆，使其满足最大堆的性质
     * @param array 堆数组
     * @param n 堆的大小
     * @param i 当前节点的索引
     */
    private static void heapify(int[] array, int n, int i) {
        int largest = i; // 初始化当前节点为最大值
        int left = 2 * i + 1; // 左子节点的索引
        int right = 2 * i + 2; // 右子节点的索引

// 如果左子节点大于当前节点，将最大值更新为左子节点
        if (left < n && array[left] > array[largest]) {
            largest = left;
        }

// 如果右子节点大于当前节点，将最大值更新为右子节点
        if (right < n && array[right] > array[largest]) {
            largest = right;
        }

// 如果最大值不是当前节点，交换当前节点和最大值，然后递归调整堆
        if (largest != i) {
            int temp = array[i];
            array[i] = array[largest];
            array[largest] = temp;

heapify(array, n, largest);
        }
    }
}

// 函数示例
// 使用堆排序算法对数组进行排序示例
// 入参：array，要排序的数组
// 出参：无
// 调用示例：
// int[] array = {4, 2, 9, 6, 1, 5};
// HeapSortAlgorithm.heapSort(array);
// for (int num : array) {
//     System.out.print(num + " ");
// }
// 输出结果：例如，对数组{4, 2, 9, 6, 1, 5}进行堆排序后的结果为：1 2 4 5 6 9
// 则输出结果为：1 2 4 5 6 9
归并排序：
// 类名：MergeSort
// 函数名：mergeSort
// 函数功能：使用归并排序算法对数组进行排序
// POM依赖包：无

public class MergeSort {
    /**
     * 使用归并排序算法对数组进行排序
     * @param arr 要排序的数组
     * @return 排序后的数组
     */
    public static int[] mergeSort(int[] arr) {
        if (arr == null || arr.length <= 1) { // 检查数组是否为空或只有一个元素
            return arr; // 如果是，则直接返回数组
        }

int mid = arr.length / 2; // 计算数组的中间位置
        int[] left = new int[mid]; // 创建左边数组
        int[] right = new int[arr.length - mid]; // 创建右边数组

// 将原始数组分割成左右两个子数组
        for (int i = 0; i < mid; i++) {
            left[i] = arr[i];
        }
        for (int i = mid; i < arr.length; i++) {
            right[i - mid] = arr[i];
        }

// 递归调用归并排序，对左右两个子数组进行排序
        left = mergeSort(left);
        right = mergeSort(right);

// 合并左右两个已排序的子数组
        return merge(left, right);
    }

/**
     * 合并左右两个已排序的子数组
     * @param left 左边已排序的子数组
     * @param right 右边已排序的子数组
     * @return 合并后的数组
     */
    private static int[] merge(int[] left, int[] right) {
        int[] merged = new int[left.length + right.length]; // 创建合并后的数组
        int i = 0, j = 0, k = 0;

// 比较左右两个子数组的元素，将较小的元素放入合并后的数组
        while (i < left.length && j < right.length) {
            if (left[i] <= right[j]) {
                merged[k++] = left[i++];
            } else {
                merged[k++] = right[j++];
            }
        }

// 将剩余的元素放入合并后的数组
        while (i < left.length) {
            merged[k++] = left[i++];
        }
        while (j < right.length) {
            merged[k++] = right[j++];
        }

return merged;
    }
}

// 函数示例
// 使用归并排序算法对数组进行排序示例
// 入参：arr，要排序的数组
// 出参：sortedArr，排序后的数组
// 调用示例：
// int[] arr = {4, 2, 1, 5, 3};
// int[] sortedArr = MergeSort.mergeSort(arr);
// for (int num : sortedArr) {
//     System.out.print(num + " ");
// }
// 输出结果：例如，对数组[4, 2, 1, 5, 3]进行归并排序后的结果为：1 2 3 4 5
// 则输出结果为：1 2 3 4 5
基数排序：
// 类名：RadixSort
// 函数名：radixSort
// 函数功能：使用基数排序算法对整数数组进行排序
// POM依赖包：无

public class RadixSort {
    /**
     * 使用基数排序算法对整数数组进行排序
     * @param arr 要排序的整数数组
     */
    public static void radixSort(int[] arr) {
        if (arr == null || arr.length == 0) { // 检查数组是否为空
            throw new IllegalArgumentException("Array cannot be null or empty"); // 抛出异常，数组不能为空
        }

int max = getMax(arr); // 获取数组中的最大值

for (int exp = 1; max / exp > 0; exp *= 10) { // 从个位开始，依次对每一位进行排序
            countingSort(arr, exp); // 使用计数排序对当前位进行排序
        }
    }

private static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) { // 遍历数组，找到最大值
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

private static void countingSort(int[] arr, int exp) {
        int n = arr.length;
        int[] output = new int[n]; // 创建临时数组存储排序结果
        int[] count = new int[10]; // 创建计数数组，用于统计每个数字出现的次数

for (int i = 0; i < n; i++) { // 初始化计数数组
            count[(arr[i] / exp) % 10]++;
        }

for (int i = 1; i < 10; i++) { // 更新计数数组，使每个元素存储的是该数字在排序结果中的最后位置
            count[i] += count[i - 1];
        }

for (int i = n - 1; i >= 0; i--) { // 从原数组末尾开始遍历，将每个元素放入临时数组中的正确位置
            output[count[(arr[i] / exp) % 10] - 1] = arr[i];
            count[(arr[i] / exp) % 10]--;
        }

for (int i = 0; i < n; i++) { // 将临时数组中的排序结果拷贝回原数组
            arr[i] = output[i];
        }
    }
}

// 函数示例
// 使用基数排序算法对整数数组进行排序示例
// 入参：arr，要排序的整数数组
// 出参：无
// 调用示例：
// int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
// RadixSort.radixSort(arr);
// for (int num : arr) {
//     System.out.print(num + " ");
// }
// 输出结果：例如，对整数数组{170, 45, 75, 90, 802, 24, 2, 66}进行基数排序后的结果为：2 24 45 66 75 90 170 802
// 则输出结果为：2 24 45 66 75 90 170 802
唉，还有1个额度，苦恼。

飞算-SoFlu软件机器人/Java FuncGPT（慧函数）代码案例

内容风险标识

评论 (8)

飞算-SoFlu软件机器人/Java FuncGPT（慧函数）代码案例 .gitee-modal { width: 500px !important; }

内容风险标识