Java 将整数置换的完整数组列表排序为决策树结构

背景：我有一个

ArrayList

。

整数

是一些订单对象的引用ID。稍后，该列表将告诉分支定界算法，哪个顺序首先计划到日程中，哪个顺序第二，等等。。 B&B是一种基于树的算法，我想用作深度优先搜索

所以，我需要列表的每一个排列。我的第一次尝试使用了递归：

private List<List<Integer>> permutations(List<Integer> input) {

    List<List<Integer>> permutations = new ArrayList<List<Integer>>();

    if (input.size() == 0) {
        permutations.add(new ArrayList<Integer>());
        return permutations;
    }

    Integer firstElement = input.remove(0);

    List<List<Integer>> recursiveReturn = permutations(input);
    for (List<Integer> li : recursiveReturn) {

        for (int index = 0; index <= li.size(); index++) {
            List<Integer> temp = new ArrayList<Integer>(li);
            temp.add(index, firstElement);
            permutations.add(temp);
        }

    }
    return permutations;
}

但如果是深度优先搜索，我需要：

[1, 2, 3]
[1, 3, 2]  
[2, 1, 3] 
[2, 3, 1] 
[3, 1, 2] 
[3, 2, 1]

以便按预期访问我的树节点：

---

那么，如何将递归获取的

列表排序到该结构中？
如何对现有排列排序：

final List<List<Integer>> permutations = new ArrayList<>();
permutations.add(Arrays.asList(1, 2, 3));
permutations.add(Arrays.asList(1, 3, 2));
permutations.add(Arrays.asList(2, 1, 3));
permutations.add(Arrays.asList(2, 3, 1));
permutations.add(Arrays.asList(3, 1, 2));
permutations.add(Arrays.asList(3, 2, 1));

System.out.println("initial state=" + permutations);

Collections.reverse(permutations);

System.out.println("after shuffle=" + permutations);

final List<List<Integer>> result = permutations.stream().sorted((o1, o2) -> {
    final int length = o1.size();
    int diff = 0;
    for (int i = 0; i < length; ++i) {
        diff = o1.get(i) - o2.get(i);
        if (diff != 0) {
            break;
        }
    }
    return diff;
}).collect(Collectors.toList());

System.out.println("sorted again =" + result);

