Java + Count从int数组重复，不使用任何集合或其他中间数组 [英] Java + Count duplicates from int array without using any Collection or another intermediate Array

问题描述

作为Java面试问题的一部分，我有以下问题需要解决。
但是我有点不知道如何在没有任何集合或中间数组的情况下实现它。

问题： - 从int数组中重复数据而不使用任何集合或另一个中间数组

 输入值： -  {7,2,6,1,4,7,4,5,4， 7,7,3，1} 
 
输出： - 重复次数值：3 
重复值：7，4，1 
  pre> 
 
 
我已经实现了以下解决方案，但尚未完成。 
有什么想法吗？感谢。
  public static void duplicate（int numbers []）{
 
 for（int i = 0; i< numbers.length; i ++）{
 
 boolean duplicate = false; 
 int j = 0; 
 
 while（j< i）{
 
 if（（i！= j）&&数字[i] ==数字[j]）{
 duplicate = true; 
} 
 
 j ++; 
} 
 
如果（重复）{
 System.out.print（numbers [i] +）; 
} 
} 
} 
  
 
 
解决方案
解决这个问题的最简单的方法是首先对数组进行排序，然后在遇到数组时重新排列数组：
  int [] numbers = new int [] {7,2,6,1,4,7,4,5,4,7,7,3,1}; 
 int temp = 0; 
 
 //我选择做一个数组的气泡排序，
 //但是你可以随意使用你想要的任何方法（例如Arrays.sort）
 System.out .print（重复值：）; （int i = 0; i< numbers.length; ++ i）{
 for（int j = 1; j<（numbers.length  -  i）; ++ j）{ 
 if（numbers [j-1]> numbers [j]）{
 temp = numbers [j-1]; 
号[j-1] =数字[j]; 
 numbers [j] = temp; 
} 
} 
} 
 
 
 //遍历排序的数组并重复计数
 int numDup = 0，dupCount = 0; 
 int previous = -1; （int i = 0; i< numbers.length; ++ i）{
 if（numbers [i] == previous）{
 ++ numDup; 
 if（numDup == 1）{
 ++ dupCount; 
 if（dupCount == 1）{
 System.out.print（numbers [i]）; 
} 
 else {
 System.out.print（，+ numbers [i]）; 
} 
} 
} 
 else {
以前=数字[i]; 
 numDup = 0; 
} 
} 
 
 System.out.println（\\\
Number of duplicateates values：+ dupCount）; 
  
 输出： 
 重复值：1，4，7 
重复值值：3 
  
请注意，我的输出顺序与您的输出顺序相反，因为您需要先阅读整个数组，然后再知道有多少个重复项。此外，我将指出，该解决方案使用的唯一状态是输入数组本身，另外还有一些 int  varibles这里和那里。
 
 
 
此代码已在IntelliJ中进行测试，并且正常工作。
 
As a part of the Java interview question paper I have got following issue to solve.
But I am bit wonder whether how can I implement it without any Collection or intermediate Array.

Question:- Count duplicates from int array without using any Collection or another intermediate Array 
Input values:- {7,2,6,1,4,7,4,5,4,7,7,3, 1}  

Output:- Number of duplicates values: 3
         Duplicates values: 7, 4, 1
I have implemented following solution but was not completed one. 
Any one has some idea? Thanks.
public static void duplicate(int numbers[]) {

    for (int i = 0; i < numbers.length; i++) {

        boolean duplicate = false;
        int j = 0;

        while (j < i){

            if ((i != j) && numbers[i] == numbers[j]) {
                duplicate = true;
            }

            j++;
        }

        if (duplicate) {
            System.out.print(numbers[i] + " ");
        }
    }
}

解决方案
The easiest way to solve this problem is to sort the array first, and then just walk through the array counting duplicates as you encounter them:
int[] numbers = new int[]{7,2,6,1,4,7,4,5,4,7,7,3,1};
int temp = 0;

// I chose to do a bubble sort of the array,
// but you are free to use any method you wish (e.g. Arrays.sort)
System.out.print("Duplicates values: ");
for (int i=0; i < numbers.length; ++i) {
    for (int j=1; j < (numbers.length - i); ++j) {
        if (numbers[j-1] > numbers[j]) {
            temp = numbers[j-1];
            numbers[j-1] = numbers[j];
            numbers[j] = temp;
        }
    }
}


// walk through the sorted array and count duplicates
int numDup = 0, dupCount = 0;
int previous = -1;
for (int i=0; i < numbers.length; ++i) {
    if (numbers[i] == previous) {
        ++numDup;
        if (numDup == 1) {
            ++dupCount;
            if (dupCount == 1) {
                System.out.print(numbers[i]);
            }
            else {
                System.out.print(", " + numbers[i]);
            }
        }
    }
    else {
        previous = numbers[i];
        numDup = 0;
    }
}

System.out.println("\nNumber of duplicates values: " + dupCount);
Output:
Duplicates values: 1, 4, 7
Number of duplicates values: 3
Note that my output order is reverse of what you have, because you need to read through the entire array before you know how many total duplicates you have.  Also, I will point out that the only state this solution uses is the input array itself, plus a couple of int varibles here and there.

This code has been tested in IntelliJ and it works correctly.

                        
这篇关于Java + Count从int数组重复，不使用任何集合或其他中间数组的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！