Clash Royale CLAN TAG#URR8PPP

Sorting algortithm with index in java

I have a set of values for srting algorithm. I have successfully sorted them out. But I also want to have the index for each element after sorting. For example like :

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


I have used the following logic for sorting. But unable to get the indexes

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;



[10, 24, 53, 95]

6 Answers
6

As this is probably homework, just some ideas:

Alternatively, you could look into introducing a helpful data structure, such as a Pair<Integer, Integer> class. The first entry represents the value, the second one an index. Then you can define your own "sorting" on that class.

Pair<Integer, Integer>

[95, 0, 53, 1, 24, 2, 10, 3]

As previously suggested, I would also recommend using an additional Item class which stores the item on which you want to sort and the initial index:

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);




When you need to sort the array of doubles, you first create an ArrayList containing the Items which store the doubles of the input array and the initial index. Since the Item class implements the Comparable interface, you can use Collections.sort for sorting (which will be faster than your bubblesort implementation):

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);



Try this:

Pair

class Pair
int val;
int index;


class Pair
int val;
int index;


sort it by valuez

valuez

index will keep the initial index

index

I have just tried the following and it worked.

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;


}


and it worked. Is this also correct way of doing? I am new to Java. I am at a very basic stage.

I would suggest below approach:

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);





Here you find the old index and shorted value

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));


//output 10=3, 24=2, 53=1, 95=0

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.