Java 递归数置换时间复杂度

我提出了一段递归生成数字排列的代码，但不确定时间复杂度，有人知道它是什么吗

 private static void maketree(int i) {
        Node<Integer> head = new Node<Integer>(0);
        ArrayList<Integer> hasLeft = new ArrayList<Integer>();
        ArrayList<ArrayList<Integer>> permutations = new ArrayList<ArrayList<Integer>>();

        for (int tmp = 1; tmp < i; tmp++) {
            hasLeft.add(tmp);
        }

        for (Integer t = 0; t < hasLeft.size(); t++) {
            head.addChild(hasLeft.get(t));
            ArrayList<Integer> start = new ArrayList<Integer>();
            start.add(0);
            fillTree(head.getChildren().get(t), (ArrayList<Integer>) hasLeft.clone(), start, permutations);
        }
    }

    private static void fillTree(Node<Integer> n, ArrayList<Integer> hasLeft, ArrayList<Integer> start,
            ArrayList<ArrayList<Integer>> permutations) {

        ArrayList<Integer> current = (ArrayList<Integer>) start.clone();
        current.add(n.getData());
        hasLeft.remove(n.getData());
        if (hasLeft.isEmpty()) {
            permutations.add(current);
        }

        for (Integer i = 0; i < hasLeft.size(); i++) {
            n.addChild(hasLeft.get(i));
            fillTree(n.getChildren().get(i), (ArrayList<Integer>) hasLeft.clone(), current, permutations);
        }
    }

私有静态void生成树（inti）{
节点头=新节点（0）；
ArrayList haslight=新的ArrayList（）；
ArrayList置换=新的ArrayList（）；
for（int-tmp=1；tmp

不要使用

整数

或

数字

，而是使用

字符串

，这将对您有很大帮助

您可以使用代码

公共类置换{
公共静态void main（字符串[]args）
{ 
String str=“ABC”；
int n=str.length（）；
置换置换=新置换（）；
置换（str，0，n-1）；
} 
/** 
*置换函数
*@param str字符串，用于计算
*@param l起始索引
*@param r end index
*/
私有void排列（字符串str、int l、int r）
{ 
如果（l==r）
系统输出打印项次（str）；
否则{
对于（int i=l；i而不是使用
Integer
或
Number
，使用
String
，这将对您有很大帮助

您可以使用代码

公共类置换{
公共静态void main（字符串[]args）
{ 
String str=“ABC”；
int n=str.length（）；
置换置换=新置换（）；
置换（str，0，n-1）；
} 
/** 
*置换函数
*@param str字符串，用于计算
*@param l起始索引
*@param r end index
*/
私有void排列（字符串str、int l、int r）
{ 
如果（l==r）
系统输出打印项次（str）；
否则{
对于（int i=l；i你说你不确定时间复杂度。那么，你的想法是什么？不要只是在这里输入代码，然后希望其他人做这项工作。从提出你的想法开始，看看然后告诉你什么。你说你不确定时间复杂度。那么，你的想法是什么？不要只是在这里输入代码，然后希望其他人做这项工作。先提出你的想法，然后看看能告诉你什么。问题是关于时间复杂度的，你应该用复杂度来回答，而不是用另一个代码。好的，我也会补充。同时我认为我找到了更有效的代码，这就是我分享的原因。问题是关于时间复杂度，你应该回答呃，复杂的代码，而不是其他代码。好的，我也会添加。同时我认为我找到了更高效的代码，这就是为什么我分享了。
public class Permutation { 
public static void main(String[] args) 
{ 
    String str = "ABC"; 
    int n = str.length(); 
    Permutation permutation = new Permutation(); 
    permutation.permute(str, 0, n - 1); 
} 

/** 
 * permutation function 
 * @param str string to calculate permutation for 
 * @param l starting index 
 * @param r end index 
 */
private void permute(String str, int l, int r) 
{ 
    if (l == r) 
        System.out.println(str); 
    else { 
        for (int i = l; i <= r; i++) { 
            str = swap(str, l, i); 
            permute(str, l + 1, r); 
            str = swap(str, l, i); 
        } 
    } 
} 

/** 
 * Swap Characters at position 
 * @param a string value 
 * @param i position 1 
 * @param j position 2 
 * @return swapped string 
 */
public String swap(String a, int i, int j) 
{ 
    char temp; 
    char[] charArray = a.toCharArray(); 
    temp = charArray[i]; 
    charArray[i] = charArray[j]; 
    charArray[j] = temp; 
    return String.valueOf(charArray); 
} 
}