堆排序

最近正在研究的算法中有用到堆排序，因此上网搜集了资料，研究了一下堆排序，在此对于什么是堆，以及堆排序的概念就不讲解了，网上有很多文章讲解的，这里只是说明了在.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