Java：递归方法接受整数'；n'；和印刷品'；n'；人物

作业：寻找更好的策略或方法，而不是完整的代码。

当我试图确定这个问题的递归情况时，我完全糊涂了。我必须编写一个接受整数参数'n'的方法，然后打印出总共'n'个字符。中间字符应始终为“”或“*”，具体取决于原始整数是奇数还是偶数。以下是两个不同的方法调用和输出的外观：

writeChars(1) -> *
writeChars(2) -> **
writeChars(3) -> <*>
writeChars(4) -> <**>
writeChars(5) -> <<*>>
writeChars(6) -> <<**>>
writeChars(7) -> <<<*>>>
writeChars(8) -> <<<**>>>

writeChars（1）->*
writeChars（2）->**
writeChars（3）->
writeChars（4）->
writeChars（5）->
writeChars（6）->
writeChars（7）->
writeChars（8）->

---

我该如何识别递归情况呢？

您有两个基本情况：n==1和n==2。除此之外，递归规则是发出一个“.”

您有两个基本情况：n==1和n==2。除此之外，递归规则是发出一个“.”

要识别递归，首先考虑如何解决给定值n的问题，假设您有一个方法可以解决较小情况下的问题。尺寸n的解决方案与尺寸n-1的解决方案有何关联

这样做之后，您会发现一个或多个小案例无法通过这种方式解决。这些是你的基本情况

---

最后，编写一个直接处理每个基本情况的方法。对于大于基本情况的n，它会调用自己的n-1，然后修改该结果以获得大小n的解决方案。

要识别递归，首先考虑如何解决给定值n的问题，假设您有一个方法可以解决较小情况的问题。尺寸n的解决方案与尺寸n-1的解决方案有何关联

这样做之后，您会发现一个或多个小案例无法通过这种方式解决。这些是你的基本情况

---

最后，编写一个直接处理每个基本情况的方法。对于比基本情况大的n，它将自己调用n-1，然后修改该结果以获得大小n的解决方案。

我可能会将问题分为3部分 1.打印

在此基础上，我们可以创建一个递归解决方案来打印每个组件。

的数量基于公式

i%2==1？i/2:（i-2）/2

，然后我们可以编写一个函数来递归打印它们，然后再编写另一个函数来打印

*

s

public class SO15049082 {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            print(i);
        }
    }

    private static void print(int i) {
        if (i > 0) {
            System.out.print("writeChars(" + i + ") --> ");
            int c = i % 2 == 1 ? i / 2 : (i - 2) / 2;
            printleft(c);
            printstar(c % 2);
            printright(c);
        }
        System.out.println();
    }

    private static void printright(int i) {
        if (i > 0) {
            System.out.print(">");
            printright(i - 1);
        }
    }

    private static void printstar(int i) {
        if (i == 1) {
            System.out.print("*");
        } else {
            System.out.print("**");
        }
    }

    private static void printleft(int i) {
        if (i > 0) {
            System.out.print("<");
            printleft(i - 1);
        }
    }

}

