Microsoft内部的PriorityQueue <T>中的错误？

81

在PresentationCore.dll中的.NET Framework中，有一个通用PriorityQueue<T>类，其代码可以在此处找到。

我写了一个简短的程序来测试排序，结果并不理想：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using MS.Internal;

namespace ConsoleTest {
    public static class ConsoleTest {
        public static void Main() {
            PriorityQueue<int> values = new PriorityQueue<int>(6, Comparer<int>.Default);
            Random random = new Random(88);
            for (int i = 0; i < 6; i++)
                values.Push(random.Next(0, 10000000));
            int lastValue = int.MinValue;
            int temp;
            while (values.Count != 0) {
                temp = values.Top;
                values.Pop();
                if (temp >= lastValue)
                    lastValue = temp;
                else
                    Console.WriteLine("found sorting error");
                Console.WriteLine(temp);
            }
            Console.ReadLine();
        }
    }
}

结果：

2789658
3411390
4618917
6996709
found sorting error
6381637
9367782

存在排序错误，并且如果样本数量增加，则排序错误的数量会成比例地增加。

我做错什么了吗？如果不是，则PriorityQueue该类代码中的错误在哪里正确定位？

c#  .net  priority-queue 
— MathuSum Mut
source
3
根据源代码中的注释，Microsoft从2005-02-14开始使用此代码。我想知道这样的错误如何在过去的12年中没有被发现？
— 纳特
9
@Nat，因为Microsoft唯一使用它的地方是这里，并且有时选择一种优先级较低的字体的字体很难注意到。
— 斯科特·张伯伦

Answers:

83

可以使用初始化向量来重现该行为[0, 1, 2, 4, 5, 3]。结果是：

[0，1，2，4，4，3，5]

（我们可以看到3放置不正确）

该Push算法是正确的。它以一种简单的方式构建了最小堆：

  • 从右下角开始
  • 如果该值大于父节点，则将其插入并返回
  • 否则，将父项放到右下角的位置，然后尝试在父项位置插入值（并不断交换树直到找到正确的位置）

结果树是：

                 0
               /   \
              /     \
             1       2
           /  \     /
          4    5   3

问题在于Pop方法。首先将顶部节点视为要填充的“间隙”（因为我们将其弹出）：

                 *
               /   \
              /     \
             1       2
           /  \     /
          4    5   3

要填充它，它将搜索最低的直接子对象（在这种情况下为1）。然后，它会将值上移以填充空白（子级现在是新的空白）：

                 1
               /   \
              /     \
             *       2
           /  \     /
          4    5   3

然后，它对新的间隙执行完全相同的操作，因此间隙再次向下移动：

                 1
               /   \
              /     \
             4       2
           /  \     /
          *    5   3

当差距达到最低点时，算法...将获取树的最右下角的值，并使用它来填补差距：

                 1
               /   \
              /     \
             4       2
           /  \     /
          3    5   *

现在，间隙位于最右下角的节点上，它递减_count以从树中删除间隙：

                 1
               /   \
              /     \
             4       2
           /  \     
          3    5

最后，我们得到了……一堆破烂的东西。

老实说，我不了解作者要做什么，所以我无法修复现有代码。最多，我可以将其替换为可用的版本（从Wikipedia进行无耻复制）：

internal void Pop2()
{
    if (_count > 0)
    {
        _count--;
        _heap[0] = _heap[_count];

        Heapify(0);
    }
}

internal void Heapify(int i)
{
    int left = (2 * i) + 1;
    int right = left + 1;
    int smallest = i;

    if (left <= _count && _comparer.Compare(_heap[left], _heap[smallest]) < 0)
    {
        smallest = left;
    }

    if (right <= _count && _comparer.Compare(_heap[right], _heap[smallest]) < 0)
    {
        smallest = right;
    }

    if (smallest != i)
    {
        var pivot = _heap[i];
        _heap[i] = _heap[smallest];
        _heap[smallest] = pivot;

        Heapify(smallest);
    }
}

该代码的主要问题是递归实现，如果元素数量太大，该实现将中断。我强烈建议您使用经过优化的第三方库。

编辑：我想我发现了什么丢失。在取得了最右下角的节点之后，作者只是忘记了重新平衡堆：

