Java ArrayList：查找整数的第n个匹配项

在ArrayList中查找第n个数字的最佳方法是什么

我已经知道了什么？

  public static void main(String[] args)
  {
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(1);
    int length = list.size();
    int firstIndex = list.indexOf(1) + 1;
    int secondIndex = firstIndex + list.subList(firstIndex, length).indexOf(1) + 1;
    System.out.println(firstIndex);
    System.out.println(secondIndex);
  }

要查找数字，列表接口中有一个方法，该方法在ArrayList类中实现

要找到第一次出现，有一种方法

我在解决什么问题？

  public static void main(String[] args)
  {
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(1);
    int length = list.size();
    int firstIndex = list.indexOf(1) + 1;
    int secondIndex = firstIndex + list.subList(firstIndex, length).indexOf(1) + 1;
    System.out.println(firstIndex);
    System.out.println(secondIndex);
  }

在一个问题中，有一个具有不同数字的列表，我必须返回两个数字的索引，其和等于目标数字。 例如：

List=（1,2,1）和target=2
现在
1+1=2
答案将是第一个1和第二个1的索引

注意：我已经解决了这个问题&我需要在
顶部

我做了什么？

  public static void main(String[] args)
  {
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(1);
    int length = list.size();
    int firstIndex = list.indexOf(1) + 1;
    int secondIndex = firstIndex + list.subList(firstIndex, length).indexOf(1) + 1;
    System.out.println(firstIndex);
    System.out.println(secondIndex);
  }

publicstaticvoidmain（字符串[]args）
{
列表=新的ArrayList（）；
增加第（1）款；
增加（2）；
增加第（1）款；
int length=list.size（）；
int firstIndex=list.indexOf（1）+1；
int secondIndex=firstIndex+list.subList（firstIndex，length.indexOf（1）+1；
System.out.println（firstIndex）；
System.out.println（第二个索引）；
}
“所有数字相等的列表”
-->{n，n，…，n，n}

“我必须返回其和等于目标数的前两个数的索引”让我们假设目标=x。
由于列表中的数字相等，如果x/2=n，索引将分别为0和1，如果x/2=你不会有对手的


问题后编辑


int-length=10；
int目标=100；
int[]tab1=新的int[长度]；
Object[]tab2=新对象[长度]；
Object[]tab2Sorted=新对象[长度]；
对于（int i=0；i目标/2）{
打破
}
}

您只需将tab2和tab2Sorted类型从Object更改为自定义类型保存第一个选项卡中的int和his索引
对于标题中的问题，您只需将循环与List的子列表方法结合使用即可：

public static void main(String[] args)
{
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(1);
    list.add(1);

    int n = 2;
    int index = -1;
    List<Integer> subList = list;

    for( int i = 0; i < n; i++)
    {
        index = subList.indexOf( 1);

        if( index == -1)
            break;

        System.out.println( i + "th index: " + index);
        subList = subList.subList( index+1, subList.size());
    }
}

