Question

我试图在由Arrays.sort（）排序的Java数组中找到重复的段。我期待相同的整数在数组中形成重复的段。例如，排序后，数组为：{1,2,3,3,3,3,5,6,8,8,8,8,8,9,9,9,9}

我想实现以下想法来找到重复的段：我想使用带有两个指针（i和j）的while循环。

1。）让我从索引0开始，让j开始最后一个索引（N-1）。 2.）在执行j--时将i保持在索引0处。当j到达i的下一个索引并且没有找到任何段时，将i递增1，并将j重新初始化为索引N-1 3.）重复步骤1和2.如果找到一个段，则将i递增到j的当前索引，并将j重新初始化为索引N-1。 4.）当i == j时退出while循环。

以下是我的尝试，但不是我的执行。

int[] test = new int[] {1, 2, 3, 3, 3, 3, 5, 6, 8, 8, 8, 8, 8, 9, 9, 9, 9};
        int i = 0;
        int j = test.length - 1;
        int[] copySegment;

        while (j > i)
        {
            if (test[j] == test[i])
            {
                int segmentLength = j - i + 1;
                copySegment = new int[segmentLength];
                for (int k = j; k >= i; k--)
                {
                    copySegment[segmentLength--] = test[k];
                }
                for (int e : copySegment)
                {
                    System.out.print(e + " ");
                }
            }
            j--;
            i++;
        }

Answer 1

如果你试图在数组中找到重复变量并打印重复项，可能应该从头开始索引i = 0，j = i + 1

Arrays.sort(array); //sorts the array elements in ascending order
int i,j,lastNum;
ArrayList<Integer> list = new ArrayList<Integer>();

for(i=0,j=i+1;i<array.length-1;i++,j++) {
  if(!list.isEmpty()) {
    lastNum = list.get(list.size()-1);
  } else {
    lastNum = array[i]-1; // so that compiler doesn't warn you about lastNum not being initialized
  }
  if(array[i]!=lastNum) {
      if(array[i]==array[j]) {
        list.add(array[i]);
      }
  } else {
    continue;
  }
}

Iterator<Integer> it = list.iterator();

while(it.hasNext()) {
    System.out.println(it.next().intValue());
}

编辑：我已经编辑了答案，以便在@javaBeginner指向时给出明确的解释。但这是不必要的，因为问题清楚地表明数组是使用Arrays.sort排序的，但无论如何更明确的解释都不会受到伤害。

Answer 2

考虑到数组已预先排序，（否则，我仍然可以Array.sort()对它们进行排序）我想出了一个更简单的方法来做你正在做的事情。

int[] array = new int[] {1, 2, 3, 3, 3, 3, 5, 6, 8, 8, 8, 8, 8, 9, 9, 9, 9};

Map<Integer, Integer> intList= new HashMap<Integer, Integer>(); 

int curCount=1;
for (int i=0; i<array.length-1; i++){
    if (array[i]==array[i+1] ){
        curCount++;
        if(i==array.length-2)
            intList.put(array[i], curCount);
    }
    else{
        intList.put(array[i], curCount);
        curCount=1;
    }

}

for (Map.Entry<Integer, Integer> entry : intList.entrySet())
{
    if(entry.getValue()<2)
        continue;
    else {
        for (int i=0; i<entry.getValue(); i++)
        System.out.println(entry.getKey());

    }
}

我已经运行并测试了这段代码。希望它有所帮助。

Answer 3

与您的解释相反，在i递减时，您的代码不会保持j不变。实际上，每次j递减时，i都会递增。

要执行您的意图，您需要两个while循环 - 一个外部的循环增加i，一个内部的循环将j从test.length减少到{ {1}}。

然而，@ BlackPanther的方法似乎以较少的计算提供了所需的结果，所以我更喜欢它的方法。

Answer 4

我这样做的方式比@ BlackPanther的解决方案需要更多的数组访问，但我最终使其工作如下：编辑。

int[] test = new int[] {1, 2, 3, 3, 3, 3, 5, 6, 8, 8, 8, 8, 8, 9, 9, 9, 9};
        int i = 0;
        int j = test.length - 1;
        int[] copySegment;

        while (i < test.length)
        {
            while (j > i)
            {
                if (test[j] == test[i])
                {
                    for (int k = i; k <= j; k++)
                        System.out.print(test[k] + " ");
                    System.out.print("\n");
                    i = j + 1;
                    j = test.length;
                }
                j--;
            }
            i++;
            j = test.length - 1;
        }

带有两个指针的while循环的问题

4 个答案: