我有一组2个int数组，包含相同数量的数字
例如
int[] array1 = {1,3,5,5,2}
int[] array2 = {5,3,4,4,4}
我需要根据2个标准对它们进行比较
- 有多少个元素在相同的索引上具有相同的值
- 有多少元素在其他索引上具有相同的值
并返回一个呈现值的整数数组
我有一些示例，所以您可以更好地理解：
int[] array0 = {1,3,5,5,2};
int[] array1 = {5,3,4,4,4};
int[] array2 = {5,3,4,4,5};
int[] array3 = {2,3,2,2,4};
int[] array4 = {5,5,2,1,3};
int[] array5 = {3,1,5,5,2};
int[] array6 = {1,3,5,5,2};
compare(array0,array1); //this would return 1,1
compare(array0,array2); //this would return 1,2
compare(array0,array3); //this would return 1,1
compare(array0,array4); //this would return 0,5
compare(array0,array5); //this would return 3,2
compare(array0,array6); //this would return 5,0
对于第一个数字，这很容易，我只需要检查array1索引i上的元素是否与array2中的元素相同。
我在产生第二个数字时遇到问题，因为应采取其中一个阵列的最低数字。如果我只查看array1的元素是否在array2中的某个地方，则在某些情况下会产生错误的结果。
如果您查看
int[] array1 = {1,3,5,5,2}
和
int[] array3 = {2,3,2,2,4};
并检查array1在索引上是否具有与array3相同的内容，它将返回3个数字相等，但在另一个位置，这是错误的，因为它应该从最低数字中进行判断，结果应该有1个。
如果我将其切换到以比较Array3是否具有与Array1相同的某些索引中的内容，则适用于这种情况。
关于如何处理这个问题的任何想法，我很无知？
-
克隆两个输入整数数组。
-
检查元素在相同索引上是否具有相同的值。
-
如果是这样，请将1添加到同一索引计数器，然后将输入整数数组中的值更改为-1（或小于最小有效值的数字）。
-
检查元素是否使用嵌套的循环具有相同的值。换句话说，请检查第一个整数数组的第一个元素，其中包括第二个整数数组的所有元素。跳过两个数组中具有相同索引的元素，并且跳过小于最小有效值的元素。
-
如果是这样，则将1添加到不同的索引计数器，然后将输入整数数组中的值更改为-1（或小于最小有效值的数字）。
这应该做技巧：
public void compare(int[] arrayA, int[] arrayB) {
int sameIndex = 0;
int diffIndex = 0;
//Made two new empty arrays to save the status of each element in the corresponding array, whether it has been checked our not, if not, it'd be null.
String[] arrayAstatus = new String[arrayA.length];
String[] arrayBstatus = new String[arrayB.length];
for (int i = 0; i < arrayA.length; i++) {
if (arrayA[i] == arrayB[i] || arrayAstatus[i] != null) {
sameIndex++;
continue;
}
for (int a = 0; a < arrayB.length; a++) {
if (a == i || arrayBstatus[a] != null) {
continue;
}
if (arrayA[i] == arrayB[a]) {
arrayAstatus[i] = "checked";
arrayBstatus[a] = "checked";
diffIndex++;
break;
}
}
}
System.out.println(sameIndex + ", " + diffIndex);
}
也许对于第二个条件，您可以尝试从数组中删除数字，并一旦发现它们具有匹配，就可以脱离循环。您可以将设置为原始数组的值设置为临时数组。然后检查array1[0]的值与array3中的所有值。找到匹配时，将两个数组中的数字删除，然后根据array3中的所有值检查array1[1]。
因此，当您对array1[4]检查CC_5时，您将获得匹配。然后，您将删除这两个数字并脱离循环。array1中没有更多的数字可以检查，因此结果为1。
我认为这将清除两次计数相同值的问题。
首先，这听起来很糟糕。不要返回每个索引意味着不同和神秘的数组。制作两种方法：比较（array，array）和iflifferentIndex（array，array）。
为了实际实现这些方式，您可以检查第一个数组中的每个索引，以查看它们是否出现在第二个数组中的任何位置，并调用只需比较（）。然后比较ifferentIndex（）变为compare（） - 比较emplesameIndex（）。例如：
public int compare (int[] array0, int[] array1) {
int matches = 0;
List<Integer> list1 = Arrays.asList(array1);
for (int curInt : array0) {
if (list1.contains(curInt)) {
matches++;
}
}
return matches;
}
public int compareSameIndex(int[] array0, int[] array1) {
int matches = 0;
for (int i=0; i < array0.length; i++) {
if (array0[i] == array1[i]) {
matches++
}
}
return matches;
}
public int compareDifferentIndex(int[] array0, int[] array1) {
return compare(array0, array1) - compareSameIndex(array0, array1);
}
当相同数字出现两次时会发生的情况似乎有些模糊，但是您可以将该逻辑构建到bamare（）中以适应。另外，您可以针对两次不检查相同数字的非常大的数组进行优化，但这是我要采用的一般方法。
您可以拥有已经访问过的数字的集合。您会喜欢以下内容：（如果该代码运行，那只是为了给您一个想法）
）public int[] compare(int[] first, int[] second) {
Set<Integer> numbersFoundInFirstArray = new LinkedHashSet<Integer>();
Set<Integer> numbersFoundInSecondArray = new LinkedHashSet<Integer>();
int inSameIndex = 0;
int inDifferentIndex = 0;
for (int i; i < first.length; i++) {
if (first[i] == second[i]) {
inSameIndex++;
}
if (numbersFoundInFirstArray.contains(second[i])) {
inDifferentIndex++;
}
if (numbersFoundInSecondArray.contains(first[i])) {
inDifferentIndex++;
}
numbersFoundInFirstArray.add(first[i]);
numbersFoundInSecondArray.add(second[i]);
}
return new int[] {inSameIndex, inDifferentIndex};
}
如果我很好，则包含集合中的比较具有O（1）。集合的属性是您只有一定类型的一个元素。因此，如果添加1两次，它将仅具有1个参考。此方式，您只能在另一个数组中找到当前数字时测试：）
检查参数只是好习惯。可能可以在这里进行一些较小的优化，但是哈希将使您存储您已经访问过的位置，以便不计算一次。
private int[] compare(int[] arr1, int[] arr2){
int same_index = 0;
Hashtable differences = new Hashtable();
int diff_count = 0;
if (arr1.length != arr2.length){
throw new IllegalArgumentException("Array Size is not identical.");
} else {
for(int count = 0; count < arr1.length; count++){
if (arr1[count] == arr2[count]{
same_index++;
differences.put(count, null);
} else {
for (int count2 = 0; count2 < arr1.length; count2++){
if(!differences.containsKey(count2) && arr1[count] == arr2[count2]){
differences.put(count2, null);
diff_count++;
}
}
}
}
}
int[] returnArray = new int[2];
returnArray[0] = same_count;
returnArray[1] = diff_count;
return (returnArray);
}
您需要将所有数组转换为类似树状的结构，该结构基本上将所有数组中的所有唯一值索引，并将指针存储在数组中的位置和哪个数组。该树的基本蓝图结构将是：
uniqElemVal->arrayIndx->arrayID = true
uniqelemval的1,3,5,2，1,3,5,5,2，2,3,4，2,3,2,2,4等，所有工会化
arrayindx将在第一个数组0中为1，为5为2和3等。
数组ID是任意的，可以让您键入每个数组，例如1对于第一个，第二个等等。
在这种情况下：
#1st array
1->0->1
3->1->1
5->2->1
5->3->1
2->4->1
#2nd array
2->0->2
3->1->2
3->2->2
2->3->2
2->4->2
4->5->2
然后，当您穿越这棵树时，每当您拥有一个超过1片叶子的第二级节点时，这意味着在多个阵列中特定位置中的该特定元素值匹配。
我会亲自将这棵树定义为
HashMap<Integer, HashMap<Integer, ArrayList<Integer>>>
因此，每当您有> 1个元素的叶片阵列列表时，这意味着您有匹配