Java 使用预定义的索引列表对ArrayList进行排序

我正在尝试使用预定义的索引数组对ArrayList进行排序。 我当前的示例使用原始ArrayList的副本进行排序，因此对于较大对象的ArrayList是不可伸缩的

package sortExample;

import java.awt.List;
import java.util.ArrayList;
import java.util.Arrays;

public class sortExample {

    public static void main(String[] args) {

        String [] str = new String[] {"a","b","c","d"};
        ArrayList<String> arr1 = new ArrayList<String>(Arrays.asList(str));

        int [] indices = {3,1,2,0};

        ArrayList<String> arr2 = new ArrayList(arr1.size());

        for (int i = 0; i < arr1.size(); i++) {
          arr2.add("0");
        }

        int arrIndex = 0;
        for (int i : indices){
            String st = arr1.get(arrIndex);
            arr2.set(i, st); 
            arrIndex++;
        }

      System.out.println(arr1.toString());
      System.out.println(arr2.toString());
    }

}

包裹分拣示例；
导入java.awt.List；
导入java.util.ArrayList；
导入java.util.array；
公共类分类器示例{
公共静态void main（字符串[]args）{
字符串[]str=新字符串[]{“a”、“b”、“c”、“d”}；
ArrayList arr1=新的ArrayList（Arrays.asList（str））；
int[]指数={3,1,2,0}；
ArrayList arr2=新的ArrayList（arr1.size（））；
对于（int i=0；i

有关重复使用相同数据的信息，请参阅我的解决方案：

public static void main(String[] args) {

    String[] strs = new String[]{"a", "b", "c", "d"};
    int[] indices = {3, 1, 2, 0};

    String tmp;
    for (int i = 0; i < strs.length; i++) {
        if (i != indices[i]) {
            tmp = strs[i];
            strs[i] = strs[indices[i]];
            strs[indices[i]] = tmp;

            indices[indices[i]] = indices[i];
            indices[i] = i;
        }
    }

    for (int i : indices) {
        System.out.print(i + " ");
    }
    System.out.println();
    for (String str : strs) {
        System.out.print(str + " ");
    }
}

int [] indices = {3,1,2,0};
ArrayList<String> arr2 = new ArrayList<String>();

for (int i = 0; i < arr1.size(); i++) {
    arr2.add(arr1.get(indices[i]));
}

publicstaticvoidmain（字符串[]args）{
字符串[]strs=新字符串[]{“a”、“b”、“c”、“d”}；
int[]索引={3,1,2,0}；
串tmp；
对于（int i=0；i

输出为：

01 2 3
d b c a

有一个（稍微）更简单的解决方案：

public static void main(String[] args) {

    String[] strs = new String[]{"a", "b", "c", "d"};
    int[] indices = {3, 1, 2, 0};

    String tmp;
    for (int i = 0; i < strs.length; i++) {
        if (i != indices[i]) {
            tmp = strs[i];
            strs[i] = strs[indices[i]];
            strs[indices[i]] = tmp;

            indices[indices[i]] = indices[i];
            indices[i] = i;
        }
    }

    for (int i : indices) {
        System.out.print(i + " ");
    }
    System.out.println();
    for (String str : strs) {
        System.out.print(str + " ");
    }
}

int [] indices = {3,1,2,0};
ArrayList<String> arr2 = new ArrayList<String>();

for (int i = 0; i < arr1.size(); i++) {
    arr2.add(arr1.get(indices[i]));
}

int[]索引={3,1,2,0}；
ArrayList arr2=新的ArrayList（）；
对于（int i=0；i

基于周期的备用再订购。请注意，索引将更改为{0,1,2,3}。我还没有安装java，所以我把C++的代码转换成了我认为是java语法的正确版。

    for (int i = 0; i < arr1.size(); i++) {
        if(i != indices[i]) {
            String st = arr1.get(i);
            int t = indices[i];
            int k = i;
            int j;
            while(i != (j = indices[k])){
                arr1.set(k, arr1.get(j));
                indices[k] = k;
                k = j;
            }
            arr1.set(k, st);
            indices[k] = k;
        }
    }

for（int i=0；i

对于这个特定的情况{3,1,2,0}，它所做的就是交换0和3。最长的循环发生在索引旋转时，例如{3 0 1 2}，在这种情况下，st=arr1[0]，arr1[0]=arr1[3]，arr[3]=arr1[2]，arr1[2]=arr1[1]，arr1[1]=st.

在下面，只需对新数组使用“索引”

public class Sorting {
    public static void main(String[] args) {
         String [] str = new String[] {"a","b","c","d"};

            int [] indices = {3,1,2,0};

            String sorted [] = new String [str.length] ;
            int i = 0;
            for (String string : str) {
                sorted[indices[i]] = string;
                i++;
            }

            for (String string : sorted) {
                System.out.print(string + " ");
            }
    }
}

印刷品：d b c a

---

你的问题是什么？如何操作有点复杂，但它可以工作……是否可以使用索引数组对ArrayList arr1进行排序而不创建副本arr2？为什么不使用Collections.sort（）？不必担心第二个列表！它将只保存对现有对象的引用，因此它的大小与对象的大小无关@VDanyliuk在本例中，要使用Collections.sort（），必须在要排序的对象中包含索引列表。@scs-根据索引数组对数组重新排序将比根据索引数组复制到另一个数组更复杂。就地重新排序的时间复杂度为O（n），因为每次交换都至少放置一个元素。有一种更快的变化，即排列循环，旋转原始数组的子集（或全部）。对于2个周期，它仍然是一个交换，对于3个或更多的周期，如果它们存在，那么旋转方法要快一点，temp=1个元素，1个元素=2个元素，2个元素=3个元素，nth element=temp@rcgldr我必须承认，我没有深入研究重新排序算法-O（n）复杂度足以满足我的需要。@hsnkhrmn：我现在看到上面的答案使用了切换，比我的示例更优雅。我对你的解决方案投了赞成票。在我的问题中，我考虑的是一个java函数，我可能忽略了其中的解决方案是一个单行程序。@rcgldr最多只能有n/2个开关操作。如前所述，这里的竞争性是O（n）。当排序开始运行时（通过比较器），最多为O（nlogn）。如果您寻找一个线性代码，TreeMap似乎是一个解决方案。通过valu和value的实际索引添加到TreeMap，完成后获取树的值。值将按键排序。