Question

我这里有一个代码，用于搜索数组中最深的坑

我将使用公式

搜索最深的坑

min(A[triP] - A[triQ], A[triR] - A[triQ]);

其中triP是第一点，triQ是第二点，triR是第三点。

我没有得到的是我无法看到任何印刷品。或者说我的代码有一个无限循环。

int[] A = {0, 1, 3, -2, 0, 1, 0, -3, 2, 3};
int length = A.length, depth = 0, x = 0, minD;
int triP = 0, triQ = 0, triR = 0;
while(x < length){
    while(x < length){
        if(x + 1 == length)
            break;
        x++;
        if(A[triP] > A[x]){
            while(A[triP] > A[x]){
                if(x + 1 == length)
                    break;
                x++;
            }
            triQ = x;
            break;
        }
        else{
            triP++;
            if(x + 1 == length)
                break;
            x++;
            continue;
        }
    }
    while(x < length){
        if(x + 1 == length)
            break;
        x++;
        if(A[triQ] < A[x]){
            while(A[triQ] < A[x]){
                if(x + 1 == length)
                    break;
                x++;
            }
            triR = x;
            break;
        }
        else{
            triQ++;
            if(x + 1 == length)
                break;
            x++;
            continue;
        }
    }
    minD = Math.min(A[triP] - A[triQ], A[triR] - A[triQ]);
    if(depth < minD){
        depth = minD;
    }
    if(x >= length)
        break;
}

if(depth == 0)       
    System.out.println("-1");
else
    System.out.println(depth);

代码有什么问题？

Answer 1

我不太确定您现有的算法在做什么，但如果我已正确理解您的意图，那么您只需尝试在数组中找到{{1}的索引}是最大的？这可以更明确地表达为：

min(A[i-1] - A[i], A[i+1] - A[i])

这个输出是：

    int[] A = { 0, 1, 3, -2, 0, 1, 0, -3, 2, 3 };

    int best = 0;
    int bestIndex = -1;
    for (int i = 1; i < A.length - 1; ++i) {
        int depth = Math.min(A[i - 1] - A[i], A[i + 1] - A[i]);
        if (depth > best) {
            best = depth;
            bestIndex = i;
        }
    }

    if (bestIndex == -1)
        System.out.println("Not Found");
    else
        System.out.println("Deepest pit at index " + bestIndex + " == " + best);

java中无休止的循环

1 个答案: