Java 需要帮助理解计数排序算法的实现吗

这段代码是关于算法和数据结构的。这段代码运行得很好，我只是有一些问题，因为我似乎不明白两点。因此，我的问题是：

哪些信息在countingArray中

while循环多久执行一次

---

公共类计数排序{
公共静态void main（字符串[]args）{
int[]m1={1,17,3,1,4,9,4,4}；
System.out.println（“未排序：”）；
产量（m1）；
int min1=最小范围（m1）；
int max1=范围最大值（m1）；
计数排序（m1，min1，max1）；
System.out.println（“排序：”）；
产量（m1）；
int[]m2={-1,13,3，-1，-4,9，-4,4}；
System.out.println（“未排序：”）；
产量（m2）；
int min2=最小范围（m2）；
int max2=范围最大值（m2）；
计数排序（m2，min2，max2）；
System.out.println（“排序：”）；
产量（m2）；
}
公共静态无效输出（int[]a）{
for（int i=0；i最大值）
最大值=数组[i]；
}
返回最大值；
}
公共静态void countingSort（int[]数组，int rangeMin，int rangeMax）{
int[]countingArray=新的int[rangeMax-rangeMin+1]；
for（int i:array）{
计数阵列[i-rangeMin]+；
}
int c=0；
对于（int i=rangeMin；i 0）{
数组[c]=i；
C++；
countingArray[i-rangeMin]-；
}
}
}
}

CountingSort

具有

O（n）

时间和空间复杂性。迭代两次（即使用

进行循环

）

公共类计数排序{
公共静态void main（字符串…参数）{
继续（1,17,3,1,4,9,4,4）；
System.out.println（“--”）；
继续（-1,13,3，-1，-4,9，-4,4）；
}
公共静态无效继续（int…arr）{
系统输出打印（“未排序：”）；
打印（arr）；
计数排序（arr）；
系统输出打印（“排序：”）；
打印（arr）；
}
公共静态无效打印（int…arr）{
System.out.println（Arrays.stream（arr）
.mapToObj（i->String.format（“%2d”，i））
.collect（收集器。连接（“，”）；
}
公共静态无效计数排序（int…arr）{
int min=Arrays.stream（arr.min（）.orElse（0）；
int max=Arrays.stream（arr.max（）.orElse（0）；
//包含未排序数组中的数字量
//计数[0]-最小数的数量
//count[count.length-1]-最大数的数量
int[]计数=新的int[max-min+1]；
用于（int i:arr）
计数[i-min]++；
//用数字量填充源数组
for（int i=0，j=0；i

数组只包含您看到每个元素的次数计数。对于每个可能的元素，使while循环遍历该元素的计数。因此while循环的运行次数与所有计数的总和相同，这与输入的长度相同。

public class CountingSort {

    public static void main(String[] args) {
        int[] m1 = { 1, 17, 3, 1, 4, 9, 4, 4 };

        System.out.println("unsorted:");
        output(m1);
        int min1 = rangeMin(m1);
        int max1 = rangeMax(m1);

        countingSort(m1, min1, max1);
        System.out.println("sorted:");
        output(m1);

        int[] m2 = { -1, 13, 3, -1, -4, 9, -4, 4 };
        System.out.println("unsorted:");
        output(m2);
        int min2 = rangeMin(m2);
        int max2 = rangeMax(m2);

        countingSort(m2, min2, max2);
        System.out.println("sorted:");
        output(m2);
    }

    public static void output(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + ", ");
        }
        System.out.println();
    }

    public static int rangeMin(int[] a) {
        int minimum = a[0];
        for (int i = 1; i < a.length; i++) {
            if (a[i] < minimum)
                minimum = a[i];
        }
        return minimum;
    }

    public static int rangeMax(int[] array) {
        int maximum = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > maximum)
                maximum = array[i];
        }
        return maximum;
    }

    public static void countingSort(int[] array, int rangeMin, int rangeMax) {
        int[] countingArray = new int[rangeMax - rangeMin + 1];
        for (int i : array) {
            countingArray[i - rangeMin]++;
        }
        int c = 0;

        for (int i = rangeMin; i <= rangeMax; i++) {
            while (countingArray[i - rangeMin] > 0) {

                array[c] = i;
                c++;
                countingArray[i - rangeMin]--;
            }
        }
    }
}

public class CountingSort {

    public static void main(String... args) {
        proceed(1, 17, 3, 1, 4, 9, 4, 4);
        System.out.println("---");
        proceed(-1, 13, 3, -1, -4, 9, -4, 4);
    }

    public static void proceed(int... arr) {
        System.out.print("unsorted: ");
        print(arr);

        countingSort(arr);

        System.out.print("sorted:   ");
        print(arr);
    }

    public static void print(int... arr) {
        System.out.println(Arrays.stream(arr)
                                 .mapToObj(i -> String.format("%2d", i))
                                 .collect(Collectors.joining(",")));
    }

    public static void countingSort(int... arr) {
        int min = Arrays.stream(arr).min().orElse(0);
        int max = Arrays.stream(arr).max().orElse(0);
        // contains amount of number in the unsorted array
        // count[0] - amount of min numbers
        // count[count.length - 1] - amount of max numbers
        int[] count = new int[max - min + 1];

        for (int i : arr)
            count[i - min]++;

        // fill source array with amount of numbers
        for (int i = 0, j = 0; i < count.length; i++)
            for (int k = 0; k < count[i]; k++, j++)
                arr[j] = min + i;
    }
}