堆排序

最近正在研究的算法中有用到堆排序，因此上網蒐集了資料，研究了一下堆排序，在此對於什麼是堆，以及堆排序的概念就不講解了，網上有很多文章講解的，這裏只是說明了在.Net中時如何實現的。

下面我們就一起走進C#中的堆排序實現。

對於堆排序，我們必不可少的步驟就是更新堆，使得無序序列符合堆的定義。這個步驟是至關重要的，無論是在插入元素到堆中，還是刪除堆元素，或者進行堆排序，更新堆是頻繁使用到的。下面的代碼中有兩個版本的實現，一個是使用遞歸的方式，一個是非遞歸的方式。

非遞歸的實現：

        private void MinHeapDown(int i, int n)
        {
            int j, temp;
            temp = heapData[i];
            j = 2 * i + 1;
            while (j < n)
            {
                if (j + 1 < n && heapData[j + 1] < heapData[j])
                {
                    //在左右子樹中尋找最小的
                    j++;
                }

                if (heapData[j] >= temp)
                {
                    break;
                }
                heapData[i] = heapData[j];

                //更新子樹
                i = j;
                j = 2 * i + 1;
            }
            heapData[i] = temp;
        }

遞歸的實現：

        private void Heapify(int current, int n)
        {
            int left = 2 * current + 1;
            int right = 2 * current + 2;
            int largest = current;

            if (left<n && Compare(heapData[left],heapData[current]))
            {
                largest = left;
            }
            if (right<n&& Compare(heapData[right],heapData[largest]))
            {
                largest = right;
            }

            if (largest!=current)
            {
                int temp = heapData[current];
                heapData[current] = heapData[largest];
                heapData[largest] = temp;
                Heapify(largest, n);
            }
           
        }

其中Compare函數如下：

        private bool Compare(int x1, int x2)
        {
            return x1 > x2 ? true : false;
        }

接下來我們看看堆的構造過程：

        private void MakeMinHeap(int n)
        {
            for (int i = n / 2 - 1; i >= 0; i--)
            {
                this.MinHeapDown(i, n);
            }
        }

當然遞歸實現更新堆的構造堆的過程也是一樣的：

        private void BuildHeap(int n)
        {
            for (int i = n / 2 - 1; i >= 0;i-- )
            {
                Heapify(i, n);
            }
        }

構造完成堆之後，我們看看堆排序

        private void MinHeapSort(int n)
        {
            for (int i = n - 1; i >= 1; i--)
            {
                Swap(0, i);
                MinHeapDown(0, i);
            }
        }

堆排序（更新堆是用遞歸方式實現的）

        private void HeapSort()
        {
            int temp;
            for (int i = heapData.Count - 1; i >= 0;i-- )
            {
                temp = heapData[0];
                heapData[0] = heapData[i];
                heapData[i] = temp;
                Heapify(0, i);
            }
        }

需要注意的是，在代碼中使用的變量heapData的定義，這是一個私有變量，在構造堆之前需要對其進行初始化，也就是填充數據：

      private List<int> heapData = new List<int>();

上面說的堆排序的過程是先初始化數據之後排序，當然也可以在讀取一個數據之後進行插入排序，首先將數據插入到堆（數組）尾，然後更新這個堆即可。

上圖是使用非遞歸的方式。

上圖是使用遞歸的方式。

到此我們的說明就結束了，謝謝！

代碼下載

參考文章：

http://blog.chinaunix.net/uid-20681545-id-252772.html

http://blog.csdn.net/morewindows/article/details/6709644