Algorithm 这个递归算法的大O

我执行了以下涉及二进制堆结构的算法：

Algorithm: heapMinimum(node)
Input    : Position n
Output   : Sequence minList; containing the postions that hold the minimum value

1. minList <-- sequence
2. if parent(node) == NULL // current node is the root of the tree
3.   minList.insertLast(node)
4. if (leftchild(node).element() == node.element())
5.   concat(heapMinimum(leftchild(node), minList))
6. if(right(node).element() == node.element())
7.   concat(heapMinimum(rightChild(node), minList))
8. return minList

算法：heapMinimum（节点）
输入：位置n
输出：序列列表；包含具有最小值的职位
1.minList在我看来像O（N），其中N是元素的数量。如果堆只包含相等的元素，则将遍历所有元素。还有，为什么concat不是O（1）？只要你是“串联”数字，它也应该是O（1）。但是，如果concat是O（N）（从伪代码来看，它看起来是-但是如果您真的需要连接两个返回的列表，您应该重新考虑），那么最坏情况下的总时间是O（N2）。
在我看来是O（N），其中N是元素数。如果堆只包含相等的元素，则将遍历所有元素。还有，为什么concat不是O（1）？只要你是“串联”数字，它也应该是O（1）。但是，如果concat是O（N）（从伪代码来看，它看起来是-但是如果您真的需要连接两个返回的列表，您应该重新考虑），那么最坏的情况下，总时间将是O（N2）。
我假设您谈论的是二进制堆

根据堆属性的定义，只有在找到大于根的元素之前，才应该递归。但是，您还必须确保树的当前级别上的其他元素的大小都不与根相同。本质上，这会产生一个规则，即一旦遇到堆中大于根的元素，就不需要递归到该元素的子元素中

但是，在最坏的情况下，每个元素可能等于根。在这种情况下，您必须检查整个堆，这将产生O（n）个时间，其中n是堆中的元素数

所以要回答你的问题，是O（n）
我想你说的是二进制堆

根据堆属性的定义，只有在找到大于根的元素之前，才应该递归。但是，您还必须确保树的当前级别上的其他元素的大小都不与根相同。本质上，这会产生一个规则，即一旦遇到堆中大于根的元素，就不需要递归到该元素的子元素中

但是，在最坏的情况下，每个元素可能等于根。在这种情况下，您必须检查整个堆，这将产生O（n）个时间，其中n是堆中的元素数

所以要回答你的问题，它是O（n）
正如其他人提到的，如果你的concat（）是O（1）[如果不是，你可以这样做]，那么你的算法在输出的大小上是O（n）

但是，如果使用了复制列表的concat（）（取决于系统，这可能很容易意外执行），那么最坏的情况是输出大小为O（N^2）。导致这种行为的一种情况是，当最小节点深入到树中时，concat（）会在每个级别上不断复制列表

请注意，此深度受堆深度的限制，因此如果树是平衡的，那么最坏的情况也是数据结构大小的O（M log M）。您可以看到这一点，因为最大副本数是树的深度。
正如其他人所提到的，如果您的concat（）是O（1）[如果不是，您可以这样做]，那么您的算法的输出大小是O（N）

但是，如果使用了复制列表的concat（）（取决于系统，这可能很容易意外执行），那么最坏的情况是输出大小为O（N^2）。导致这种行为的一种情况是，当最小节点深入到树中时，concat（）会在每个级别上不断复制列表

请注意，此深度受堆深度的限制，因此如果树是平衡的，那么最坏的情况也是数据结构大小的O（M log M）。您可以看到这一点，因为最大副本数是树的深度。
我想您的解决方案中有一个bug。
第一项检查：

如果父（节点）==NULL

必须删除，但请检查节点！=必须添加NULL

此外，我建议使用列表作为附加参数，您将在其中放置答案。
这就是我的实现：

Algorithm: heapMinimum(node, minList)
if (node != NULL)
{
   if (minList.empty() || minList.getFirst().element() == node.element())
   {
      minList.insertLast(node)

      heapMinimum(left(node),  minList)
      heapMinimum(right(node), minList)
   }
}

假设向列表中添加一个元素需要O（1），我们得到函数需要O（k），其中k是堆中最小值的数目

享受。
我想你的解决方案中有一个bug。
第一项检查：

如果父（节点）==NULL

必须删除，但请检查节点！=必须添加NULL

此外，我建议使用列表作为附加参数，您将在其中放置答案。
这就是我的实现：

Algorithm: heapMinimum(node, minList)
if (node != NULL)
{
   if (minList.empty() || minList.getFirst().element() == node.element())
   {
      minList.insertLast(node)

      heapMinimum(left(node),  minList)
      heapMinimum(right(node), minList)
   }
}

假设向列表中添加一个元素需要O（1），我们得到函数需要O（k），其中k是堆中最小值的数目

享受。
看看堆上操作的复杂性：看看堆上操作的复杂性：正如IVlad指出的，如果您的concat不是O（1），那么您使用的数据结构是错误的。在这种情况下，一个简单的链表将起作用，就像一个可调整大小的数组（如向量）一样。对于大堆，每次在concat列表上运行的惩罚可能非常低效。如果concat操作不是O（1），因为它存储的数据的性质（例如，每个元素都是一个序列），那么需要使用不同的变量来计算。例如：O（n*k），其中n=堆的大小，k=最长序列的大小。因此，例如，使用基于数组的加倍策略向量将两个向量连接在一起需要恒定的时间？@Andreas正如我指出的，计算取决于您希望存储的数据类型。从列表中插入操作的角度来看，它应该是O（1）（表示不遍历）