Algorithm 我如何找到这个递归算法的复杂性？用二进制数替换字符串中的模式

该算法本质上是在给定的二进制字符串中查找星号（*），并将其替换为0和1，以输出二进制字符串的所有不同组合

我原本以为这个算法是O（2^n），但是，在我看来，它只考虑了字符串中的星号（*）。那绳子的长度呢？因为如果给定的字符串中没有星号，那么从技术上讲它仍然是线性的，因为递归调用的数量取决于字符串长度，但是我最初的O（2^n）似乎没有考虑到这一点，因为如果n=0，它将变成O（1）

我应该如何去了解它的时间和空间复杂性？谢谢

代码：

static void RevealStr（StringBuilder str，int i）{
//基本情况：达到时打印每个可能性
如果（str.length（）==i）{
系统输出打印项次（str）；
返回；
}
//如果找到通配符（*），则执行递归步骤
如果（str.charAt（i）='*'）{
//探索堆栈帧中0和1的置换
对于（char ch='0'；ch要解决此问题，我们可以手动运行：

基础：n=1

RevealStr("*", 1)

它满足第一个if的条件，我们只为输出运行一次
*

下一步：n=2

RevealStr("**", 1)
  RevealStr("0*", 2)
    RevealStr("00", 2)
    RevealStr("01", 2)
  RevealStr("1*", 2)
    RevealStr("10", 2)
    RevealStr("11", 2)

下一步：n=3

RevealStr("***", 1)
  RevealStr("0**", 2)
    RevealStr("00*", 2)
      RevealStr("000", 3)
      RevealStr("001", 3)
    RevealStr("01*", 2)
      RevealStr("010", 3)
      RevealStr("011", 3)
  RevealStr("1**", 2)
    RevealStr("10*", 2)
      RevealStr("100", 3)
      RevealStr("101", 3)
    RevealStr("11*", 2)
      RevealStr("110", 3)
      RevealStr("111", 3)

您可以看到，当n=2时，
revelastr
被调用了7次，而当n=3时，它被调用了15次。这遵循了函数
F（n）=2^（n+1）-1

在最坏的情况下，复杂度似乎是O（2^n）是n星数
要解决这个问题，我们可以手动运行：

基础：n=1

RevealStr("*", 1)

它满足第一个if的条件，我们只为输出运行一次
*

下一步：n=2

RevealStr("**", 1)
  RevealStr("0*", 2)
    RevealStr("00", 2)
    RevealStr("01", 2)
  RevealStr("1*", 2)
    RevealStr("10", 2)
    RevealStr("11", 2)

下一步：n=3

RevealStr("***", 1)
  RevealStr("0**", 2)
    RevealStr("00*", 2)
      RevealStr("000", 3)
      RevealStr("001", 3)
    RevealStr("01*", 2)
      RevealStr("010", 3)
      RevealStr("011", 3)
  RevealStr("1**", 2)
    RevealStr("10*", 2)
      RevealStr("100", 3)
      RevealStr("101", 3)
    RevealStr("11*", 2)
      RevealStr("110", 3)
      RevealStr("111", 3)

您可以看到，当n=2时，
revelastr
被调用了7次，而当n=3时，它被调用了15次。这遵循了函数
F（n）=2^（n+1）-1

在最坏的情况下，复杂度似乎是O（2^n）是n星的数目
大O表示法的思想是给出上界的估计值，即，如果算法的顺序是O（n^4）运行时，它仅仅意味着算法不能做比这更差的运算

比方说，可能有一个O（N）阶的算法运行时，但我们仍然可以说它是O（N^2）。因为O（N）从来没有比O（N^2）更差。但在计算意义上，我们希望估计值尽可能接近和紧凑，因为它能让我们更好地了解算法的实际性能

在您当前的示例中，O（2^N）和O（2^L），N是字符串的长度，L是*的数目，都是有效的上界。但是，由于O（2^L）对算法及其对*字符的依赖性有了更好的了解，所以O（2^L）的估计更好、更精确（正如L一样，大O表示法的思想是给出上界的估计值，即，如果算法的顺序是O（N^4）运行时，它只是意味着算法不能做任何比这更糟糕的事情

比方说，可能有一个O（N）阶的算法运行时，但我们仍然可以说它是O（N^2）。因为O（N）从来没有比O（N^2）更差。但在计算意义上，我们希望估计值尽可能接近和紧凑，因为它能让我们更好地了解算法的实际性能

在您当前的示例中，O（2^N）和O（2^L），N是字符串的长度，L是*的数目，都是有效的上界。但由于O（2^L）对算法及其对*字符存在的依赖性有了更好的了解，所以O（2^L）的估计值更好、更精确（如
O（2^L）所示）
我猜，因为星星的数量最多等于弦的长度，所以它是
O（2^l）
我猜，因为星的数量最多等于字符串的长度。谢谢。但是，我们是否应该考虑字符串中的字符数量？在我看来，递归调用是在字符是否为星的情况下执行的。这里不是有两个变量来计算复杂性吗？如果字符串中没有星，t算法不是O（1），它仍然与字符串长度成线性关系，对吗？这是最坏的情况（调用量最多的情况），即全明星（*），因为你的算法有两条路径，它不会总是遵循相同的路径。排序数组时也会发生同样的情况，你有最好的情况（通常是已经排序的情况）和最坏的情况编辑：仔细阅读评论后，你是对的，它将取决于两个变量：字符串的长度（L）和开始数（S）。如果S=0，算法将是O（n）（最佳情况），如果S=L，算法将是O（2^S）根据不同的值，它可以在它们之间变化。谢谢。但是，我们不应该考虑字符串中的字符数吗？在我看来，无论字符是否为星型，递归调用都是执行的。这里没有两个变量来计算复杂性吗？如果字符串中没有星型，则算法是无效的不是O（1），它仍然与字符串长度成线性关系吗？这是最坏的情况（调用量最多的情况），即全明星（*），因为您的算法有两条路径，它不会始终遵循相同的路径。排序数组时也会发生同样的情况，您有最好的情况（通常是已排序的情况）和最坏的情况编辑：仔细阅读评论后，你是对的，它将取决于两个变量：字符串的长度（L）和开始数（S）。如果S=0，算法将是O（n）（最佳情况），如果S=L，算法将是O（2^S）根据不同的值，它可以在它们之间变化。那么空间复杂度会是O（n），其中n只是字符串的长度吗