[英]Java Array sort: Quick way to get a sorted list of indices of an array
問題:考慮以下浮點數[]:
d[i] = 1.7 -0.3 2.1 0.5
我想要的是一個int []數組,它表示帶索引的原始數組的順序。
s[i] = 1 3 0 2
d[s[i]] = -0.3 0.5 1.7 2.1
當然,可以使用自定義比較器,自定義對象的排序集,或者通過簡單地對數組進行排序,然后搜索原始數組中的索引(顫抖)來完成。
我實際上正在尋找的是Matlab的sort函數的第二個返回參數的等價物。
有沒有一種簡單的方法(<5 LOC)? 可能有一個解決方案,不需要為每個元素分配一個新對象?
更新:
謝謝你的回復。 不幸的是,迄今為止提出的所有內容都不像我希望的簡單而有效的解決方案。 因此,我在JDK反饋論壇中打開了一個帖子,建議添加一個新的類庫函數來解決這個問題。 讓我們看看Sun / Oracle對此問題的看法。
http://forums.java.net/jive/thread.jspa?threadID=62657&tstart=0
創建索引器數組的簡單解決方案:對索引器進行排序,比較數據值:
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]);
}
});
為索引創建值的TreeMap
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();
索引將按它們指向的浮點數排序,原始數組不受影響。 如果確實需要,將Collection<Integer>
轉換為int[]
將作為練習。
編輯:如評論中所述,如果float數組中存在重復值,則此方法不起作用。 這可以通過將Map<Float, Integer>
轉換為Map<Float, List<Integer>>
盡管這會使for循環的內部和最終集合的生成稍微復雜化。
我將定制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;
}
使用Java 8功能(沒有額外的庫),實現它的簡潔方法。
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();
使用Functional Java :
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();
Jherico的答案允許重復值的更一般情況是這樣的:
// 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;
}
最好的解決方案是沿着C的qsort,它允許你指定比較和交換的函數,因此qsort不需要知道被排序的數據的類型或組織。 這是你可以試試的。 由於Java沒有函數,因此使用Array內部類來包裝要排序的數組或集合。 然后將其包裝在IndexArray中並進行排序。 IndexArray上的getIndex()結果將是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();
}
}
我會做這樣的事情:
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];
}
}
以下是基於插入排序的方法
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
}
我想使用它,因為它非常快。但是我將它用於int,你可以將它改為float。
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;
}
}
另一個非簡單的解決方案。 這是一個合並排序版本,它是穩定的 ,不會修改源數組,盡管合並需要額外的內存。
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)];
}
將輸入轉換為如下所示的對類,然后使用Arrays.sort()對其進行排序。 Arrays.sort()確保原始順序保留為與Matlab相同的值。 然后,您需要將排序后的結果轉換回單獨的數組。
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;
}
我想最簡單的方法是在創建數組時對其進行索引。 您需要鍵值對。 如果索引是一個單獨的結構,那么我不知道如何在沒有其他對象的情況下做到這一點(盡管有興趣看到它)
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.