publicstaticvoidmain（字符串[]args）
{
列表=新的ArrayList（）；
增加第（1）款；
增加第（1）款；
增加第（1）款；
int n=2；
int指数=-1；
列表子列表=列表；
对于（int i=0；i

对于真正的问题，在列表中查找第n个数字并不是一种可靠的方法，您假设重复数组元素是目标数字的除数。
public static int nthIndexOf（list list，int-needle，int-n）{
public static int nthIndexOf(List<Integer> list, int needle, int n){
    for (int i = 0; i < list.size(); i++) {
        if (list.get(i) == needle) {
            n--;
            if (n == 0) {
                return i;
            }
        }
    }
    return -1;
}

对于（int i=0；i

假设您的列表不是一个列表，而是一个数组（一旦插入内容，arraylist基本上就是一个数组）

还假设您不想找到前两个num的索引，它们的总和为X，而只是两个num（如果有的话）

有一个简单的解决方案需要O（n^2）时间，你只需用后面的所有数字迭代每个数字，然后检查总和

更好的方法是对数组进行排序（需要O（n*logn））。现在，您可以对每个数字在数组中进行二进制搜索，查找其补码，即如果将该数字相加，将得到X。这需要n（每个数字）*logn（二进制搜索其补码）

但是我们不能排序，因为我们需要索引！还是我们不能

如果我们创建一个数组的副本，而不仅仅是值，它存储一对值+原始位置，该怎么办

class PosAndValue {
  public final int value;
  public final int pos;
  public PosAndValue(int v, int p) {
    value = v;
    pos = p;
  }
} 

我们现在可以对这些PosAndValue的数组按其值排序，执行刚才提到的算法，然后检索原始位置（即索引），所有这些都是n*logn时间复杂度（和n空间复杂度）

就复杂性而言，我很有信心，你不可能让它变得更快。请注意，这并不意味着代码在任何情况下都会更快，相反，对于足够大的输入（即“足够大”的数组），它会更快！例如，对于小输入，所有这些开销实际上可能会使代码变慢

如果您知道输入的范围有限，然后对值执行布尔位图O（n），则可以使效果更好，但这是一个未指定的约束
 
publicstaticvoidmain（字符串[]args）
  public static void main(String[] args)
  {
    Integer[] numbersList = {1,2,3,4,5,6,7,8,9,10}; //Load your Array here
    List<Integer> list = Arrays.asList(numbersList);
    int targetNumber = 8;  //Load your targetNumber here

    int currrentVal = 0;
    int nextVal = 0;
    int i = 0;
    int j = 0;
    boolean found = false;
    for(i=0;i<list.size();i++) {
        currrentVal = list.get(i);          
        for(j=currrentVal+1;j<list.size();j++) {
            nextVal = list.get(j);              
            if(targetNumber == currrentVal+nextVal) {
                found = true;
                break;
            }
        }
        if(found) {
            break;
        }
    }
    if(found) {
        System.out.println("firstIndex  : "+i);
        System.out.println("secondIndex : "+j);
    } else {
        System.out.println(" No match found");
    }
  }

{
整数[]numbersList={1,2,3,4,5,6,7,8,9,10}；//在此处加载数组
List=Arrays.asList（numbersList）；
int targetNumber=8；//在此处加载您的targetNumber
int currentval=0；
int nextVal=0；
int i=0；
int j=0；
布尔值=false；
对于（i=0；i您可以构建这样的东西

List<Integer> numbers = new ArrayList<>(); // your list of numbers. Let's say it's {1, 1, 4, 5, 4}
numbers.add(1);
numbers.add(1);
numbers.add(4);
numbers.add(5);
numbers.add(4);
SparseArray<Set<Integer>> occurrences = new SparseArray<>();
for (int i = 0; i < numbers.size(); i++) {
    if (occurrences.indexOfKey(numbers.get(i)) < 0) {
        occurrences.put(numbers.get(i), new HashSet<Integer>());
    }
    Set<Integer> ints = occurrences.get(numbers.get(i)); // get current set
    ints.add(i); // add your new found one
    occurrences.put(numbers.get(i), ints); // put it back into your occurrences set
}

这应该是最有效的。它使用数组的排序版本（保留对原始偏移量的引用）和集合。binarySearch应提供最佳性能

private Integer[] addsUp(List<Integer> numbers, int value) {
    // Hold the value and it's original offset.
    class No implements Comparable<No> {

        final int n;
        final int o;

        public No(int n, int o) {
            this.n = n;
            this.o = o;
        }

        public No(int n) {
            this(n, -1);
        }

        @Override
        public int compareTo(No o) {
            return Integer.compare(n, o.n);
        }

        @Override
        public String toString() {
            return "{" + n + " @ " + o + "}";
        }
    };
    // Build my list.
    List<No> myNumbers = new ArrayList(numbers.size());
    for (int i = 0; i < numbers.size(); i++) {
        myNumbers.add(new No(numbers.get(i), i));
    }
    // Start sorted.
    Collections.sort(myNumbers);
    // Upper limit of my search.
    int max;
    // Find the value in the numbers.
    No no = new No(value);
    int spot = Collections.binarySearch(myNumbers, no);
    // Did we find it?
    if (spot < 0) {
        // Not found - but this number is nearest to value.
        max = -spot - 1;
    } else {
        // Found ! No number higher than that is relevant.
        max = spot;
    }
    // For each start number.
    for (int first = 0; first < max; first++) {
        No remainder = new No(value - myNumbers.get(first).n);
        // Does that number appear in the list.
        int second = Collections.binarySearch(myNumbers, remainder);
        if (second >= 0) {
            // Found second number! Return original offsets.
            return new Integer[]{myNumbers.get(first).o, myNumbers.get(second).o};
        }
    }
    return null;
}

public void test() {
    List<Integer> numbers = Arrays.asList(1, 2, 1);
    Integer[] two = addsUp(numbers, 2);
    System.out.println("two = " + Arrays.toString(two));
    Integer[] three = addsUp(numbers, 3);
    System.out.println("three = " + Arrays.toString(three));
}

private Integer[]addsUp（列表编号，int值）{
//保留该值及其原始偏移量。
类号{
最终整数n；
最终INTO；
公共编号（整数n，整数o）{
这个，n=n；
这个。o=o；
}
公共编号（int n）{
这（n，-1）；
}
@凌驾
公共整数比较（无o）{
返回整数。比较（n，o.n）；
}
@凌驾
公共字符串toString（）{
返回“{”+n+“@”+o+“}”；
}
};
//建立我的清单。
List myNumbers=newarraylist（numbers.size（））；
for（int）