Big o 递归函数时间复杂度的证明

我试图确定这个函数的复杂性，其中D和element是整数，list是整数的有序列表。请注意，（其他元素）将严格为正

def doFunc(element, D, list):
  x = 0 
  if(D > 0):
    for otherElement in list:
      if otherElement == element:
        x += 1
      if otherElement > element:
        return x + (doFunc (otherElement,D-(otherElement-element) , list))
  return x

---

鉴于列表不会总是完全迭代，我不知道如何确定此函数的时间复杂度

doFunc

从左到右检查

列表

，以查找大于或等于提供的

元素的
其他元素
。最多进行一次递归调用。我们可以通过推断最坏情况下的输入和分析行为来尝试计算该函数的最坏情况时间复杂度

假设我们从一个大小为1的列表开始；叫它
{1}
。如果我们调用此列表中的函数，那么从
for
循环中可能得到的最多迭代次数是多少？如果我们设置
element=1
，我们得到一个迭代。但是，如果设置
element=0
，我们可以让
doFunc
使用
element=1
递归调用自己；这意味着我们有两次迭代。说服自己，对于这个列表，我们不可能得到超过两次的迭代。还要说服自己选择
{1}
基本上并不重要；任何单个元素列表的工作方式都是相同的

假设现在我们想要找到长度为2的最坏情况列表；下一个数字应该相同、更大还是更小？考虑<代码> { 1, 1 } <代码>，<代码> { 1, 2 } < /代码>和<代码> { 1, 0 } < /代码>。使用
element=-1
调用
doFunc
将分别导致
for
循环最多迭代3次、5次和3次。对于长度为2的列表，添加较大的元素可能会导致最坏的行为

让自己相信，最糟糕的情况是数字的升序列表；事实上，由于
D
的限制因素，最坏情况是
n
元素的
{a，a+1，a+2，…，a+n-1}
形式的列表。对于这样的列表，在设置
元素
时，我们有以下行为：

对
doFunc
的初始调用进行一次迭代；然后我们有
otherElement>element
，所以我们递归调用
doFunc
对
doFunc
的第一次递归调用进行两次迭代；然后我们有
otherElement>element
，所以我们递归地再次调用
类似地，在
k
对
doFunc
的第次递归调用中，我们应该期望
k+1
对
for
循环的迭代。由于
for
循环在单个调用上下文中的迭代次数不能超过
n次，这意味着我们对
doFunc
的递归调用最多为
n-1次

我们有
1+2+…+n=O（n^2）
。这是假设
d>n
。假设
d
，我们不能得到所有的递归调用；我们最多只能有，
1+2+…+在这种情况下，d
迭代，或
O（d^2）
。因此，此函数的最坏情况是
O（min（n^2，d^2））
。你的另一个问题的复杂性是
O（dn）
，这比这里的复杂性更糟糕，除非
d=n
，在这种情况下，性能是相同的

编辑：还要注意，这里的时间复杂度常数实际上肯定比您的其他尝试要好得多，因此尽管具有相同的渐近复杂度，您仍会看到明显更好的性能。
请参见，我在这里回答了一个类似于，但显然不同于这个，我试图优化算法。你看，我必须以严格低于O（n^2）的时间复杂度来解决一个问题，但我不知道如何计算大O。我认为添加一个新的条件可能会帮助我降低复杂性。你是说它和我以前贴的那张一样吗；我现在正在写一个答案，但这里的复杂性确实更好。只是指出这是一个类似的问题；对不起，如果是你的问题，我没认出你：）没问题，谢谢你的帮助