internal void Pop()
{
    Debug.Assert(_count != 0);

    if (_count > 1)
    {
        // Loop invariants:
        //
        //  1.  parent is the index of a gap in the logical tree
        //  2.  leftChild is
        //      (a) the index of parent's left child if it has one, or
        //      (b) a value >= _count if parent is a leaf node
        //
        int parent = 0;
        int leftChild = HeapLeftChild(parent);

        while (leftChild < _count)
        {
            int rightChild = HeapRightFromLeft(leftChild);
            int bestChild =
                (rightChild < _count && _comparer.Compare(_heap[rightChild], _heap[leftChild]) < 0) ?
                    rightChild : leftChild;

            // Promote bestChild to fill the gap left by parent.
            _heap[parent] = _heap[bestChild];

            // Restore invariants, i.e., let parent point to the gap.
            parent = bestChild;
            leftChild = HeapLeftChild(parent);
        }

        // Fill the last gap by moving the last (i.e., bottom-rightmost) node.
        _heap[parent] = _heap[_count - 1];

        // FIX: Rebalance the heap
        int index = parent;
        var value = _heap[parent];

        while (index > 0)
        {
            int parentIndex = HeapParent(index);
            if (_comparer.Compare(value, _heap[parentIndex]) < 0)
            {
                // value is a better match than the parent node so exchange
                // places to preserve the "heap" property.
                var pivot = _heap[index];
                _heap[index] = _heap[parentIndex];
                _heap[parentIndex] = pivot;
                index = parentIndex;
            }
            else
            {
                // Heap is balanced
                break;
            }
        }
    }

    _count--;
}
— 凯文·高斯
source
4
“算法错误”是您不应该向下移动一个间隙，而是先缩小树并将右下角的元素放在该间隙中。然后以简单的迭代循环修复树。
— Henk Holterman
5
对于错误报告来说，这是很好的材料，您应该通过这篇文章的链接对其进行报告（我认为正确的地方应该是MS connect，因为PresentationCore不在GitHub上）。
— 卢卡斯·特热涅夫斯基
4
@LucasTrzesniewski我不确定对实际应用程序的影响（因为它仅用于WPF中一些晦涩的字体选择代码），但是我想举报它不会有任何伤害
— Kevin Gosse
20

凯文·高斯（Kevin Gosse）的答案指出了问题所在。尽管可以重新平衡堆，但是如果您在原始删除循环中解决了基本问题，则没有必要。

正如他所指出的那样，其想法是用最低的，最右边的项目替换堆顶部的项目，然后将其筛选到正确的位置。这是对原始循环的简单修改：

internal void Pop()
{
    Debug.Assert(_count != 0);

    if (_count > 0)
    {
        --_count;
        // Logically, we're moving the last item (lowest, right-most)
        // to the root and then sifting it down.
        int ix = 0;
        while (ix < _count/2)
        {
            // find the smallest child
            int smallestChild = HeapLeftChild(ix);
            int rightChild = HeapRightFromLeft(smallestChild);
            if (rightChild < _count-1 && _comparer.Compare(_heap[rightChild], _heap[smallestChild]) < 0)
            {
                smallestChild = rightChild;
            }

            // If the item is less than or equal to the smallest child item,
            // then we're done.
            if (_comparer.Compare(_heap[_count], _heap[smallestChild]) <= 0)
            {
                break;
            }

            // Otherwise, move the child up
            _heap[ix] = _heap[smallestChild];

            // and adjust the index
            ix = smallestChild;
        }
        // Place the item where it belongs
        _heap[ix] = _heap[_count];
        // and clear the position it used to occupy
        _heap[_count] = default(T);
    }
}

还要注意，编写的代码存在内存泄漏。这段代码：

        // Fill the last gap by moving the last (i.e., bottom-rightmost) node.
        _heap[parent] = _heap[_count - 1];

不清除中的值_heap[_count - 1]。如果堆存储的是引用类型，则这些引用将保留在堆中，并且除非对堆内存进行垃圾回收，否则无法对其进行垃圾回收。我不知道在哪里使用该堆，但是如果它很大并且可以使用很多时间，则可能会导致过多的内存消耗。答案是在复制项目后清除该项目：

_heap[_count - 1] = default(T);

我的替换代码包含了该修复程序。

