Question

我想要一个程序，它接收一个8位数字并返回它的所有排列。

例如，12345678应该返回12345687, 12345768, 12345786 .. 87654321。

我的想法是这样做：

首先将每个数字作为元素放在数组中，然后：

for (int y = 0; y < digits; y++)
    for (int x = 0; x < digits; x++)
        for (int u = 0; u < digits; u++)
            for (int m = 0; m < digits; m++)
                for (int z = 0; z < digits; z++)
                    for (int b = 0; b < digits; b++)
                        for (int c = 0; c < digits; c++)
                            for (int d = 0; d < digits; d++)
                            {
                                if (!(y == x || y == u || y == m
                                    || y == z || y == b || y == c
                                    || y == d || x == u || x == m
                                    || x == z || x == b || x == c
                                    || x == d || u == m || u == z
                                    || u == b || u == c || u == d
                                    || m == z || m == b || m == c
                                    || m == d || z == b || z == c
                                    || z == d || b == c || b == d || c == d))
                                {

                                    holding[co] = (a1[y] * 10000000)
                                                + (a1[x] * 1000000)
                                                + (a1[u] * 100000)
                                                + (a1[m] * 10000)
                                                + (a1[z] * 1000)
                                                + (a1[b] * 100)
                                                + (a1[c] * 10)
                                                +  a1[d];

                                    co++;
                                }
                            }

将所有结果放入数组中。对数组进行排序并删除相同的元素（如果输入为11223344则会有相同的元素）。

但问题是我实际上想要打印从10000000到20000000的所有数字排列。这个想法太慢了。有谁知道如何更快地完成它？

Answer 1

递归地怎么样，就像他们在这里建议的那样？

Generating all permutations of a given string

由于Pham的建议，逻辑略有改善。我认为现在是O（n）...如果有人看到不同，请告诉我。

import java.util.ArrayList;

    public class Main {

        static ArrayList<Integer> numbersList = new ArrayList<Integer>();
        static ArrayList<String> prefixList = new ArrayList<String>();

        public static void main(String[] args) {
            String number = "83241232";

            permutation(number);

            System.out.printf("Found %d unique permutations!%n", numbersList.size());
            for(int i=0; i<numbersList.size(); i++)
            {
                System.out.printf("%d%n", numbersList.get(i));
            }
        }

        public static void permutation(String str) { 
            permutation("", str); 
        }

        private static void permutation(String prefix, String str) {
            int n = str.length();
            if (n == 0) 
            {
                if(!prefixList.contains(prefix))
                {
                    prefixList.add(prefix);
                    numbersList.add(Integer.parseInt(prefix));
                }
            }
            else {
                for (int i = 0; i < n; i++)
                {
                    permutation(prefix + str.charAt(i), str.substring(0, i) + str.substring(i+1, n));
                }
            }
        }
    }

Answer 2

一个太多的循环这是一个更容易的例子，这只是一个10位数组，你可以修改它来完成所有1000000或你需要它多少，虽然它需要一段时间。

import java.util.Arrays;

/**
 *
 * @author David
 */
public class Permutations {

    /**
     * @param args the command line arguments
     */
    public static void permutations(int[] chararr,int start, int end)
    {
        System.out.println(Arrays.toString(chararr));
        if (start<end)
        {
            int i,j;
            for(i=end-2; i>=start; i--)
            {
                for(j=i+1; j<end; j++)
                {
                    Swap(chararr,i,j);
                    permutations(chararr,i+1,end);
                }
                Rotate_Left(chararr,i,end);
            }
        }
    }
    private static void Swap(int[] chararr,int i,int j)
    {
        int t;
        t = chararr[i];
        chararr[i] = chararr[j];
        chararr[j] = t;
    }

    private static void Rotate_Left(int[] chararr,int start,int end)
    {
        int tmp = chararr[start];
        for (int i=start; i < end-1; i++)
        {
            chararr[i] = chararr[i+1];
        }
        chararr[end-1] = tmp;
    }         

    public static void main(String[] args) {
        // TODO code application logic here
        int[] array = new int[10];
        for(int x = 0; x < array.length; x++)
            array[x] = x+1;
        permutations(array,0,array.length);

    }

}

整数排列（无重复）

2 个答案: