java中带索引的排序算法

Question

我有一组 srting 算法的值。 我已经成功地把它们整理出来了。 但我也想在排序后为每个元素提供索引。 例如像：

Array = [95, 53, 24, 10]
Output after sorting should be like :
10 at index 3, 24 at index 2, 53 at index 1 and 95 at index 0

我使用以下逻辑进行排序。 但无法获得索引

for (int p = 0; p < ((list.size()) - 1); p++) {
    int min = p;                 
    count++;

    for(int q=p+1; q<list.size();q++) {
        if(doubleArray[q] < doubleArray[min]) {
            min = q;
        }
    }

    double smallNumber = doubleArray[p];
    doubleArray[p] = doubleArray[min];
    doubleArray[min] = smallNumber;                  
}

Answer 1

由于这可能是家庭作业，所以只是一些想法：

• 在排序之前，创建初始数组的副本
• 排序后，迭代原始数组，然后找到排序数组中每个值的索引，并打印出来
• 棘手的部分是处理重复出现的值。 但这取决于您的确切要求。

或者，您可以考虑引入一个有用的数据结构，例如Pair<Integer, Integer>类。 第一个条目表示值，第二个条目表示索引。 然后您可以在该类上定义自己的“排序”。

Answer 2

如前所述，我还建议使用额外的Item类来存储您要排序的项目和初始索引：

public class Item<T extends Comparable<T>> implements Comparable<Item<T>> {
    public final T item;
    public final int index;

    public Item(T item, int index) {
        if (item == null)
            throw new NullPointerException("the given item is null!");
        this.item = item;
        this.index = index;
    }

    @Override
    public int compareTo(Item<T> t) {
        if (t == null)
            return 1;
        return item.compareTo(t.item);
    }
}

当您需要对双精度数组进行排序时，您首先创建一个ArrayList其中包含存储输入数组的双精度和初始索引的Items 。 由于Item类实现了Comparable接口，您可以使用Collections.sort进行排序（这将比您的冒泡排序实现更快）：

public static void sort(Integer... array) {
    List<Item<Integer>> copy = new ArrayList<Item<Integer>>(array.length);

    // copy the input array
    for (int i = 0; i < array.length; ++i)
        copy.add(new Item<Integer>(array[i], i));


    Collections.sort(copy);

    for (Item<Integer> t : copy)
        System.out.println(t.item + " at index " + t.index);
}

Answer 3

尝试这个：

2. 创建一个Pair类

class Pair { int val; int index; }

2. 按valuez排序

3. index将保留初始索引

Answer 4

我刚刚尝试了以下方法并且有效。

int[] index = {0,1,2,3}
for (int p=0;p<((list.size())-1);p++) 
                 {
                     int min = p;
                     
                     count++;
                     for(int q=p+1; q<list.size();q++) 
                     {
                        if(doubleArray[q]< doubleArray[min])
                        {
                            min = q;
                        }
                     }
                     double smallNumber = doubleArray[p];
                     doubleArray[p] = doubleArray[min];
                     doubleArray[min] = smallNumber;
                     
                     store = index[p];
                     index[p] = index[min];
                     index[min] = store;
                    
                 }
}

它奏效了。

Answer 5

我会建议以下方法：

    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.SortedSet;
    import java.util.TreeSet;

    public class trial
    {
     public static void main(String[] args)
     {
    List<Integer> aList = Arrays.asList(95, 53, 24, 10);
    Map<Integer, Integer> aMap = new HashMap<>();

    int index = 0;
    for( Integer aInteger : aList )
    {
      aMap.put(aInteger, index);
      index++;
    }

    SortedSet<Integer> keys = new TreeSet<>(aMap.keySet());

    for( Integer key : keys )
    {
      Integer value = aMap.get(key);
      System.out.println(key + " at index " + value);
     }
    }
    }

Answer 6

在这里您可以找到旧指数和卖空值

Map<Integer, Integer> map1 = numbers.stream().collect(Collectors.toMap(i -> i, i -> numbers.indexOf(i))).           entrySet().stream().sorted(Map.Entry.comparingByKey()).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                        (oldValue, newValue) -> oldValue, LinkedHashMap::new));

//输出{10=3, 24=2, 53=1, 95=0}