算法：堆（Heap）

背景

Heap 可以用來實現優先級隊列，也可以用來做堆排序，本文簡單的做個介紹。

Heap

規則

• 是一個完全二叉樹，隱含的意思是：他是平衡的、使用數組進行存儲也是連續的。
• 給定的任意節點，該節點小於等於其父親節點，大於他們的孩子節點。

基礎知識

對於一個完全二叉樹，如果將其存儲到數組中，給定父節點的索引為：x，則：

• left child's index is：2*x + 1。
• right child's index is：2*x + 2。
• root's index is：0.

說明：上面的公式很容易自己推到出來，有興趣的朋友可以推到一下，這樣就不用記住這個特性了。

圖示

存儲到數組的順序為：先存儲第一層，然后是第二層，直到第 N 層。

操作

添加和刪除后還必須保證 Heap 滿足規則。

添加

添加前

添加 6

先將 6 添加到完全樹的下一個節點，然后沿着祖先路徑，將其插入到合適的節點（不一定是根節點）。

代碼

            public void Insert(T item)
            {
                if (this.IsFull())
                {
                    throw new InvalidOperationException("容量已滿，不能插入！");
                }

                _items[_length++] = item;
                this.MoveUp(_length - 1);
            }

結果

刪除最大值

接着上面的例子執行刪除

先將刪除根節點（6），再將完全樹最后的節點（2）直接移動到根節點。 

接着將 2 向下插入到合適的節點，比如：5 > 4 && 5 > 2，因此結果是：

代碼

            public T Remove()
            {
                if (this.IsEmpty())
                {
                    throw new InvalidOperationException("容量已空，不能刪除！");
                }

                var result = _items[0];
                _items[0] = _items[--_length];
               
                this.MoveDown(0);

                return result;
            }

完整代碼

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DataStuctureStudy.Heaps
{
    class HeapTest
    {
        public static void Test()
        {
            var heap = new Heap<int>(10);
            heap.Insert(1);
            heap.Insert(2);
            heap.Insert(3);
            heap.Insert(4);
            heap.Insert(5);
            heap.Insert(6);
            heap.Display();
            heap.Remove();
            heap.Display();
        }

        class Heap<T>
            where T : IComparable<T>
        {
            private T[] _items;
            private int _length;

            public Heap(int size)
            {
                _items = new T[size];
            }

            public void Display()
            {
                Console.WriteLine("數組表示");
                Console.Write("[");
                for (var i = 0; i < _items.Length; i++)
                {
                    if (i < _length)
                    {
                        Console.Write(_items[i]);
                    }
                    else
                    {
                        Console.Write('-');
                    }
                }
                Console.WriteLine("]");
                Console.WriteLine();

                Console.WriteLine("樹形表示");
                var row = 0;
                var column = 0;
                var level = (int)Math.Ceiling(Math.Log(_length + 1, 2));
                var width = (int)Math.Pow(2, level);
                for (var i = 0; i < _length; i++)
                {
                    this.Display(_items[i], width, row, column);

                    if ((i + 1) == Math.Pow(2, row + 1) - 1)
                    {
                        row++;
                        column = 0;
                        Console.WriteLine();
                    }
                    else
                    {
                        column++;
                        if (i == _length - 1)
                        {
                            Console.WriteLine();
                        }
                    }
                }

                Console.WriteLine();
            }

            private void Display(T item, int width, int row, int column)
            {
                var step = (int)((width * 3) / Math.Pow(2, row));
                var itemLength = item.ToString().Length;
                Console.Write(item.ToString().PadLeft((step + itemLength) / 2).PadRight(step));
            }

            public void Insert(T item)
            {
                if (this.IsFull())
                {
                    throw new InvalidOperationException("容量已滿，不能插入！");
                }

                _items[_length++] = item;
                this.MoveUp(_length - 1);
            }

            private void MoveUp(int index)
            {
                var bottom = _items[index];
                var current = index;

                while (current > 0)
                {
                    var parent = (current - 1) / 2;
                    if (_items[parent].CompareTo(bottom) > 0)
                    {
                        break;
                    }

                    _items[current] = _items[parent];
                    current = parent;
                }

                _items[current] = bottom;
            }

            public T Remove()
            {
                if (this.IsEmpty())
                {
                    throw new InvalidOperationException("容量已空，不能刪除！");
                }

                var result = _items[0];
                _items[0] = _items[--_length];
               
                this.MoveDown(0);

                return result;
            }

            private void MoveDown(int index)
            {
                var top = _items[index];
                var current = index;

                while (current < _length)
                {
                    var large = 0;
                    var left = 2 * current + 1;
                    var right = left + 1;

                    if (left < _length && right < _length)
                    {
                        if (_items[left].CompareTo(_items[right]) >= 0)
                        {
                            large = left;
                        }
                        else
                        {
                            large = right;
                        }
                    }
                    else if (left < _length)
                    {
                        large = left;
                    }
                    else
                    {
                        break;
                    }

                    if (_items[large].CompareTo(top) <= 0)
                    {
                        break;
                    }

                    _items[current] = _items[large];
                    current = large;
                }

                _items[current] = top;
            }

            public bool IsFull()
            {
                return _length == _items.Length;
            }

            public bool IsEmpty()
            {
                return _length == 0;
            }
        }
    }
}

備注

下篇簡單的介紹一下堆排序。