LeetCode Two Sum Problem - Справка по многомерным массивам Java - PullRequest
Новая
       7

LeetCode Two Sum Problem - Справка по многомерным массивам Java

1 голос
/ 16 февраля 2020

Я предпринял попытку первого LeetCode. Проблема: Учитывая массив целых чисел, вернуть индексы двух чисел так, чтобы они складывались до заданной c цели.

Вы можете предположить, что каждый вход будет иметь точно одно решение, и вы не можете использовать один и тот же элемент дважды.

Пример: 

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

Тем не менее, я получаю похожую ошибку времени выполнения: 

 Finished in N/A
 java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
 at line 67, Solution.sortArr
 at line 11, Solution.twoSum

I Я не очень привык использовать многомерные массивы и видел в этом прекрасную возможность использовать их и учиться. Я предоставил свой код, может кто-нибудь помочь мне понять, почему это не удается? 

class Solution {
public int[] twoSum(int[] nums, int target) 
{
    int[] targetIndex = {0,0};

    int arrEndIndex = nums.length - 1;

    int[][] copyArr = new int[nums.length][];
    copyArr = copyArrWithIndex(nums);

    int[][] sortedArr = new int[nums.length][];
    sortedArr = sortArr(copyArr);

    int firstIndex = 0;
    int secondIndex = arrEndIndex;

    int firstElement = 0;
    int secondElement = 0;

    while(firstIndex != secondIndex)
    {

        firstElement = sortedArr[firstIndex][0];
        secondElement = sortedArr[secondIndex][0];

        if(firstElement + secondElement == target)
        {
            targetIndex[0] = sortedArr[firstIndex][1];
            targetIndex[1] = sortedArr[secondIndex][1];
            break;
        }
        else if(firstElement + secondElement < target)
        {
            firstIndex++;
        }
        else
        {
            secondIndex--;
        }     
    }

    return targetIndex;
}

/*
This function sorts a 2D array of ints from least to greatest based 
on the values in the first column and returns a 2D array of ints
*/

private int[][] sortArr(int[][] arr)
{

    int temp = 0;

    int firstIndex = 0;
    int secondIndex = 1; 
    int firstElement = 0;
    int secondElement = 0;

    int i = 0;
    while(i < arr[0].length)
    {

        firstElement = arr[firstIndex][0];
        secondElement = arr[secondIndex][0];

        if(firstElement < secondElement)
        {
            firstIndex++;
            secondIndex++; 
        }

        else /*if(firstElement > secondElement)*/
        {
            temp = firstElement;
            arr[firstIndex][0] = secondElement;
            arr[secondIndex][0] = temp;

            temp = firstIndex;
            arr[firstIndex][1] = secondIndex;
            arr[secondIndex][1] = temp;

            if(firstIndex != 0)
            {
                firstIndex--;
                secondIndex--;
            }
            else
            {
                firstIndex++;
                secondIndex++;
            }
         }
    }

    return(arr);
  }

 /*
This function accepts a 1D array and returns a 2D array of ints with the index int in the     first 
column and the original index of the presorted number adjacently in the second
column
*/

private int [][] copyArrWithIndex(int[] arr)
{
    int[][] copyArr = new int [arr.length][2]; 

    for(int i = 0; i < arr.length; i++)
    {
        copyArr[i][0] = arr[i];
        copyArr[i][1] = i;
    }

    return(copyArr);
   }
   }
...