公共类SO15049082{
公共静态void main（字符串[]args）{
对于（int i=0；i<10；i++）{
印刷品（一）；
}
}
专用静态无效打印（int i）{
如果（i>0）{
System.out.print（“writeChars（“+i+”）-->”）；
intc=i%2==1？i/2：（i-2）/2；
左图（c）；
printstar（c%2）；
印刷权（c）；
}
System.out.println（）；
}
私有静态无效打印权限（int i）{
如果（i>0）{
系统输出打印（“>”）；
印刷权（i-1）；
}
}
专用静态无效打印星（int i）{
如果（i==1）{
系统输出打印（“*”）；
}否则{
系统输出打印（**）；
}
}
私有静态无效打印左（int i）{
如果（i>0）{
System.out.print（“我可能会把这个问题分为三个部分
1.打印

在此基础上，我们可以创建一个递归解决方案来打印每个组件。
的数量基于一个公式
i%2==1？i/2：（i-2）/2
，然后我们可以编写一个函数来递归打印它们，然后再编写另一个函数来打印
*
s

public class SO15049082 {

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            print(i);
        }
    }

    private static void print(int i) {
        if (i > 0) {
            System.out.print("writeChars(" + i + ") --> ");
            int c = i % 2 == 1 ? i / 2 : (i - 2) / 2;
            printleft(c);
            printstar(c % 2);
            printright(c);
        }
        System.out.println();
    }

    private static void printright(int i) {
        if (i > 0) {
            System.out.print(">");
            printright(i - 1);
        }
    }

    private static void printstar(int i) {
        if (i == 1) {
            System.out.print("*");
        } else {
            System.out.print("**");
        }
    }

    private static void printleft(int i) {
        if (i > 0) {
            System.out.print("<");
            printleft(i - 1);
        }
    }

}

公共类SO15049082{
公共静态void main（字符串[]args）{
对于（int i=0；i<10；i++）{
印刷品（一）；
}
}
专用静态无效打印（int i）{
如果（i>0）{
System.out.print（“writeChars（“+i+”）-->”）；
intc=i%2==1？i/2：（i-2）/2；
左图（c）；
printstar（c%2）；
印刷权（c）；
}
System.out.println（）；
}
私有静态无效打印权限（int i）{
如果（i>0）{
系统输出打印（“>”）；
印刷权（i-1）；
}
}
专用静态无效打印星（int i）{
如果（i==1）{
系统输出打印（“*”）；
}否则{
系统输出打印（**）；
}
}
私有静态无效打印左（int i）{
如果（i>0）{
System.out.print（“我认为递归的方式是传递两种状态（pos，string:s），它们在每次递归调用中都会发生变化，三种状态（n，mid1，mid2）有助于决定如何实现下一种状态

    public static void main(String... arg) {
        int n = 10, mid1, mid2;
        if (n % 2 == 0) {
            mid1 = n / 2;
            mid2 = n / 2 + 1;
        } else {
            mid1 = mid2 = n / 2 + 1;
        }

        System.out.println(recursion(1, n, mid1, mid2, ""));
    }

    private static String recursion(int pos, final int n, final int mid1, final int mid2, String s) {
        if (pos > n)
            return s;
        else if (pos == mid1 || pos == mid2)
            return recursion(pos + 1, n, mid1, mid2, s + "*");
        else if (pos < mid1)
            return recursion(pos + 1, n, mid1, mid2, s + "<");
        else
            return recursion(pos + 1, n, mid1, mid2, s + ">");
    }

publicstaticvoidmain（字符串…arg）{
int n=10，中间1，中间2；
如果（n%2==0）{
mid1=n/2；
mid2=n/2+1；
}否则{
mid1=mid2=n/2+1；
}
System.out.println（递归（1，n，mid1，mid2，“”）；
}
私有静态字符串递归（int pos、final int n、final int mid1、final int mid2、字符串s）{
如果（位置>n）
返回s；
else if（pos==mid1 | | pos==mid2）
返回递归（pos+1，n，mid1，mid2，s+“*”）；
否则如果（位置
我对递归的思考方式是传递两种状态（pos，string:s），它们在每次递归调用中都会发生变化，三种状态（n，mid1，mid2）有助于决定如何实现下一种状态

    public static void main(String... arg) {
        int n = 10, mid1, mid2;
        if (n % 2 == 0) {
            mid1 = n / 2;
            mid2 = n / 2 + 1;
        } else {
            mid1 = mid2 = n / 2 + 1;
        }

        System.out.println(recursion(1, n, mid1, mid2, ""));
    }

    private static String recursion(int pos, final int n, final int mid1, final int mid2, String s) {
        if (pos > n)
            return s;
        else if (pos == mid1 || pos == mid2)
            return recursion(pos + 1, n, mid1, mid2, s + "*");
        else if (pos < mid1)
            return recursion(pos + 1, n, mid1, mid2, s + "<");
        else
            return recursion(pos + 1, n, mid1, mid2, s + ">");
    }

publicstaticvoidmain（字符串…arg）{
int n=10，中间1，中间2；
如果（n%2==0）{
mid1=n/2；
mid2=n/2+1；
}否则{
mid1=mid2=n/2+1；
}
System.out.println（递归（1，n，mi