Java Tri par tableau: moyen rapide d'obtenir une liste triée des index d'un tableau
Le problème: considérez les flottants suivants []:
d[i] = 1.7 -0.3 2.1 0.5
Ce que je veux, c'est un tableau d'int [] qui représente l'ordre du tableau d'origine avec des indices.
s[i] = 1 3 0 2
d[s[i]] = -0.3 0.5 1.7 2.1
Bien sûr, cela pourrait être fait avec un comparateur personnalisé, un ensemble trié d'objets personnalisés, ou simplement en triant le tableau puis en recherchant les indices dans le tableau d'origine (frisson).
Ce que je recherche en fait, c'est l'équivalent du second argument de retour de fonction de tri de Matlab .
Existe-t-il un moyen facile de le faire (<5 LOC)? Peut-il y avoir une solution qui n'a pas besoin d'allouer un nouvel objet pour chaque élément?
Mettre à jour:
Merci pour vos réponses. Malheureusement, rien de ce qui a été proposé jusqu'à présent ne ressemble à la solution simple et efficace que j'espérais. J'ai donc ouvert un fil dans le forum de feedback JDK, proposant l'ajout d'une nouvelle fonction de bibliothèque de classes pour résoudre le problème. Permet de voir ce que Sun/Oracle pense du problème.
http://forums.Java.net/jive/thread.jspa?threadID=62657&tstart=
Je voudrais adapter l'algorithme de tri rapide pour effectuer l'opération d'échange sur plusieurs tableaux en même temps: le tableau d'index et le tableau de valeurs. Par exemple (basé sur ceci quicksort ):
public static void quicksort(float[] main, int[] index) {
quicksort(main, index, 0, index.length - 1);
}
// quicksort a[left] to a[right]
public static void quicksort(float[] a, int[] index, int left, int right) {
if (right <= left) return;
int i = partition(a, index, left, right);
quicksort(a, index, left, i-1);
quicksort(a, index, i+1, right);
}
// partition a[left] to a[right], assumes left < right
private static int partition(float[] a, int[] index,
int left, int right) {
int i = left - 1;
int j = right;
while (true) {
while (less(a[++i], a[right])) // find item on left to swap
; // a[right] acts as sentinel
while (less(a[right], a[--j])) // find item on right to swap
if (j == left) break; // don't go out-of-bounds
if (i >= j) break; // check if pointers cross
exch(a, index, i, j); // swap two elements into place
}
exch(a, index, i, right); // swap with partition element
return i;
}
// is x < y ?
private static boolean less(float x, float y) {
return (x < y);
}
// exchange a[i] and a[j]
private static void exch(float[] a, int[] index, int i, int j) {
float swap = a[i];
a[i] = a[j];
a[j] = swap;
int b = index[i];
index[i] = index[j];
index[j] = b;
}
Solution simple pour créer un tableau d'indexation: triez l'indexeur en comparant les valeurs des données:
final Integer[] idx = { 0, 1, 2, 3 };
final float[] data = { 1.7f, -0.3f, 2.1f, 0.5f };
Arrays.sort(idx, new Comparator<Integer>() {
@Override public int compare(final Integer o1, final Integer o2) {
return Float.compare(data[o1], data[o2]);
}
});
Créer un TreeMap de valeurs aux index
float[] array = new float[]{};
Map<Float, Integer> map = new TreeMap<Float, Integer>();
for (int i = 0; i < array.length; ++i) {
map.put(array[i], i);
}
Collection<Integer> indices = map.values();
les indices seront triés par les flottants vers lesquels ils pointent, le tableau d'origine est intact. Conversion du Collection<Integer> à un int[] est laissé comme exercice si c'est vraiment nécessaire.
EDIT: Comme indiqué dans les commentaires, cette approche ne fonctionne pas s'il y a des valeurs en double dans le tableau flottant. Ceci peut être résolu en faisant Map<Float, Integer> dans une Map<Float, List<Integer>> bien que cela complique légèrement l'intérieur de la boucle for et la génération de la collection finale.
L'utilisation de Java 8 fonctionnalités (sans bibliothèque supplémentaire), manière concise d'y parvenir.
int[] a = {1,6,2,7,8}
int[] sortedIndices = IntStream.range(0, a.length)
.boxed().sorted((i, j) -> a[i] - a[j])
.mapToInt(ele -> ele).toArray();
Avec Java fonctionnel :
import static fj.data.Array.array;
import static fj.pre.Ord.*;
import fj.P2;
array(d).toStream().zipIndex().sort(p2Ord(doubleOrd, intOrd))
.map(P2.<Double, Integer>__2()).toArray();
Le cas plus général de réponse de Jherico qui autorise les valeurs en double serait le suivant:
// Assuming you've got: float[] array; defined already
TreeMap<Float, List<Integer>> map = new TreeMap<Float, List<Integer>>();
for(int i = 0; i < array.length; i++) {
List<Integer> ind = map.get(array[i]);
if(ind == null){
ind = new ArrayList<Integer>();
map.put(array[i], ind);
}
ind.add(i);
}
// Now flatten the list
List<Integer> indices = new ArrayList<Integer>();
for(List<Integer> arr : map.values()) {
indices.addAll(arr);
}
public static int[] indexSort(final double[] v, boolean keepUnsorted) {
final Integer[] II = new Integer[v.length];
for (int i = 0; i < v.length; i++) II[i] = i;
Arrays.sort(II, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Double.compare(v[o1],v[o2]);
}
});
int[] ii = new int[v.length];
for (int i = 0; i < v.length; i++) ii[i] = II[i];
if (!keepUnsorted) {
double[] clon = v.clone();
for (int i = 0; i < v.length; i++) v[i] = clon[II[i]];
}
return ii;
}
La meilleure solution serait dans le sens de qsort de C, qui vous permet de spécifier des fonctions de comparaison et d'échange, donc qsort n'a pas besoin de connaître le type ou l'organisation des données en cours de tri. En voici une que vous pouvez essayer. Puisque Java n'a pas de fonctions, utilisez la classe interne Array pour encapsuler le tableau ou la collection à trier. Ensuite, encapsulez cela dans un IndexArray et triez. Le résultat de getIndex () sur l'IndexArray sera un tableau d'index comme décrit dans JavaDoc.
public class QuickSortArray {
public interface Array {
int cmp(int aindex, int bindex);
void swap(int aindex, int bindex);
int length();
}
public static void quicksort(Array a) {
quicksort(a, 0, a.length() - 1);
}
public static void quicksort(Array a, int left, int right) {
if (right <= left) return;
int i = partition(a, left, right);
quicksort(a, left, i-1);
quicksort(a, i+1, right);
}
public static boolean isSorted(Array a) {
for (int i = 1, n = a.length(); i < n; i++) {
if (a.cmp(i-1, i) > 0)
return false;
}
return true;
}
private static int mid(Array a, int left, int right) {
// "sort" three elements and take the middle one
int i = left;
int j = (left + right) / 2;
int k = right;
// order the first two
int cmp = a.cmp(i, j);
if (cmp > 0) {
int tmp = j;
j = i;
i = tmp;
}
// bubble the third down
cmp = a.cmp(j, k);
if (cmp > 0) {
cmp = a.cmp(i, k);
if (cmp > 0)
return i;
return k;
}
return j;
}
private static int partition(Array a, int left, int right) {
int mid = mid(a, left, right);
a.swap(right, mid);
int i = left - 1;
int j = right;
while (true) {
while (a.cmp(++i, right) < 0)
;
while (a.cmp(right, --j) < 0)
if (j == left) break;
if (i >= j) break;
a.swap(i, j);
}
a.swap(i, right);
return i;
}
public static class IndexArray implements Array {
int[] index;
Array a;
public IndexArray(Array a) {
this.a = a;
index = new int[a.length()];
for (int i = 0; i < a.length(); i++)
index[i] = i;
}
/**
* Return the index after the IndexArray is sorted.
* The nested Array is unsorted. Assume the name of
* its underlying array is a. The returned index array
* is such that a[index[i-1]] <= a[index[i]] for all i
* in 1..a.length-1.
*/
public int[] index() {
int i = 0;
int j = index.length - 1;
while (i < j) {
int tmp = index[i];
index[i++] = index[j];
index[j--] = tmp;
}
int[] tmp = index;
index = null;
return tmp;
}
@Override
public int cmp(int aindex, int bindex) {
return a.cmp(index[aindex], index[bindex]);
}
@Override
public void swap(int aindex, int bindex) {
int tmp = index[aindex];
index[aindex] = index[bindex];
index[bindex] = tmp;
}
@Override
public int length() {
return a.length();
}
}
Une autre solution non simple. Voici une version de tri par fusion qui est stable et ne modifie pas le tableau source, bien que la fusion nécessite de la mémoire supplémentaire.
public static int[] sortedIndices(double[] x) {
int[] ix = new int[x.length];
int[] scratch = new int[x.length];
for (int i = 0; i < ix.length; i++) {
ix[i] = i;
}
mergeSortIndexed(x, ix, scratch, 0, x.length - 1);
return ix;
}
private static void mergeSortIndexed(double[] x, int[] ix, int[] scratch, int lo, int hi) {
if (lo == hi)
return;
int mid = (lo + hi + 1) / 2;
mergeSortIndexed(x, ix, scratch, lo, mid - 1);
mergeSortIndexed(x, ix, scratch, mid, hi);
mergeIndexed(x, ix, scratch, lo, mid - 1, mid, hi);
}
private static void mergeIndexed(double[] x, int[] ix, int[] scratch, int lo1, int hi1, int lo2, int hi2) {
int i = 0;
int i1 = lo1;
int i2 = lo2;
int n1 = hi1 - lo1 + 1;
while (i1 <= hi1 && i2 <= hi2) {
if (x[ix[i1]] <= x[ix[i2]])
scratch[i++] = ix[i1++];
else
scratch[i++] = ix[i2++];
}
while (i1 <= hi1)
scratch[i++] = ix[i1++];
while (i2 <= hi2)
scratch[i++] = ix[i2++];
for (int j = lo1; j <= hi1; j++)
ix[j] = scratch[j - lo1];
for (int j = lo2; j <= hi2; j++)
ix[j] = scratch[(j - lo2 + n1)];
}
Je voudrais l'utiliser car il est très rapide, mais je l'utilise pour int, vous pouvez le changer pour flotter.
private static void mergeSort(int[]array,int[] indexes,int start,int end){
if(start>=end)return;
int middle = (end-start)/2+start;
mergeSort(array,indexes,start,middle);
mergeSort(array,indexes,middle+1,end);
merge(array,indexes,start,middle,end);
}
private static void merge(int[]array,int[] indexes,int start,int middle,int end){
int len1 = middle-start+1;
int len2 = end - middle;
int leftArray[] = new int[len1];
int leftIndex[] = new int[len1];
int rightArray[] = new int[len2];
int rightIndex[] = new int[len2];
for(int i=0;i<len1;++i)leftArray[i] = array[i+start];
for(int i=0;i<len1;++i)leftIndex[i] = indexes[i+start];
for(int i=0;i<len2;++i)rightArray[i] = array[i+middle+1];
for(int i=0;i<len2;++i)rightIndex[i] = indexes[i+middle+1];
//merge
int i=0,j=0,k=start;
while(i<len1&&j<len2){
if(leftArray[i]<rightArray[j]){
array[k] = leftArray[i];
indexes[k] = leftIndex[i];
++i;
}
else{
array[k] = rightArray[j];
indexes[k] = rightIndex[j];
++j;
}
++k;
}
while(i<len1){
array[k] = leftArray[i];
indexes[k] = leftIndex[i];
++i;++k;
}
while(j<len2){
array[k] = rightArray[j];
indexes[k] = rightIndex[j];
++j;++k;
}
}
Je ferais quelque chose comme ça:
public class SortedArray<T extends Comparable<T>> {
private final T[] tArray;
private final ArrayList<Entry> entries;
public class Entry implements Comparable<Entry> {
public int index;
public Entry(int index) {
super();
this.index = index;
}
@Override
public int compareTo(Entry o) {
return tArray[index].compareTo(tArray[o.index]);
}
}
public SortedArray(T[] array) {
tArray = array;
entries = new ArrayList<Entry>(array.length);
for (int i = 0; i < array.length; i++) {
entries.add(new Entry(i));
}
Collections.sort(entries);
}
public T getSorted(int i) {
return tArray[entries.get(i).index];
}
public T get(int i) {
return tArray[i];
}
}
Voici une méthode basée sur le tri par insertion
public static int[] insertionSort(float[] arr){
int[] indices = new int[arr.length];
indices[0] = 0;
for(int i=1;i<arr.length;i++){
int j=i;
for(;j>=1 && arr[j]<arr[j-1];j--){
float temp = arr[j];
arr[j] = arr[j-1];
indices[j]=indices[j-1];
arr[j-1] = temp;
}
indices[j]=i;
}
return indices;//indices of sorted elements
}
Convertissez l'entrée en une classe de paires comme celle ci-dessous, puis triez-la à l'aide de Arrays.sort (). Arrays.sort () garantit que l'ordre d'origine est conservé pour des valeurs égales comme le fait Matlab. Vous devez ensuite reconvertir le résultat trié dans les tableaux séparés.
class SortPair implements Comparable<SortPair>
{
private int originalIndex;
private double value;
public SortPair(double value, int originalIndex)
{
this.value = value;
this.originalIndex = originalIndex;
}
@Override public int compareTo(SortPair o)
{
return Double.compare(value, o.getValue());
}
public int getOriginalIndex()
{
return originalIndex;
}
public double getValue()
{
return value;
}
}
//Here index array(of length equal to length of d array) contains the numbers from 0 to length of d array
public static Integer [] SortWithIndex(float[] data, Integer [] index)
{
int len = data.length;
float temp1[] = new float[len];
int temp2[] = new int[len];
for (int i = 0; i <len; i++) {
for (int j = i + 1; j < len; j++) {
if(data[i]>data[j])
{
temp1[i] = data[i];
data[i] = data[j];
data[j] = temp1[i];
temp2[i] = index[i];
index[i] = index[j];
index[j] = temp2[i];
}
}
}
return index;
}