Question

我正在学习数据结构和算法的课程，我应该在指定的时间范围内实现heapsort算法。以下是两个实现：

def generateSwaps():
size=self._n
    for root in range((size//2)-1,-1,-1):
        root_val = self._data[root]             # save root value
        child = 2*root+1
        while(child<size):
            if child<size-1 and self._data[child]>self._data[child+1]:
                child+=1
            if root_val<=self._data[child]:     # compare against saved root value
                break
            self._data[(child-1)//2]=self._data[child]   # find child's parent's index correctly
            self._swaps.append(((child-1)//2,child))
            child=2*child+1
            # print(child)
        self._data[(child-1)//2]=root_val       # here too, and assign saved root value
    return self._data

这里，self._n是输入的大小，self._data是需要形成堆的元素列表。这个实现以更低的运行时间通过测试（最大迭代占用0.32秒）给出3秒的时间限制）。

下面是第二个代码片，它失败了（最大迭代时间长达6秒）

for i in range(self._n//2 , -1, -1):
      child_index = 0
      if (2*i + 2) == self._n:
        child_index = 2*i + 1
      elif (2*i + 2) < self._n:
        child_index = self._data.index(min(self._data[(2*i) + 1],self._data[(2*i) + 2]))
      else:
        child_index = 0

      while self._data[i] > self._data[child_index]:
        b = 0
        print("child is smaller for n = " + str(i))
        print(child_index)
        if child_index == 0:
          break
        else:
          self._swaps.append((i, child_index))
          self._data[i], self._data[child_index] = self._data[child_index], self._data[i]
          if child_index <= n//2:
            i = child_index
          else:
            break
          if (2*i + 2) == self._n:
            child_index = 2*i + 1
          elif(2*i + 2) < self._n:
            child_index = self._data.index(min(self._data[(2*i) + 1],self._data[(2*i) + 2]))
          else:
            child_index = 0

        print("hello work")
        self._data[i], self._data[child_index] = self._data[child_index], self._data[i]
        print(self._data)

我想了解的是运行时间差异很大的原因。我假设这可能是由于在while循环中的每一步都交换了列表项，但由于python中的列表基本上是一个数组，我意识到交换也应该是恒定的时间步长（这是我的假设。如果我是的话请纠正我错了）。

提前致谢

Answer 1

根据上面评论中的user2357112和user2357112的建议，问题是下面一行中的.index（）操作。

child_index = self._data.index(min(self._data[(2*i) + 1],self._data[(2*i) + 2]))

查找数组中元素索引的运行时间是O（n），因为它需要遍历数组，直到找到值的第一个匹配。这会导致第二个实现中的运行时间过长。在第一个实现中，通过直接比较所考虑的孩子的价值和它的邻居孩子，如下所示取代了这一点。

if child<size-1 and self._data[child]>self._data[child+1]:
   child+=1

由于数组具有对元素的恒定时间访问，因此上述实现是恒定时间，因此减少了运行时间。

Python heapify实现运行时

1 个答案: