数组中重复数最小索引的返回值 [英] Return value of smallest index of repeated number in array
本文介绍了数组中重复数最小索引的返回值的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我有一个整数数组，我想从中返回出现次数最小的索引值。
Integer [ ] array = {8,2,10,7,2,10};
因此，在这种情况下，如果我寻找数字2，我发现2被包含在 array [1] 和 array [4] 。我在管理数组时有些失落。
到目前为止，我所做的就是检查给定的数字是否存在
public int exist（整数number）{
int index = 0;
int位置= 0;
while（position< = array.length&& number == array [position]）{
index = index + 1;
if（index< = array.length）{
index = position;
} else {
index = -1;
}
}
回报指数；
}
我从Internet上找到了这段代码，该代码找到了数组中的第一个重复元素整数
class Main {
//此函数打印arr []中的第一个重复元素[]
static void printFirstRepeating（int arr []）{
//初始化第一个重复元素
的索引int min = -1;
//创建一个空的哈希集
HashSet< Integer> set = new HashSet<>（）;
//对于（int i = arr.length-1; i> = 0; i--）从右向左遍历输入数组
{
//如果元素已经在哈希集中，如果（set.contains（arr [i]））
min = i ;，则更新最小值
；
else //将其他元素添加到哈希集
set.add（arr [i]）;
}
//如果（min！= -1）
System.out.println（第一个重复元素是 + arr [min]）;则打印结果
else
System.out.println（没有重复的元素）;
}
//用于测试上述方法的驱动程序方法
public static void main（String [] args）抛出java.lang.Exception {
int arr [] = {10，5，3，4，3，5，6};
printFirstRepeating（arr）; //输出5
}
}
我仍然无法合并
解决方案
在您的编码示例中 10，5 ，3、4、3、5、6 ，重复的第一个 值是索引4处的 3 索引2中 3 的值。另一个重复值是索引5中的 5 ，重复 5 位于索引1。
插图：
索引4：3的10、5、3、4、3、5、6
↑是索引2：3的第一个重复值
↑在索引5：5第一次在这里找到
↑是在索引1 1：5的第二个重复值
↑在这里第一次找到
因此，可能的结果取决于您的实际需求：
- 4，索引首次重复值
- 2，第一个重复的值的索引
- 1，重复值的第一个索引
以下是这三个解决方案：
私有静态无效printIndexOfFirstRepeated（int ... values）{
Set< Integer> set = new HashSet<>（）;
for（int i = 0; i< values.length; i ++）
if（！set.add（values [i]））{// add（）返回false
System.out.println（第一次重复的索引： + i）;
的回报；
}
System.out.println（找不到重复）;
}
私有静态无效printIndexOfRepeatedFirst（int ... values）{
Map< Integer，Integer> mapValueToIndex = new HashMap<>（）;
for（int i = 0; i
System.out.println（重复的第一个索引： + prevIndex）;
的回报；
}
}
System.out.println（找不到重复）;
}
私有静态无效printFirstIndexOfRepeated（int ... values）{
整数firstIndex = null;
Map< Integer，Integer> mapValueToIndex = new HashMap<>（）;
for（int i = 0; i
firstIndex = prevIndex ;，则返回null
；
}
if（firstIndex！= null）
System.out.println（重复的第一个索引： + firstIndex）;
else
System.out.println（找不到重复）;
}
测试
printIndexOfFirstRepeated（10、5、3、4、3、5、6）;
printIndexOfRepeatedFirst（10，5，3，4，3，5，6）;
printFirstIndexOfRepeated（10，5，3，4，3，5，6）;
输出
<
第一次重复的索引：4
第一次重复的索引：2
第一次重复的索引：1
I have an array of Integer from which I want to return the index value of the smallest number appearence.
Integer[] array = {8,2,10,7,2,10};
So, in this case if I look for number 2, i find that 2 is contained in array[1] and array[4]. I'm a little bit lost in managing an array.
What I have done so far is to check if the given number exists
public int exist( Integer number ) {
int index = 0;
int position = 0;
while (position <= array.length && number == array[position]){
index = index + 1;
if( index <= array.length ){
index = position ;
} else {
index = -1;
}
}
return index ;
}
and I find from Internet this code which finds the first repeating element in an array of integers
class Main {
// This function prints the first repeating element in arr[]
static void printFirstRepeating(int arr[]) {
// Initialize index of first repeating element
int min = -1;
// Creates an empty hashset
HashSet<Integer> set = new HashSet<>();
// Traverse the input array from right to left
for (int i=arr.length-1; i>=0; i--) {
// If element is already in hash set, update min
if (set.contains(arr[i]))
min = i;
else // Else add element to hash set
set.add(arr[i]);
}
// Print the result
if (min != -1)
System.out.println("The first repeating element is " + arr[min]);
else
System.out.println("There are no repeating elements");
}
// Driver method to test above method
public static void main (String[] args) throws java.lang.Exception {
int arr[] = {10, 5, 3, 4, 3, 5, 6};
printFirstRepeating(arr); // output 5
}
}
I'm still unable to combine this code with the first to get what I really want.
解决方案
In your coded example 10, 5, 3, 4, 3, 5, 6, the first repeated value is 3 at index 4, a repeat of the 3 at index 2. The other repeated value is 5 at index 5, a repeat of the 5 at index 1.
Illustrated:
10, 5, 3, 4, 3, 5, 6
↑ at index 4: 3 is first repeated value
↑ at index 2: 3 was first found here
↑ at index 5: 5 is second repeated value
↑ at index 1: 5 was first found here
So, possible results, depending on what you really want:
- 4, index of first repeated value
- 2, index of value that is repeated first
- 1, first index of a repeated value
Here are solutions for all three:
private static void printIndexOfFirstRepeated(int ... values) {
Set<Integer> set = new HashSet<>();
for (int i = 0; i < values.length; i++)
if (! set.add(values[i])) { // add() returns false if value already in set
System.out.println("Index of first repeated: " + i);
return;
}
System.out.println("No repeat found");
}
private static void printIndexOfRepeatedFirst(int ... values) {
Map<Integer, Integer> mapValueToIndex = new HashMap<>();
for (int i = 0; i < values.length; i++) {
Integer prevIndex = mapValueToIndex.put(values[i], i); // put() returns old value, or null
if (prevIndex != null) {
System.out.println("Index of repeated first: " + prevIndex);
return;
}
}
System.out.println("No repeat found");
}
private static void printFirstIndexOfRepeated(int ... values) {
Integer firstIndex = null;
Map<Integer, Integer> mapValueToIndex = new HashMap<>();
for (int i = 0; i < values.length; i++) {
Integer prevIndex = mapValueToIndex.put(values[i], i); // put() returns old value, or null
if (prevIndex != null && (firstIndex == null || prevIndex < firstIndex))
firstIndex = prevIndex;
}
if (firstIndex != null)
System.out.println("First index of repeated: " + firstIndex);
else
System.out.println("No repeat found");
}
TEST
printIndexOfFirstRepeated(10, 5, 3, 4, 3, 5, 6);
printIndexOfRepeatedFirst(10, 5, 3, 4, 3, 5, 6);
printFirstIndexOfRepeated(10, 5, 3, 4, 3, 5, 6);
OUTPUT
Index of first repeated: 4
Index of repeated first: 2
First index of repeated: 1
这篇关于数组中重复数最小索引的返回值的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
