Question

这个问题的最佳解决方案是什么？ （小于O（n））

给定一个正整数数组，其中连续元素增加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开始。

附：我的解决方案是O（n），我也尝试将它分成两部分仍然会减少一半。

提示：有人告诉我，我可以使用二进制搜索。

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

Answer 1

尝试这样的事情

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);
            }
        }
    }
}

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

Answer 2

public static void main(String[] args) {
    // corruption starts at 13
    int[] arr = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17};

    int corruptionIndex = -1;

    int start = 0;
    int end = arr.length;

    while (end - start > 1) {
        int middle = (start + end) / 2;

        // we add the first element onto our value as an offset
        int expectedValue = middle + arr[0];

        if (arr[middle] != expectedValue) {
            // something has already gone wrong, let's check the first half
            end = middle;
        }
        else {
            // so far so good, let's check the second half
            start = middle;
        }

        corruptionIndex = end;
    }

    System.out.println("Corruption Index: " + corruptionIndex);
}

Answer 3

＆＃13;

var arr1 = [5, 9, 7, 8, 9, 13] ;
var arr2 = [5, 2] ;
var arr3 = [5, 6, 7, 8, 9, 13] ;
check(arr1);
check(arr2);
check(arr3);

function check(arr){
 for(var i=1;i<arr.length;i++){
  if(arr[i]-arr[i-1] !=1 ){
   console.log('corroption begins at '+i);
   break;
  }
 }
}

＆＃13;

我们可以检查当前和prev元素差异，对吧。如果diff不是1，我们需要打破。它在js

Answer 4

O（n）是您唯一的选择。二进制搜索是O（log（n）），但仅适用于搜索已排序列表中的特定数字。您既没有排序列表也没有要搜索的特定号码

Answer 5

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));  
            }
        }   
    }
}

找到损坏开始的数组的索引

5 个答案: