你如何检查二维数组中的所有整数是否都是唯一的？

Question

I am looking to verify if all of the integers in a 2d array are unique, return true if they are unique otherwise false. The below code is what I have for a simple array. But I am not sure how to go about modifying it.

public boolean verifyUniqueIntegers(int array []){
boolean result = true;
   for (int i = 0; i < array.length; i++) {
        if(array[i] <= 0 || array[i] > n*n){
            result = false;
        }
        for (int j = 0; j < i; j++)
            if (array[i] == array[j]) {
                result = false;
            }
    }
    return result;
 }

Answer 1

The best way to approach this problem is to use a mathematical construct called a set. The key property of a set for your purposes is that they can not contain duplicates by definition. Java provides a data structure allowing us to create sets found in java.util.Set . This is the generic interface that specifies how sets should behave. However, interfaces provide only specification, not implementation, so you'll have to use Set in conjunction with another class java.util.HashSet , which implements Set . You seem like a novice programmer, so I wrote a test program to show you how this works.

import java.util.*;

public class SetTest {
    public static void main(String[] args) {
        int[] set = {1,2,3,4,5,6,7};
        int[] nonSet = {1,2,3,4,5,4};

        System.out.println(verifyUniqueIntegers(set));
        System.out.println(verifyUniqueIntegers(nonSet));
    }

    public static boolean verifyUniqueIntegers(int[] array) {
        Set<Integer> set = new HashSet<Integer>();
        for(int i : array) // This is a construction called a for-each loop
            if(!set.add(i)) // This is an example of what's called autoboxing
                return false;
        return true;
    }
}

Here I've used a static method for convenience, but you can of course change this into an instance method for your purposes once you give it a try.

First, I create a for-each loop to iterate over all the elements in the array that's passed into verifyUniqueIntegers() . For each loops use what are called iterators to create a reference to each element, one at a time, and make it available in the body of the loop. When the end of the body is reached, the for-each loop automatically resets i to the next element in the array, as long as there are elements left in the arry. You can ready more about for-each loops in the Oracle Java Tutorials.

Then, the method calls set.add(i) . This attempts to add i to the set that we previously defined. This is an example of what's called autoboxing. Since the Set interface is generic, it can contain elements of any object type. Since int is a primitive, we must use the wrapper class Integer to specify the elements in our set. When we call set.add(i) you don't have to convert the int into an Integer because the java compiler does it for you.

This method returns true if i is not a duplicate, then adds it to the Set . It returns false if i is a duplicate and does nothing. Thus, we can take advantage of the method check the uniqueness of each element in your array. The method returns false as soon as a duplicate is found, and otherwise returns true . Hope this helps, good luck!

Answer 2

Your algorithm is slow. To make it faster, you should use something like HashMap .

1. Create empty HashMap<Integer> .
2. Iterate on all 2d-array elements (for-for loop).
3. For every element check if your HashMap contains it.
4. If yes then return false , it means that not all elements in your array are unique .
5. If no, add element to HashMap .
6. After for-for loop return true .

Answer 3

As a beginning programmer, choose basic solutions without the sophistication of more complex parts of the library that do in truth offer more power. The main thing for you here is to learn how to use 2D arrays.

You can do it very simply because of the hidden specification that you did not mention but is in the code. None of the numbers can be greater than N * N.

Start with pseudo-code. The basic algorithm is to have a checking array of length N * N. Put a marker in each element as you find the number in the source array, using the number as the index into the checking array. If there is already an element there, then the number is not unique. The code becomes something like this:

final int N = 10;  // Your choice of N, or perhaps input it.
int [][] needsChecking = new int [N] [N];  // fill it up.

public boolean arrayIsGood (int [][] src) {
    final int N2 = N * N;
    boolean [] checker = new boolean [N2];
    for (int i = 0; i < N2; i++) {  // Initialize Checker
        checker [i] = false;
    }
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            int value = src [i][j];
            if ((value <= 0) || (value > N2))
                return false;
            if (checker [value - 1])  // already found
                return false;
            checker [value - 1] = true;
        } // for j
    } // for i
    return true;  // if we get here every element has passed.
} // arrayIsGood (int [][])

Some of the other answers are more elegant or more extensible or handle space usage better or may find the result faster, etc. But master the basics first.

Answer 4

public boolean verifyUniqueIntegers(int array []){
    Set<Integer> set = new HashSet<>(array.length);
    for (int i : array)
    {
        if (set.contains(i))
            return false;
        set.add(i);
    }
    return true;
}

or maybe:

public boolean verifyUniqueIntegers(Integer array []){
    return new HashSet<>(Arrays.asList(array)).size() == array.length;
}