Java 查找开始损坏的数组的索引

这个问题的最佳解决方案是什么？少于 给定一个连续元素增加1的正整数数组 除了一个元素，该元素在开始时不会增加1 腐败，返回腐败开始的索引

例1：

数组：[5,6,7,8,12,13]索引：0 1 2 3 4 5

腐败从指数4开始

例2：

数组：[5,2,3,4,5,6]索引：0 1 2 3 4 5

腐败从索引1开始。 顺便说一下，我的解决方案是开的，我也试着把它分成两部分，但它会减少一半。 提示：有人告诉我可以使用二进制搜索

编辑：

---

我的解决方案只是迭代数组，看看差异是大于还是小于1。

On是您唯一的选择。二进制搜索是Ologn，但它仅适用于在排序列表中搜索特定的数字。您既没有已排序的列表，也没有正在搜索的特定编号，这是您唯一的选择。二进制搜索是Ologn，但它仅适用于在排序列表中搜索特定的数字。您既没有已排序的列表，也没有正在搜索的特定数字，请尝试以下操作

public class Main {

    public static void main(String[] args) {
        int[] nums = {5, 6, 7, 8, 12, 13};
        int res = checkArray(nums, 0, nums.length - 1);
        System.out.println("res = " + res);
    }

    public static int checkArray(int[] nums, int start, int end) {
        if (end - start < 2) {
            return end;
        } else {
            int middle = (start + end) / 2;
            int a = nums[start];
            int b = nums[middle];
            if (b - a != middle - start) {
                return checkArray(nums, start, middle);
            } else {
                return checkArray(nums, middle, end);
            }
        }
    }
}

---

它使用这样一个事实，即如果数组没有损坏，子数组的第一个和最后一个元素之间的差值等于它的长度。

试试这样的方法

public class Main {

    public static void main(String[] args) {
        int[] nums = {5, 6, 7, 8, 12, 13};
        int res = checkArray(nums, 0, nums.length - 1);
        System.out.println("res = " + res);
    }

    public static int checkArray(int[] nums, int start, int end) {
        if (end - start < 2) {
            return end;
        } else {
            int middle = (start + end) / 2;
            int a = nums[start];
            int b = nums[middle];
            if (b - a != middle - start) {
                return checkArray(nums, start, middle);
            } else {
                return checkArray(nums, middle, end);
            }
        }
    }
}

它使用这样一个事实，即如果数组没有损坏，子数组的第一个和最后一个元素之间的差值等于其长度。

var arr1=[5,9,7,8,9,13]； var arr2=[5,2]； var arr3=[5,6,7,8,9,13]； checkarr1； checkarr2； checkarr3； 函数校验{ forvar i=1；i var arr1=[5,9,7,8,9,13]； var arr2=[5,2]； var arr3=[5,6,7,8,9,13]； checkarr1； checkarr2； checkarr3； 函数校验{

---

---

forvar i=1；iy你的解决方案是开的，酷！你能不能也发布它，即使它是伪代码？我的解决方案只是迭代数组，看看差异是大于还是小于一。你可以使用像合并排序这样的排序算法，当你做比较时，如果它大于一，那就是答案。因为我们正在寻找单一的元素，您可以查看开始和结束，验证结束元素是否为开始+长度+n，其中n为损坏，然后将数组拆分为两部分，并检查上面的规则在哪一部分仍然有效，然后继续使用该部分并忽略另一部分。@M.Prokhorov您能提供伪代码吗？您的解决方案是On，酷！可以吗即使是伪代码，也请发布它？我的解决方案只是迭代数组，看看差异是大于还是小于一。你可以使用像合并排序这样的排序算法，当你进行比较时，如果它大于一，那就是答案。因为我们寻找的是单个元素，你可以查看开始和结束，验证结束元素是start+length+n，其中n是损坏的，然后将数组分成两部分，检查上面的规则仍然保留的部分，然后继续使用该部分并忽略另一部分。@M.Prokhorov您可以提供伪代码吗？我只有一个损坏的索引，因此可以通过如下分支实现解决方案我们在二进制搜索中是这样做的。事实上，他的列表是排序的。我只有一个损坏的索引，因此它可以是解决方案，可以像我们在二进制搜索中那样通过分支来实现。事实上，他的列表是排序的。问题要求更好的解决方案。问题要求更好的解决方案。对于这个输入，我得到5:5，1，7，8，9，10。这是预期的吗？是的。因为您有无效的输入。只允许一个损坏。@talex非常感谢您提供的解决方案：为什么要使用递归而不是循环来解决这个问题？@Alex因为，我认为这是一个更难理解的问题。对于这个输入，我得到了5:5，1，7，8，9，10。这是预期的吗？是的。因为您有无效的输入。只允许一个损坏。@talex非常感谢您的解决方案：为什么要使用递归而不是循环来解决这个问题？@Alex，因为我认为理解它是pimplier。

class FindCorruptionIndex
{
    public static void main(String[] args) 
    {
        int i,j;
        int array[]={1,2,3,4,7,8,9};
        System.out.print("The array is [ ");
        for (int x :array )
        {
            System.out.print(x+",");
        }
        System.out.print("\b ] ");
        System.out.println();
        for(i=0;i<array.length-1;i++)
        {
            j=array[i+1]-array[i];
            if (j>=2)
            {
                System.out.println("The corruption Index position is "+(i+1));  
            }
        }   
    }
}