带案例陈述的大 O 递归

Question

我有这个程序，它使用 case 语句在递归中从向后打印数组切换到向前打印数组。如果我要迭代地写这个，它将是一个带有条件逻辑的 for 循环（可以忽略）；因此，Big O 将是 O(n)。我假设相同的逻辑也适用于递归程序，对吗？

    public static int recursion(int i, int j, String swap) {
        int[] testList = {0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21};
        if (j == 10) {
            return testList[10];
        }
        if (i == 10 ) {
            swap = "Yes";
        }

        switch (swap) {
            case "No":
                System.out.print(testList[i] + " ");
                i -= 1;
                break;
            case "Yes":
                System.out.print(testList[j] + " ");
                j += 1;
                break;
        }
        return recursion(i, j, swap);
    }
    public static void main(String[] args){
        String swap = "No";
        int i = 20;
        int j = 0;
        System.out.println(recursion(i, j, swap) + " ");
    }
}

Answer 1

我将代码简化如下，计算其时间复杂度

 public static void recursion(int[] testList, int i) { // O(n)
        int len = testList.length; // O(1)

        if(i >= len) return; // O(1)

        int idx = i <= len / 2 ? len - 1 - i: i - len / 2; // O(1)
        System.out.print(testList[idx] + " "); // O(1)

        recursion(testList, i + 1); // O(n - 1)
    }
    public static void main(String[] args){
        int[] testList = {0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21};
        recursion(testList, 0);
    }

如果我们创建一个递归关系，那么我们可以找到它的时间复杂度

T(n) = T(n - 1) + C (some constant time) (0 <= n < length)
T(n) = 1 (for n >= length)

我们可以简化等式

T(n) = T(n - 2) + 2C
     = T(n - 3) + 3C
     .
     .
     = T(n - (n - 1)) + (n - 1)C
     = T(1) + (n - 1)C
     = 1 + (n - 1)C

这给出 T(n) = O(n)

带案例陈述的大 O 递归

Big O Recursion with a Case Statement

java

big-o