一種二叉堆的泛化實現

本文列出了一種二叉堆的泛化實現方法

所謂二叉堆,其實就是一種完全二叉樹或者近似完全二叉樹,樹中父節點的鍵值總是保持某種固定的序關係於任何一個子節點的鍵值 ,且每個節點的左子樹 和右子樹 也都是二叉堆 .

這裡列出一種二叉堆的泛化實現方法,其中值得一提的地方有這麼幾處:

• 泛化資料型別,方法自然是使用泛型實現
• 泛化序關係的表達方式,傳統的最大堆和最小堆實現一般就是直接使用數值的大小比較,泛化的方法則是使用泛型委託
• 實現了一種類似於空間劃分的元素查詢方法

完整的程式碼可以在gist 上找到:

using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.Collections.ObjectModel;

public class Heap<T> where T : IEquatable<T>
{
public static Heap<T> Build(IEnumerable<T> items, Func<T, T, bool> predicate)
{
var heap = new Heap<T>(predicate);

if (items != null)
{
var iter = items.GetEnumerator();
while (iter.MoveNext())
{
var item = iter.Current;
heap.Add(item);
}
}

return heap;
}

/*
public static Heap<T> Build2(IEnumerable<T> items, Func<T, T, bool> predicate)
{
var heap = new Heap<T>(predicate);

if (items != null)
{
heap.m_items.AddRange(items);
var itemCountIndexBegin = heap.m_items.Count / 2;
var itemCountIndexEnd = 1;
for (int i = itemCountIndexBegin; i >= itemCountIndexEnd; --i)
{
// NOTE this requires Heapify() just do "down-heap" operation
//now Heapify() do both "up-heap" and "down-heap" operation
heap.Heapify(i - 1);
}
}

return heap;
}
*/

Func<T, T, bool> m_predicate;
List<T> m_items = new List<T>();

public int Count
{
get
{
return m_items.Count;
}
}

public ReadOnlyCollection<T> Items
{
get
{
return m_items.AsReadOnly();
}
}

public T this[int index]
{
get
{
return m_items[index];
}
}

public Heap(Func<T, T, bool> predicate)
{
Debug.Assert(predicate != null);
m_predicate = predicate;
}

int IndexOfRecur(T item, int itemIndex)
{
if (IsValidIndex(itemIndex))
{
if (!m_predicate(item, m_items[itemIndex]))
{
// not found
return -1;
}
else
{
if (m_items[itemIndex].Equals(item))
{
return itemIndex;
}
else
{
var itemCountIndex = itemIndex + 1;
var childCountIndexLeft = itemCountIndex * 2;
var childIndexLeft = childCountIndexLeft - 1;

var index = IndexOfRecur(item, childIndexLeft);
if (index >= 0)
{
return index;
}
else
{
var childCountIndexRight = itemCountIndex * 2 + 1;
var childIndexRight = childCountIndexRight - 1;
return IndexOfRecur(item, childIndexRight);
}
}
}
}

// default return -1
return -1;
}

// return -1 when not found(recur)
public int IndexOf(T item)
{
return IndexOfRecur(item, 0);
}

// return -1 when not found(iterator)
public int IndexOf2(T item)
{
return m_items.IndexOf(item);
}

public void Add(T item)
{
m_items.Add(item);
Heapify(m_items.Count - 1);
}

public void Remove(T item)
{
var itemIndex = IndexOf(item);
if (itemIndex >= 0)
{
Swap(itemIndex, m_items.Count - 1);
m_items.RemoveAt(m_items.Count - 1);
Heapify(itemIndex);
}
}

public void RemoveAt(int itemIndex)
{
if (IsValidIndex(itemIndex))
{
Swap(itemIndex, m_items.Count - 1);
m_items.RemoveAt(m_items.Count - 1);
Heapify(itemIndex);
}
}

public void Clear()
{
m_items.Clear();
}

bool IsValidIndex(int itemIndex)
{
return itemIndex >= 0 && itemIndex < m_items.Count;
}

void Swap(int index1, int index2)
{
if (IsValidIndex(index1) && IsValidIndex(index2))
{
var temp = m_items[index1];
m_items[index1] = m_items[index2];
m_items[index2] = temp;
}
}

void Heapify(int itemIndex)
{
if (IsValidIndex(itemIndex))
{
var itemCountIndex = itemIndex + 1;

// first check parent
var parentCountIndex = itemCountIndex / 2;
var parentIndex = parentCountIndex - 1;
if (IsValidIndex(parentIndex) && !m_predicate(m_items[itemIndex], m_items[parentIndex]))
{
while (IsValidIndex(itemIndex) && IsValidIndex(parentIndex) && !m_predicate(m_items[itemIndex], m_items[parentIndex]))
{
Swap(itemIndex, parentIndex);

// update index
itemIndex = parentIndex;
itemCountIndex = itemIndex + 1;
parentCountIndex = itemCountIndex / 2;
parentIndex = parentCountIndex - 1;
}
}
else
{
// then check child
var childCountIndexLeft = itemCountIndex * 2;
var childIndexLeft = childCountIndexLeft - 1;
var childCountIndexRight = itemCountIndex * 2 + 1;
var childIndexRight = childCountIndexRight - 1;

while (IsValidIndex(childIndexLeft))
{
if (IsValidIndex(childIndexRight))
{
if (!m_predicate(m_items[childIndexLeft], m_items[itemIndex]) || !m_predicate(m_items[childIndexRight], m_items[itemIndex]))
{
if (!m_predicate(m_items[childIndexLeft], m_items[itemIndex]) && m_predicate(m_items[childIndexRight], m_items[itemIndex]))
{
Swap(childIndexLeft, itemIndex);

itemIndex = childIndexLeft;
itemCountIndex = childCountIndexLeft;
}
else if (m_predicate(m_items[childIndexLeft], m_items[itemIndex]) && !m_predicate(m_items[childIndexRight], m_items[itemIndex]))
{
Swap(childIndexRight, itemIndex);

itemIndex = childIndexRight;
itemCountIndex = childCountIndexRight;
}
else
{
if (m_predicate(m_items[childIndexLeft], m_items[childIndexRight]))
{
// left should be child
Swap(childIndexRight, itemIndex);

itemIndex = childIndexRight;
itemCountIndex = childCountIndexRight;
}
else
{
// right should be child
Swap(childIndexLeft, itemIndex);

itemIndex = childIndexLeft;
itemCountIndex = childCountIndexLeft;
}
}

// update index
childCountIndexLeft = itemCountIndex * 2;
childIndexLeft = childCountIndexLeft - 1;
childCountIndexRight = itemCountIndex * 2 + 1;
childIndexRight = childCountIndexRight - 1;
}
else
{
// break since fit
break;
}
}
else
{
// right child is invalid, reach end
if (!m_predicate(m_items[childIndexLeft], m_items[itemIndex]))
{
Swap(childIndexLeft, itemIndex);
}

// break since reach end
break;
}
}
}
}
}
}

參考資料

• 二叉堆

不出意外的話,這應該是 2019 新年之前的最後的一篇博文,來年繼續吧~