Java中有序数组的索引

如何在Java中获得排序数组的索引

例如：

  int[] myIntArray = new int[]{20,100,69,4};

和Arrays.sortmyIntArray结果为：

{4,20,69,100}

如果需要原始数组的索引，该怎么办

这意味着：

---

{3,0,2,1}

如果我正确理解了你的问题

考虑到数组中没有重复项。在对数组排序之后

备选案文1：

编写一个小助手方法

将每个值传递给下面的方法并获取其索引

public int findIndex(int[] iarray, int value) {
    for(int i=0; i<iarray.length; i++) 
         if(iarray[i] == value)
             return i;
}

那么

---

如果要将这些索引存储在数组中，请获取具有初始数组长度的数组，并使用返回的索引填充该数组。

如果我正确理解了您的问题

考虑到数组中没有重复项。在对数组排序之后

备选案文1：

编写一个小助手方法

将每个值传递给下面的方法并获取其索引

public int findIndex(int[] iarray, int value) {
    for(int i=0; i<iarray.length; i++) 
         if(iarray[i] == value)
             return i;
}

那么

---

如果要将这些索引存储在数组中，请获取具有初始数组长度的数组，并用返回的索引填充该数组。

我认为一种方法是创建一个类intWithIndex。这样，您就可以快速跟踪索引

public class IntWithIndex implements Comparable<IntWithIndex>{
  public int value;
  public int index;

  @Override
  Public int compareTo(intWithIndex x) {
    return value - x.value;
  }
}

public Test {
  IntWithIndex[] myArray = ...
  myArray[].sort;
}

IntWithIndex[]。排序应该可以工作，您可以使用索引字段检查初始索引

---

你明白我的意思了吗？

我认为一种方法是创建一个类intWithIndex实现Comparable。这样，您就可以快速跟踪索引

public class IntWithIndex implements Comparable<IntWithIndex>{
  public int value;
  public int index;

  @Override
  Public int compareTo(intWithIndex x) {
    return value - x.value;
  }
}

public Test {
  IntWithIndex[] myArray = ...
  myArray[].sort;
}

IntWithIndex[]。排序应该可以工作，您可以使用索引字段检查初始索引

---

你明白我的意思了吗？

声明一个包含索引和值的类，并设置一个仅比较值的比较器

class IndexAndValue implements Comparable<IndexAndValue> {
    public int index;
    public int value;
    public IndexAndValue(int index, int value) {
        this.index = index;
        this.value = value;
    }
    @Override
    public int compareTo(IndexAndValue other) {
        return Integer.compareTo(value, other.value);
    }
}

现在，当您在myIVArray上调用sort时，它将使用比较器进行排序，这意味着它将比较这些值。但是结果数组包含IndexAndValue对象，这将使索引和值保持在一起

class IndexAndValue implements Comparable<IndexAndValue> {
    public int index;
    public int value;
    public IndexAndValue(int index, int value) {
        this.index = index;
        this.value = value;
    }
    @Override
    public int compareTo(IndexAndValue other) {
        return Integer.compareTo(value, other.value);
    }
}

p.S.没有测试，所以我可能弄错了一些语法

---

PPS。公共数据成员通常是邪恶的，但我认为对于像这样的一个小类来说，它的目的只是将几个值保存在一起是可以的。但是如果您不喜欢，请将它们设置为私有并使用访问器方法。

声明一个包含索引和值的类，并设置一个仅比较值的比较器

class IndexAndValue implements Comparable<IndexAndValue> {
    public int index;
    public int value;
    public IndexAndValue(int index, int value) {
        this.index = index;
        this.value = value;
    }
    @Override
    public int compareTo(IndexAndValue other) {
        return Integer.compareTo(value, other.value);
    }
}

现在，当您在myIVArray上调用sort时，它将使用比较器进行排序，这意味着它将比较这些值。但是结果数组包含IndexAndValue对象，这将使索引和值保持在一起

class IndexAndValue implements Comparable<IndexAndValue> {
    public int index;
    public int value;
    public IndexAndValue(int index, int value) {
        this.index = index;
        this.value = value;
    }
    @Override
    public int compareTo(IndexAndValue other) {
        return Integer.compareTo(value, other.value);
    }
}

p.S.没有测试，所以我可能弄错了一些语法

---

