Question

我需要对数组进行排序并获取链接到未排序数组的索引。问题是如果未排序的数组包含重复的条目，即[1,1,1,2,2,]，则这些条目的索引是相同的。对于示例[3,5,5,3,3,]，索引将为[0,1,1,0,0]。但我需要获得以下索引[0,3,4,1,2]。怎么做？

ArrayList<Double> nfit = new ArrayList<Double>();
ArrayList<Double> nfit_copy = new ArrayList<Double>(nfit);

// Fill nfit

Collections.sort(nfit);

int[] ind = new int[nfit.size()];

for (int n = 0; n < nfit.size(); n++){
    ind[n] = nfit_copy.indexOf(nfit.get(n));
}

Answer 1

这是因为您使用nfit_copy.indexOf(nfit.get(n));如果您有重复的数字，它将为您提供相同的索引

例如

[3,5,5,3,3,] ----＆GT;每次您使用：nfit.indexOf(3)时，都会给您索引0

所以，您可能需要更改此值或将其设置为null（不要因为它会更改索引而重新删除它），以允许您获取下一个重复的数字

试试这个：

ArrayList<Integer> nfit = new ArrayList<Integer>();
ArrayList<Integer> nfit_copy = new ArrayList<Integer>(nfit);

// Fill nfit 

  nfit.add(3);
  nfit.add(5);
  nfit.add(5);
  nfit.add(3);
  nfit.add(3);


  nfit_copy = (ArrayList<Integer>) nfit.clone();


  Collections.sort(nfit);

  int[] ind = new int[nfit.size()];

  for (int n = 0; n < nfit.size(); n++) {
         ind[n] = nfit_copy.indexOf(nfit.get(n));
         nfit_copy.set(nfit_copy.indexOf(nfit.get(n)), null);
   }
   for (int i = 0; i < ind.length; i++) {
         int j = ind[i];
         System.out.println(j);
    }

Answer 2

public static void main(String[] args) {
        Integer[] input = new Integer[]{1,2,2,1,5,6,2,3,2,3,4,5,6,1};
        List<Integer> mappedIndexes = new ArrayList<Integer>();

        List<Integer> sorted = new ArrayList<Integer>();
        for (int num : input) {
            sorted.add(num);
        }       
        Collections.sort(sorted);

        for (int number : input) {
            System.out.println("finding for input -> " + number);
            for (int i = 0; i < sorted.size(); i++) {
                int sortedNumber = sorted.get(i);
                if (number == sortedNumber) {
                    if (mappedIndexes.contains(i)) {
                        continue;
                    } else {
                        System.out.println("setting index as -> " + i);
                        mappedIndexes.add(i);
                        break;
                    }
                }
            }
        }
        System.out.println(mappedIndexes);
    }

Answer 3

以下是我的Set和HashMap结构的解决方案。请阅读代码注释以获取更多信息。

int[] input = { 45, 3, 4, 9, 2, 1, 45, 3 };
// Backup the initial array for later use.
int[] originalArray = Arrays.copyOf(input, input.length);    
Arrays.sort(input);

// Determine all occurences with a set.
Set<Integer> set = new HashSet<Integer>();
for (int i : input) {
    set.add(i);
}

// Populate a hashmap for keeping <value,index> pairs.
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
int counter = 0;
for (int i : set) {
    map.put(i, counter++);
}

// Populate the output array.
int[] output = new int[input.length];
for (int i = 0; i < output.length; i++) {
    output[i] = map.get(originalArray[i]);
}

这就是全部。如果您将output的内容打印到控制台，则可以看到结果。

在使用重复条目对数组进行排序后获取唯一索引

3 个答案: