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

如何解决如何找到此递归算法的复杂性？用二进制数替换字符串中的模式

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

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

我应该如何找出其时间和空间复杂性？谢谢。

代码：

for x in formatted_sell_list:
    # print('loop = ' + str(loop))
    content = x.copy()
    file_name = str(db_number) + '- Q' + str(loop) +' NEW'
    # print('Writing to ' + str(db_file_name) + "," + str(content))
    if len(x) > 0:

        # Open the file in append & read mode ('a+')
        with open(os.path.join(r'C:\Users\PC\PycharmProjects\Simcompanies\Files\RecordedSales2',str(file_name)) + '.txt',"a+") as file_object:

            for write_me in content:

                    # Append text at the end of file
                    file_object.write(str(write_me))
                    file_object.write("\n")

编辑：我目前正在考虑类似O（2 ^ s + l），其中s是星数，l是字符串的长度。

解决方法

要解决此问题，我们可以手动运行：

基数： n = 1

RevealStr("*",1)

它满足第一个条件，如果我们只对输出*运行了一次

下一步： 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的情况下，RevealStr被调用了7次，而在n = 3的情况下，其被调用了15。这遵循了函数F(n)=2^(n+1)-1

在最坏的情况下，复杂度似乎是O（2 ^ n）为n个星数

Big-O表示法的想法是给出一个上限的估计，即，如果算法的顺序为O（N ^ 4）运行时，则仅意味着该算法不能做任何更糟的比那强。

可以说，也许有一个运行时间为O（N）的算法，但是我们仍然可以说它是O（N ^ 2）。由于O（N）永远不会比O（N ^ 2）差。但是从计算的角度来看，我们希望估算值尽可能接近且严格，这样可以使我们更好地了解算法的实际效果。

在您当前的示例中，O（2 ^ N）和O（2 ^ L）均为N，N是字符串的长度，L是*的数字，是有效上限。但是，由于O（2 ^ L）可以更好地了解算法及其对*字符存在的依赖性，因此O（2 ^ L）可以更好，更严格地估计算法（因为L

更新：空间复杂度取决于实现方式。在您当前的实现中，假设StringBuilder是通过引用传递的，并且在每个递归调用中均没有字符串的副本，则空间复杂度的确为O（N），即递归调用堆栈的大小。如果按值传递它，并且在进行调用之前每次都将其复制到堆栈中，则总体复杂度将为O（N * N），即（O（max_number_of_recursive_calls * size_of_string）），因为复制操作成本为O（size_of_string）