final List permutations=new ArrayList（）；
add（Arrays.asList（1,2,3））；
add（Arrays.asList（1,3,2））；
add（Arrays.asList（2,1,3））；
add（Arrays.asList（2,3,1））；
add（Arrays.asList（3,1,2））；
add（Arrays.asList（3,2,1））；
System.out.println（“初始状态=”+置换）；
收藏。反向（排列）；
System.out.println（“洗牌后=”+置换）；
最终列表结果=排列.流（）.排序（（o1，o2）->{
最终整数长度=o1.size（）；
int-diff=0；
对于（int i=0；i

如何生成排序排列（）：

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.function.Consumer；
导入java.util.stream.collector；
导入java.util.stream.IntStream；
/**
*@作者卡罗尔·克罗尔
*/
公共类置换{
私有置换（）{
}
公共静态列表置换（最终整数[]编号）{
最终置换收集器置换收集器=新置换收集器（）；
置换（新整数[0]，数字，置换收集器）；
返回置换收集器.getResult（）；
}
私有静态无效置换（int[]前缀，int[]数组，最终使用者操作）{
int length=array.length；
如果（长度==0）{
操作.接受（前缀）；
}否则{
对于（int i=0；i
如何对已存在的排列进行排序：

final List<List<Integer>> permutations = new ArrayList<>();
permutations.add(Arrays.asList(1, 2, 3));
permutations.add(Arrays.asList(1, 3, 2));
permutations.add(Arrays.asList(2, 1, 3));
permutations.add(Arrays.asList(2, 3, 1));
permutations.add(Arrays.asList(3, 1, 2));
permutations.add(Arrays.asList(3, 2, 1));

System.out.println("initial state=" + permutations);

Collections.reverse(permutations);

System.out.println("after shuffle=" + permutations);

final List<List<Integer>> result = permutations.stream().sorted((o1, o2) -> {
    final int length = o1.size();
    int diff = 0;
    for (int i = 0; i < length; ++i) {
        diff = o1.get(i) - o2.get(i);
        if (diff != 0) {
            break;
        }
    }
    return diff;
}).collect(Collectors.toList());

System.out.println("sorted again =" + result);

final List permutations=new ArrayList（）；
add（Arrays.asList（1,2,3））；
add（Arrays.asList（1,3,2））；
add（Arrays.asList（2,1,3））；
add（Arrays.asList（2,3,1））；
add（Arrays.asList（3,1,2））；
add（Arrays.asList（3,2,1））；
System.out.println（“初始状态=”+置换）；
收藏。反向（排列）；
System.out.println（“洗牌后=”+置换）；
最终列表结果=排列.流（）.排序（（o1，o2）->{
最终整数长度=o1.size（）；
int-diff=0；
对于（int i=0；i

如何生成排序排列（）：

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
导入java.util.function.Consumer；
导入java.util.stream.collector；
导入java.util.stream.IntStream；
/**
*@作者卡罗尔·克罗尔
*/
公共类置换{
私有置换（）{
}
公共静态列表置换（最终整数[]编号）{
最终置换收集器置换收集器=新置换收集器（）；
置换（新整数[0]，数字，置换收集器）；
返回置换收集器.getResult（）；
}
私有静态无效置换（int[]前缀，int[]数组，最终使用者操作）{
int length=array.length；
如果（长度==0）{
操作.接受（前缀）；
}否则{
对于（int i=0；iimport java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * @author Karol Krol
 */
public class Permutation {

    private Permutation() {
    }

    public static List<List<Integer>> permutation(final int[] numbers) {
        final PermutationCollector permutationCollector = new PermutationCollector();
        permutation(new int[0], numbers, permutationCollector);
        return permutationCollector.getResult();
    }

    private static void permutation(int[] prefix, int[] array, final Consumer<int[]> operation) {
        int length = array.length;
        if (length == 0) {
            operation.accept(prefix);
        } else {
            for (int i = 0; i < length; ++i) {
                final int[] newPrefix = append(prefix, array[i]);
                final int[] reducedArray = reduce(array, i);
                permutation(newPrefix, reducedArray, operation);
            }
        }
    }

    private static int[] append(int[] array, int element) {
        int newLength = array.length + 1;
        array = Arrays.copyOf(array, newLength);
        array[newLength - 1] = element;
        return array;
    }

    private static int[] reduce(int[] array, int index) {
        final int newLength = array.length - 1;
        if (index == 0) {
            return Arrays.copyOfRange(array, 1, array.length);
        } else {
            final int[] dest = new int[newLength];
            System.arraycopy(array, 0, dest, 0, index);
            System.arraycopy(array, index + 1, dest, index, newLength - index);
            return dest;
        }
    }

    public static class PermutationCollector implements Consumer<int[]> {

        private List<List<Integer>> result = new ArrayList<>();

        @Override
        public void accept(int[] ints) {
            result.add(IntStream.of(ints).boxed().collect(Collectors.toList()));
        }

        public List<List<Integer>> getResult() {
            return result;
        }
    }
}

private List<List<Integer>> permutations(List<Integer> input)
{
    List<List<Integer>> permutations = new ArrayList<>();
    // if input's size is one, then there is only one permutation to return
    // wrap it as single entry inside permutations and return 
    if (input.size() == 1) {
        permutations.add(input);
        return permutations;
    }

    // if input's size is more than one, then we need to calc permutations
    // we iterate over the input, each time taking out one cell
    // the remaining cells become tree "under" this cell
    for (int i = 0; i < input.size(); i++) {
        List<Integer> remainingCells = new ArrayList<>(input);
        Integer firstElement = remainingCells.remove(i);
        List<List<Integer>> permutationsUnderFirstElement = permutations(remainingCells);
        for (List<Integer> permutation : permutationsUnderFirstElement) {
            permutation.add(0, firstElement);
            permutations.add(permutation);
        }
    }
    return permutations;
}