重接和重接递归到迭代转换C#

我被要求将递归的重定位和重定位算法转换为另一种迭代形式。以下是递归版本的psuedocode：

ReheapUp(node)
begin
   if NOT node = 0
       parent ← (node - 1) / 2 // integer division
       if heap[node] > heap[parent]
           Swap(heap[parent], heap[node])
           ReheapUp(parent)
       end-if
   end-if
end

ReheapDown(node)
begin
   leftChild ← node * 2 + 1
   rightChild ← node * 2 + 2
   if leftChild <= lastUsed
       largest ← leftChild
       if rightChild <= lastUsed AND array[largest] < array[rightChild]
           largest ← rightChild
       end-if
       if array[node] < array[largest]
           Swap(array[node], array[largest])
           ReheapDown(largest)
       end-if
   end-if
end

reheap（节点）
开始
如果不是，则节点=0
父母亲← （节点-1）/2//整数除法
如果heap[node]>heap[parent]
交换（堆[父]、堆[节点]）
再收容（家长）
如果结束
如果结束
结束
重新安置（节点）
开始
左撇子← 节点*2+1
右孩← 节点*2+2
如果leftChild您的再适应方法有一个小问题。
这应该起作用：

    private void ReheapDown(int index)
    {
        bool Terminate;

        int Processing = index,
            Largest = -1;

        do
        {
            Terminate = true;
            int LeftChild = CLEFT(Processing),
                RightChild = CRIGHT(Processing);

            if (LeftChild <= _LastUsed)
            {
                Largest = LeftChild;

                if (RightChild <= _LastUsed && _Data[Largest].CompareTo(_Data[RightChild]) < 0)
                    Largest = RightChild;

                if (_Data[Processing].CompareTo(_Data[Largest]) < 0)
                {
                    Utility.Swap(ref _Data[Processing], ref _Data[Largest]);
                    Terminate = false;
                    Processing = Largest;
                }
            }
        } while (!Terminate);
    }

private void-ReheapDown（内部索引）
{
布尔终止；
int处理=索引，
最大=-1；
做
{
终止=真；
int LeftChild=CLEFT（处理），
RightChild=CRIGHT（处理）；
如果（LeftChild请告诉我你认为哪里不对。@paqogomez我写的迭代代码不正确。当输入样本数据时，结果没有被正确地重调。请添加样本输入、预期输出和实际输出。在谷歌搜索时发现了这一点，我很好奇，
上次使用的
在你的伪代码中来自哪里？我既不声明也不设置
    private void ReheapDown(int index)
    {
        bool Terminate;

        int Processing = index,
            Largest = -1;

        do
        {
            Terminate = true;
            int LeftChild = CLEFT(Processing),
                RightChild = CRIGHT(Processing);

            if (LeftChild <= _LastUsed)
            {
                Largest = LeftChild;

                if (RightChild <= _LastUsed && _Data[Largest].CompareTo(_Data[RightChild]) < 0)
                    Largest = RightChild;

                if (_Data[Processing].CompareTo(_Data[Largest]) < 0)
                {
                    Utility.Swap(ref _Data[Processing], ref _Data[Largest]);
                    Terminate = false;
                    Processing = Largest;
                }
            }
        } while (!Terminate);
    }