0

我希望在一堆点数组中找到唯一点（即删除所有重复项并查看剩下的内容）。

这是我尝试过的代码：

int numCount = 0;
    for (int x = 0; x < ALLARRAYS.length; x++) {
        for (final Point test : ALLARRAYS[x]) {
            NUMBER: for (final Point[] numbers : ALLARRAYS) {
                if (numbers == ALLARRAYS[x]) {
                    continue;
                }
                for (int i = 0; i < numbers.length; i++) {
                    if (test.equals(numbers[i])) {
                        break NUMBER;
                    } else {
                        if (i == numbers.length - 1) {
                            numCount++;
                        }
                    }
                }
            }
            if (numCount == 10) {
                System.out.println(x + "\tPoint: " + test.x + ", " + test.y + " is unique.");
            }
            numCount = 0;
        }
        System.out.println();
    }

基本上，我有 11 个要检查的数组，因此 numCount 会检查 10 个要确认的数组。我的方法是循环遍历每个数组，然后循环遍历该数组中的所有点，然后循环遍历每个其他数组中的每个点。如果它看到重复，它会完全跳过整个数字。

我的问题：我得到错误的读数。我不确定发生了什么，但程序会吐出其他数组中已经存在的点。

我的目标：每个阵列作为一个整体工作。如果一个元素不满足，则跳过整个数组。我的最终结果应该是 11 个较小的数组，它们都是唯一的，以便方法可以检查每个集合的元素并确定它们都是唯一的。

注意：这些数组现在都是独一无二的，它们非常大。我正在寻找一种方法来通过创建这个小程序来消除重复项来截断它。

我的问题：有人可以帮我吗？

4

3 回答 3

2

将所有数组条目放在一个集合中，它将跳过重复项。

请确保正确覆盖 Point 类上的 equals 方法，因为 Set 接口的实现将使用它。

高温高压

于 2012-05-04T23:36:57.460 回答
1

您的代码似乎检查了所有有问题的数组Point，包括Point您要查找的数组。因此，您的代码将始终找到Point它正在寻找的内容，而您最终将没有结果。

您可能需要执行以下操作：

        NUMBER: for (final Point[] numbers : ALLARRAYS) {
            if (numbers == array) {
                continue; // skip the array that contains 'test'
            }
            ...
        }

这样，您将跳过包含该test元素的数组。

于 2012-05-04T23:44:54.143 回答
0

数组不太适合您的工作。它们不仅没有像 intersection 或 removeAll 这样的方法，而且很难改变，尤其是如果你想减小它们的大小。

为了避免这种麻烦，我removed通过将 x 和 y 设置为 -1 来标记一个点，一个坐标当然就足够了，但是出于对称的原因......

import java.util.*;
import java.awt.Point;

public class RandPoints
{
    Random r = new Random ();
    Point [][] arr;

    public void removeDuplicatesFrom2 (Point [] pa, Point [] pb) {
        for (Point p : pb) {
            if (p.x != - 1 && Arrays.asList (pa).contains (p)) {
                // System.out.println ("dup: " + p.x + " " + p.y);
                p.x = -1;
                p.y = -1;
            }
        }
    }

    // create a random point in range (0..19)(0..19)
    public Point randpoint () {
        return new Point (r.nextInt (20), r.nextInt (20));
    }

    // create 10 (default) arrays of size 100 (default)
    public void init (int arrsize, int arrcount) 
    {
        arr = new Point [arrcount][];
        for (int c = 0; c < arrcount; ++c)
        {
            Point [] points = new Point [arrsize];
            for (int s = 0; s < arrsize; ++s)
            {
                Point p = randpoint ();
                points[s] = p; 
            }
            arr[c] = points;
        }
    }

    public void unify () 
    {
        for (Point[] pac0 : arr) {
            for (Point[] pac1 : arr) 
            {
                if (pac0 != pac1)
                removeDuplicatesFrom2 (pac0, pac1);     
            }   
        }
    }

    /**
        fill arrays with duplicates by random, 
        show, delete and show again.
    */
    public RandPoints (int arrsize, int arrcount)
    {
        init (arrsize, arrcount);
        show ();
        unify (); 
        System.out.println ();
        show ();
    }

    public static void main (String args[])
    {
        int arrsize = 100;
        int arrcount = 10;
        if (args.length == 2)
        {
            arrsize = Integer.parseInt (args[0]);
            arrcount = Integer.parseInt (args[1]);
        }
        new RandPoints (arrsize, arrcount);
    }

    // visible feedback is always welcome while debugging/testing
    public void show ()
    {
        for (Point[] pa: arr) {
            for (Point point: pa)
                if (point.x != -1 && point.y != -1)
                    System.out.print (point.x + ", " + point.y + "\t");
            System.out.println ();
        }
    }
}

我稍微修改了代码，以使值 (20) 的最大范围也可配置。

开始它

java RandPoints 16 10 10
3, 0    9, 0    6, 9    2, 3    6, 9    7, 4    9, 9    2, 5    8, 7    3, 3    9, 5    3, 7    0, 5    7, 6    0, 4    8, 1    
6, 1    2, 7    2, 5    6, 7    0, 7    5, 8    4, 2    1, 9    8, 4    5, 7    0, 2    3, 1    1, 9    2, 1    8, 0    1, 7    
5, 4    9, 7    9, 3    7, 3    1, 2    9, 6    0, 4    6, 0    3, 0    7, 7    1, 3    1, 1    5, 3    3, 8    1, 0    4, 9    
4, 7    8, 9    4, 0    0, 2    8, 7    5, 8    7, 0    1, 4    4, 9    8, 2    6, 9    9, 6    2, 1    1, 9    0, 8    6, 5    
6, 8    9, 6    1, 0    6, 9    4, 0    5, 1    2, 9    7, 3    5, 1    2, 5    6, 9    0, 9    7, 4    8, 1    5, 5    3, 4    
5, 9    0, 4    5, 4    2, 2    2, 6    7, 1    2, 0    6, 1    0, 4    9, 8    5, 7    5, 5    4, 6    9, 0    2, 8    8, 5    
8, 2    4, 2    0, 8    1, 1    0, 3    3, 4    1, 8    3, 1    6, 6    4, 1    3, 6    6, 0    1, 7    4, 8    1, 6    1, 1    
6, 2    1, 3    2, 4    0, 8    9, 0    3, 0    1, 1    3, 7    6, 2    2, 4    0, 9    3, 6    7, 2    1, 2    5, 0    8, 2    
2, 3    5, 6    7, 9    3, 0    9, 3    2, 6    4, 8    8, 7    9, 4    5, 3    0, 3    3, 0    5, 5    1, 4    6, 4    5, 2    
3, 2    4, 9    6, 9    4, 7    7, 1    0, 4    5, 8    7, 2    5, 2    5, 5    2, 1    9, 8    4, 9    6, 6    7, 7    0, 3    

3, 0    9, 0    6, 9    2, 3    6, 9    7, 4    9, 9    2, 5    8, 7    3, 3    9, 5    3, 7    0, 5    7, 6    0, 4    8, 1    
6, 1    2, 7    6, 7    0, 7    5, 8    4, 2    1, 9    8, 4    5, 7    0, 2    3, 1    1, 9    2, 1    8, 0    1, 7    
5, 4    9, 7    9, 3    7, 3    1, 2    9, 6    6, 0    7, 7    1, 3    1, 1    5, 3    3, 8    1, 0    4, 9    
4, 7    8, 9    4, 0    7, 0    1, 4    8, 2    0, 8    6, 5    
6, 8    5, 1    2, 9    5, 1    0, 9    5, 5    3, 4    
5, 9    2, 2    2, 6    7, 1    2, 0    9, 8    4, 6    2, 8    8, 5    
0, 3    1, 8    6, 6    4, 1    3, 6    4, 8    1, 6    
6, 2    2, 4    6, 2    2, 4    7, 2    5, 0    
5, 6    7, 9    9, 4    6, 4    5, 2    
3, 2
于 2012-05-05T00:24:02.987 回答