Question

该程序的目的是使用递归将大数组分解为四个单独的数组，直到每个数组包含小于或等于1000个整数。发生这种情况时，将对数组进行排序，然后将其添加到ArrayList中。

我的问题是，在声明了四个子数组之后，我的程序完全跳过for循环集并直接进入递归调用，这导致我的数组只被零填充。我不知道为什么会这样，所以任何见解都会非常感激。

 public static void quadSort(int[] array, int startIndex, int endIndex) {
            // Insertion sort
            if(endIndex - startIndex <= 1000) {
                for(int i = 0; i <= endIndex; i++) {
                    int x = array[i];
                    int j = i;
                    while(j > 0 && array[j - 1] > x) {
                        array[j] = array[j - 1];
                        j = j - 1;
                    }
                    array[j] = x;
                }

                for(int i = 0; i < array.length; i++) {
                    list.add(array[i]);
                }
            }

            else {

                // Split array into four separate arrays
                int[] a = new int[(endIndex + 1) / 4];
                int[] b = new int[(endIndex + 1) / 4];
                int[] c = new int[(endIndex + 1) / 4];
                int[] d = new int[(endIndex + 1) / 4];

                // Fill separate arrays with initial array's values
                for(int i = 0; i < (endIndex + 1) * (1/4); i++) {

                    for(int k = startIndex; k < (endIndex + 1) * (1/4); k++) {
                        a[i] = array[k];
                    }

                    for(int l = (endIndex + 1) * (1/4); l < (endIndex + 1) * (1/2); l++) {
                        b[i] = array[l];
                    }

                    for(int m = (endIndex + 1) * (1/2); m < (endIndex + 1) * (3/4); m++) {
                        c[i] = array[m];
                    }

                    for(int n = (endIndex + 1) * (1/4); n < endIndex + 1; n++) {
                        d[i] = array[n];
                    }
                }

                quadSort(a,0,a.length - 1);
                quadSort(b,0,b.length - 1);
                quadSort(c,0,c.length - 1);
                quadSort(d,0,d.length - 1);
            }
        }

Answer 1

问题是1/4的计算结果为零（它是一个整数除法，因此会丢弃该部分）。你可以通过将不等式的两边乘以4来解决这个问题，如下所示：

for(int i = 0 ; 4*i < (endIndex + 1) ; i++)
    ...

现在条件在逻辑上等同于^*，但不使用除法进行评估。

^*假设没有溢出

Answer 2

for(int i = 0; i < (endIndex + 1) * (1/4); i++)

由于整数除法，

将完全迭代0次。

Answer 3

这是整数运算的情况。

如果你运行：

 System.out.println(1/4);

你得到0。

另一方面，这个：

System.out.println(1.0f/4.0f);

给出0.25。

使用它，您可以将循环更改为：

for(int i = 0; i < (endIndex + 1) * (1.0f/4.0f); i++)

或者，您可以跳过除法并使用预先计算的值：

for(int i = 0; i < (endIndex + 1) * .25f; i++)

Java程序跳过for循环

3 个答案: