Java 比较2D矩阵中每一行的元素

我试图比较2D矩阵中一行中每个元素的值，以确保每个元素彼此不同

以下是我的功能：

    private static boolean CompareComponentValue(int[][] m) {
    int k = 0;
    for (int i = 0; i < m.length; i = i + 1) {
        for (int j = 1; j < m[i].length; j = j + 1) {
            if (m[i][k] == m[i][j]) {
                return false;
            }
        }
        k = k + 1;
    }
    return true;
}

private静态布尔比较组件值（int[][]m）{
int k=0；
对于（int i=0；i

我在想，我必须确定每一个元素如下：[0][0]不同于[0][1]，[0][2]…[0][n]，然后：[0][1]不同于[0][2]…[0][n]，当然，对于每一行，[1][0]不同于[1][1]，[1][2]…[1][n]

---

我无法让它正常工作，因为它有时会在不应该返回的时候返回false。

您可以按如下方式执行：

import java.io.IOException;
import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

public class Solution {
    public static void main(String[] args) throws IOException {
        Integer n[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
        Integer x[][] = { { 1, 2, 2 }, { 4, 5, 6 }, { 7, 8, 9 } };
        System.out.println(compareComponentValue(n));
        System.out.println(compareComponentValue(x));
    }

    private static boolean compareComponentValue(Integer[][] m) {
        for (int i = 0; i < m.length; i++) {

            // Add the row i.e. m[i] to a Set
            Set<Integer> set = Arrays.stream(m[i]).collect(Collectors.toSet());

            // If there will be any duplicate values in m[i], they will be rejected by the
            // set and therefore the size of the set won't be equal to the size of m[i]
            if (set.size() != m[i].length)
                return false;
        }
        return true;
    }
}

“…确保每个元素彼此不同。”

你需要的是一份工作。使用

add

和

contains

操作可以轻松地向集合中添加元素，并测试元素是否已经在集合中。而且，这些操作都需要O（1）时间，因此解决方案将是有效的；无需反复搜索矩阵

此外，如果您只需要值，而不需要索引，请使用“增强的

for

循环”

import java.util.*；
公共类校验矩阵{
公共静态布尔hasDuplicate（int[][]矩阵）{
Set seen=新的HashSet（）；
对于（int[]行：矩阵）{
//清空集合，以仅检查单行中的重复项
明白了；
用于（整数x：行）{
如果（seen.contains（x））{return true；}
见。添加（x）；
}
}
返回false；
}
}

如果您想让人觉得有趣，可以使用返回一个

布尔值的事实，指示
x
是否已经存在：将内部循环体替换为：

                if(!seen.add(x)) { return true; }

首先感谢你们的回答，但他们真的超出了我的水平，正如我在beggining上所说的，我现在不使用任何软件包，因为我仍然是一个工程师，我想保持基本的逻辑，最后我通过认真思考得到了答案

    private static boolean NumerosDistintosFila(int[][] m) {
    for (int i = 0; i < m.length; i = i + 1) {
        for (int k = 0; k < m.length - 2; k = k + 1) {
            for (int j = 1 + k; j < m[i].length; j = j + 1) {
                if (m[i][k] == m[i][j]) {
                    return false;
                }
            }
        }
    }
    return true;
}

private静态布尔NumerosDistintosFila（int[]m）{
对于（int i=0；i

我添加了另一个for循环，其中有一个变量k，我注意到它从来没有超过矩阵的长度-2，例如，如果我要使用5x5，我需要它达到3。
这是因为我需要在第一行中比较的最后一个元素是[0][3]到[0][4]

我的逻辑是，我需要比较元素，而不重复它们之间的比较，因此这段代码基本上是将第一个元素与同一行中的每个元素进行比较，然后将第二个元素与除第一个元素之外的每个元素进行比较，然后将第三个元素与第四个和第五个元素进行比较，以此类推

再次感谢你们的解决方案，我试过了，所有的解决方案都很好，但正如我说的，我现在想继续使用基本逻辑。
所以你们的目标是检查矩阵的每一行是否由唯一的元素组成，对吗？嗯，按照你们现在编写的方式，有时
k
将等于
j
，然后你在检查某个元素是否等于它本身……是的，我不知道这是否是回答你评论的正确方法，但这正是我需要的。我想说，你可以通过使用Hashmap来查看该行中的元素是否已经存在于映射中，从而增加空间复杂度。每一行都会实例化一个新的映射。正如我说过的，我甚至不知道hashmap是什么，因为我还是一个乞丐，我宁愿保持它的简单
    private static boolean NumerosDistintosFila(int[][] m) {
    for (int i = 0; i < m.length; i = i + 1) {
        for (int k = 0; k < m.length - 2; k = k + 1) {
            for (int j = 1 + k; j < m[i].length; j = j + 1) {
                if (m[i][k] == m[i][j]) {
                    return false;
                }
            }
        }
    }
    return true;
}