用java写一个计数排序

### 回答1：
好的，以下是使用 Java 编写的计数排序算法示例：

public class CountingSort {
    public static void countingSort(int[] array, int k) {
        int[] counts = new int[k+1];
        int[] output = new int[array.length];

        // 计数
        for (int i = 0; i < array.length; i++) {
            counts[array[i]]++;
        }

        // 累加计数
        for (int i = 1; i <= k; i++) {
            counts[i] += counts[i-1];
        }

        // 排序
        for (int i = array.length - 1; i >= 0; i--) {
            output[counts[array[i]]-1] = array[i];
            counts[array[i]]--;
        }

        // 拷贝到原数组
        System.arraycopy(output, 0, array, 0, array.length);
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 6, 2, 8};
        int k = 8;
        countingSort(arr, k);

        System.out.println(Arrays.toString(arr));
    }
}

解释如下：

1. 首先，定义一个 `countingSort` 方法，它接受一个整型数组 `array` 和一个整数 `k` 作为输入。

2. 在方法中，创建一个长度为 `k+1` 的 `counts` 数组，和一个与 `array` 相同长度的 `output` 数组。

3. 遍历 `array` 数组，并对每个元素进行计数，将计数结果保存在 `counts` 数组中。

4. 对 `counts` 数组进行累加计数，从第二个元素开始，将当前元素与前一个元素相加，得到前缀和。

5. 倒序遍历 `array` 数组，并根据 `counts` 数组中的值将每个元素放入 `output` 数组中相应的位置。

6. 将 `output` 数组拷贝回 `array` 数组中。

7. 最后，在 `main` 方法中调用 `countingSort` 方法，并输出排序后的结果。

这样就完成了一个简单的计数排序算法的 Java 实现。

### 回答2：
计数排序是一种非常简单且高效的排序算法。它适用于一定范围内的整数排序。

Java代码实现计数排序如下：

public class CountingSort {
    public static void countingSort(int[] array) {
        int max = getMaxValue(array);
        int[] countArray = new int[max + 1];

        for (int num : array) {
            countArray[num]++;
        }

        int outputIndex = 0;
        for (int i = 0; i < countArray.length; i++) {
            while (countArray[i] > 0) {
                array[outputIndex++] = i;
                countArray[i]--;
            }
        }
    }

    private static int getMaxValue(int[] array) {
        int max = array[0];
        for (int num : array) {
            if (num > max) {
                max = num;
            }
        }
        return max;
    }

    public static void main(String[] args) {
        int[] array = {4, 2, 2, 8, 3, 3, 1};
        countingSort(array);

        System.out.println("排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

这段代码定义了一个名为`CountingSort`的类，其中包含了一个静态方法`countingSort`来实现计数排序。首先，我们找出原始数组中的最大值，然后创建一个计数数组`countArray`，数组长度是最大值加一。接下来，我们遍历原始数组，将每个元素作为索引在计数数组对应位置加一。接着，根据计数数组的内容，我们重新按顺序填充原始数组。最后，我们可以通过调用`countingSort`方法，并传入待排序的数组，输出排序结果。

以上是用Java实现计数排序的代码和说明，希望能帮到您！

### 回答3：
计数排序是一种非比较排序算法，适用于一定范围内的整数排序。下面是使用Java语言实现计数排序的代码：

public class CountingSort {

    public static void countingSort(int[] array) {
        if (array.length == 0) {
            return;
        }

        // 找出数组中的最大值和最小值
        int min = array[0];
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            } else if (array[i] > max) {
                max = array[i];
            }
        }

        // 创建计数数组，并初始化为0
        int[] count = new int[max - min + 1];
        for (int i = 0; i < count.length; i++) {
            count[i] = 0;
        }

        // 统计每个元素的出现次数
        for (int i = 0; i < array.length; i++) {
            count[array[i] - min]++;
        }

        // 对计数数组进行顺序求和
        for (int i = 1; i < count.length; i++) {
            count[i] += count[i - 1];
        }

        // 创建临时数组，存储排序结果
        int[] sortedArray = new int[array.length];
        for (int i = array.length - 1; i >= 0; i--) {
            sortedArray[count[array[i] - min] - 1] = array[i];
            count[array[i] - min]--;
        }

        // 将临时数组拷贝回原始数组
        for (int i = 0; i < array.length; i++) {
            array[i] = sortedArray[i];
        }
    }

    public static void main(String[] args) {
        int[] array = {5, 7, 3, 2, 6, 4, 1};
        countingSort(array);

        System.out.print("排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

以上的代码通过计数数组来统计每个元素的出现次数，并通过顺序求和计算每个元素在排序结果中的位置。最后，将排序好的结果拷贝回原始数组，完成计数排序。

运行结果如下：

排序结果：1 2 3 4 5 6 7