C# 实现堆排序算法源码

将开发过程中比较好的内容做个记录，下边内容段是关于C# 实现堆排序算法的内容，应该对各位朋友也有用。

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;

using Demo.Arithmetic.Sort;

namespace Demo.Arithmetic.DS
{
public class Heap where T : IComparable
{
HeapType _heapType = HeapType.BigRoot;

    T[] _rawData;

    public Heap(int capability, HeapType heapType)
    {
        _rawData = new T[capability];

        _heapType = heapType;
    }

    #region Public methods

    public void Sort(SortOrder sortOrder)
    {
        if (sortOrder == SortOrder.None) return;
        if (_rawData == null || _rawData.Length <= 1) return;

        HeapType formerHeapType = _heapType;

        _heapType = sortOrder == SortOrder.Ascending ? HeapType.BigRoot : HeapType.SmallRoot;

        BuildHeap();

        for (int i = _rawData.Length - 1; i > 0; i--)
        {
            Exchange(0, i);
            Heapify(0, i - 1);
        }

        _heapType = formerHeapType;
    }

    public void BuildHeap()
    {
        for (int i = _rawData.Length / 2 - 1; i >= 0; i--)
        {
            Heapify(i, _rawData.Length - 1);
        }
    }

    public void Heapify(int rootIndex, int lastIndex)
    {
        if (IsLeaf(rootIndex, lastIndex)) return;

        int nextRootIndex = GetRootIndex(rootIndex, lastIndex);

        if (nextRootIndex == rootIndex)
        {
            return;
        }
        else
        {
            Exchange(rootIndex, nextRootIndex);

            Heapify(nextRootIndex, lastIndex);
        }
    }

    #endregion

    #region Private methods

    private int GetRootIndex(int rootIndex, int lastIndex)
    {
        int tLeftIndex = rootIndex + rootIndex + 1;
        if (tLeftIndex > lastIndex) return rootIndex;

        int nextRootIndex = ((_heapType == HeapType.BigRoot && _rawData[rootIndex].CompareTo(_rawData[tLeftIndex]) > 0) ||
            (_heapType == HeapType.SmallRoot && _rawData[rootIndex].CompareTo(_rawData[tLeftIndex]) < 0)) ?
            rootIndex : tLeftIndex;

        int tRightIndex = rootIndex + rootIndex + 2;
        if (tRightIndex > lastIndex) return nextRootIndex;

        nextRootIndex = ((_heapType == HeapType.BigRoot && _rawData[nextRootIndex].CompareTo(_rawData[tRightIndex]) > 0) ||
            (_heapType == HeapType.SmallRoot && _rawData[nextRootIndex].CompareTo(_rawData[tRightIndex]) < 0)) ?
            nextRootIndex : tRightIndex;

        return nextRootIndex;
    }

    private void Exchange(int firstIndex, int secondIndex)
    {
        T temp = _rawData[firstIndex];
        _rawData[firstIndex] = _rawData[secondIndex];
        _rawData[secondIndex] = temp;
    }

    #endregion

    #region Static methods

    private static bool IsLeaf(int nodeIndex, int lastIndex)
    {
        return nodeIndex + nodeIndex + 1 > lastIndex;
    }

    #endregion

    #region Properties

    public T this[int i]
    {
        get
        {
            return _rawData[i];
        }

        set
        {
            _rawData[i] = value;
        }
    }

    public int Capability
    {
        get
        {
            return _rawData.Length;
        }
    }

    #endregion
}

public enum HeapType
{ 
    BigRoot = 0x00,
    SmallRoot = 0x01
}

}