— 吉姆·米歇尔
source
1
在我测试过的基准测试中（可以在pastebin.com/Hgkcq3ex上找到），该版本比Kevin Gosse提出的基准版本慢约18％（即使取消了对default（）的清除行并将_count/2计算悬挂在外部）循环）。
— MathuSum Mut
@MathuSumMut：我提供了一个优化的版本。与其放置并不断交换它，不如将它与放置的位置进行比较。这减少了写入次数，因此应提高速度。另一种可能的优化是将其复制_heap[_count]到临时目录，这将减少数组引用的数量。
— Jim Mischel
不幸的是，我尝试了这个，它似乎也有一个错误。设置一个int类型的队列，并使用此自定义比较器：Comparer<int>.Create((i1, i2) => -i1.CompareTo(i2))-即，将其排序为最大到最小（注意负号）。按顺序依次输入数字：3、1、5、0、4，然后逐步将它们全部出队后，返回顺序为：{5,4,1,3,0}，因此大部分仍排序，但是1和3的顺序错误。使用上面的Gosse方法不会出现此问题。请注意，我没有按正常的升序出现此问题。
— 尼古拉斯·彼得森
1
@NicholasPetersen：有趣。我必须调查一下。感谢您的来信。
— Jim Mischel
2
@JimMischel代码中的错误：比较rightChild < _count-1应为rightChild < _count。这仅在将计数从精确的2的幂开始减少时才重要，并且仅当间隙一直沿树的右边缘向下移动时才重要。在最底层，rightChild与其左同级没有进行比较，并且错误的元素可以得到提升，从而破坏了堆。树越大，发生这种情况的可能性就越小；当计数从4减少到3时最有可能出现，这解释了尼古拉斯·彼得森（Nicholas Petersen）对“最后几件物品”的观察。
— Sam Bent-MSFT
0

在.NET Framework 4.8中不可复制

尝试在2020年使用问题中PriorityQueue<T>链接的.NET Framework 4.8实现重现此问题，并 使用以下XUnit测试...

public class PriorityQueueTests
{
    [Fact]
    public void PriorityQueueTest()
    {
        Random random = new Random();
        // Run 1 million tests:
        for (int i = 0; i < 1000000; i++)
        {
            // Initialize PriorityQueue with default size of 20 using default comparer.
            PriorityQueue<int> priorityQueue = new PriorityQueue<int>(20, Comparer<int>.Default);
            // Using 200 entries per priority queue ensures possible edge cases with duplicate entries...
            for (int j = 0; j < 200; j++)
            {
                // Populate queue with test data
                priorityQueue.Push(random.Next(0, 100));
            }
            int prev = -1;
            while (priorityQueue.Count > 0)
            {
                // Assert that previous element is less than or equal to current element...
                Assert.True(prev <= priorityQueue.Top);
                prev = priorityQueue.Top;
                // remove top element
                priorityQueue.Pop();
            }
        }
    }
}

...在所有一百万个测试用例中均成功

在此处输入图片说明

因此，似乎Microsoft修复了其实现中的错误：

internal void Pop()
{
    Debug.Assert(_count != 0);
    if (!_isHeap)
    {
        Heapify();
    }

    if (_count > 0)
    {
        --_count;

        // discarding the root creates a gap at position 0.  We fill the
        // gap with the item x from the last position, after first sifting
        // the gap to a position where inserting x will maintain the
        // heap property.  This is done in two phases - SiftDown and SiftUp.
        //
        // The one-phase method found in many textbooks does 2 comparisons
        // per level, while this method does only 1.  The one-phase method
        // examines fewer levels than the two-phase method, but it does
        // more comparisons unless x ends up in the top 2/3 of the tree.
        // That accounts for only n^(2/3) items, and x is even more likely
        // to end up near the bottom since it came from the bottom in the
        // first place.  Overall, the two-phase method is noticeably better.

        T x = _heap[_count];        // lift item x out from the last position
        int index = SiftDown(0);    // sift the gap at the root down to the bottom
        SiftUp(index, ref x, 0);    // sift the gap up, and insert x in its rightful position
        _heap[_count] = default(T); // don't leak x
    }
}

由于问题中的链接仅指向Microsoft源代码的最新版本（当前为.NET Framework 4.8），因此很难说出代码中到底发生了什么更改，但是最值得注意的是，现在有明确的注释不泄漏内存，因此我们可以假设@JimMischel的答案中提到的内存泄漏也已解决，可以使用Visual Studio诊断工具进行确认：

在此处输入图片说明

如果发生内存泄漏，经过数百万次Pop()操作后，我们会在这里看到一些更改...

— 弗雷德里克·霍夫特（Frederik Hoeft）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.