PPS。公共数据成员通常是邪恶的，但我认为对于像这样的一个小类来说，它的目的只是将几个值保存在一起是可以的。但如果您不喜欢，请将它们设置为私有并使用访问器方法。

除了@SURESH ATTA之外，您还可以使用它来定义数据结构，键将保存为索引，值将是整数

除了@SURESH ATTA之外，您还可以使用它来定义数据结构，键是另存为索引，值是整数

在不使用任何库的情况下获取排序值的索引数组。还要注意重复/多个数组元素

import java.util.Arrays;

public class IndexCal {

    public static void main(String args[]) {
        int[] myIntArray = new int[] { 20, 100, 69, 4, 20, 4, 100 };
        int[] copyArray = new int[myIntArray.length];
        System.arraycopy(myIntArray, 0, copyArray, 0, myIntArray.length);
        Arrays.sort(myIntArray);
        int[] indexArray = new int[myIntArray.length];
        Arrays.fill(indexArray, -1);
        for (int i = 0; i < copyArray.length; i++) {
            int skiplength = 0;
            int index = find(copyArray, myIntArray[i], 0);
            while(find(indexArray, index, 0) != -1){
                index = find(copyArray, myIntArray[i], skiplength++);
            }
            indexArray[i] = index;

        }

        for (int i = 0; i < copyArray.length; i++) {
            System.out.println(indexArray[i]);
        }

    }

    public static int find(int[] array, int value, int skiplength) {
        for (int i = 0; i < array.length; i++)
            if (array[i] == value)
                if(skiplength == 0)
                    return i;
                else
                    skiplength--;

        return -1;
    }
}

---

在不使用任何库的情况下获取排序值的indexArray。还要注意重复/多个数组元素

import java.util.Arrays;

public class IndexCal {

    public static void main(String args[]) {
        int[] myIntArray = new int[] { 20, 100, 69, 4, 20, 4, 100 };
        int[] copyArray = new int[myIntArray.length];
        System.arraycopy(myIntArray, 0, copyArray, 0, myIntArray.length);
        Arrays.sort(myIntArray);
        int[] indexArray = new int[myIntArray.length];
        Arrays.fill(indexArray, -1);
        for (int i = 0; i < copyArray.length; i++) {
            int skiplength = 0;
            int index = find(copyArray, myIntArray[i], 0);
            while(find(indexArray, index, 0) != -1){
                index = find(copyArray, myIntArray[i], skiplength++);
            }
            indexArray[i] = index;

        }

        for (int i = 0; i < copyArray.length; i++) {
            System.out.println(indexArray[i]);
        }

    }

    public static int find(int[] array, int value, int skiplength) {
        for (int i = 0; i < array.length; i++)
            if (array[i] == value)
                if(skiplength == 0)
                    return i;
                else
                    skiplength--;

        return -1;
    }
}

---

---

索引是常量。价值变化。请告诉我们，你们面临的实际问题是什么。我正在寻找一个函数，它返回原始矩阵的索引。假设：Arrays.ordermyIntArray={3,0,2,1}维护原始数组的副本，这将比创建包装类的开销更小。只需调用array.clone.index就可以了。价值变化。请告诉我们，你们面临的实际问题是什么。我正在寻找一个函数，它返回原始矩阵的索引。假设：Arrays.ordermyIntArray={3,0,2,1}维护原始数组的副本，这将比创建包装类的开销更小。只需调用array.clone.No:更多解释请No:更多解释请+1表示简单，但如果数组中有任何重复值，它将始终返回出现该值的第一个索引at@mdewitt：对于您提到的场景，我假设OP必须是智能的enuf才能遍历整个数组并保持找到的值的索引位置！！：@值得一提的是，+1表示简单，但如果数组中有任何重复值，它将始终返回值出现的第一个索引at@mdewitt：对于前面提到的场景，我假设OP必须是smart-enuf才能遍历整个数组并保持找到的值的索引位置！！：@mdewitt这一点值得一提。+1因为这涉及到为数组中的重复值返回正确的原始索引。如何生成IndexAndValue？构建包含索引和值的对象的IndexAndValue数组？？

---

+1因为这涉及为数组中的重复值返回正确的原始索引，所以如何生成IndexAndValue？构建包含索引和值的对象的IndexAndValue数组？？