堆排序

1. 堆简单介绍，数据存储及堆上定义的操作

2. 堆排序简单实现及算法的时间复杂度

3. 代码下载

 

1. 堆简单介绍，数据存储及堆上的定义的操作

二叉堆在本文中使用数组(.net中的List)来存储，它可以完全被看作是一颗二叉树。

 

除了叶子节点外，其他每层都是满的。二叉堆可以分为最大堆和最小堆。最大堆定义如下：

 

有定义可知，最大堆中中根元素是最大的。最小堆定义与最大堆定义正好相反，最小堆中根元素是最小元素。下面定义堆上的操作。

1. 给定某个节点下标i，该节点的父节点PARENT(i) = floor(i / 2)

2. 给定某个节点下标i，该节点的左孩子LEFT(i) = 2 * i

3. 给定某个节点下标i，该节点的右孩子RIGHT(i) = 2 × i + 1；

4. 定义操作MaxHeapfiy，该函数保持堆栈特性，时间负责度lg(n)

5. 定义堆排序HeapSort，时间复杂度nlg(n)

6. 下面定义有限队列操作。HeapMaxium返回堆栈中最大元素

7. HeapExtractMax函数返回堆中最大元素，同时将最大元素从堆栈中删除

8. HeapInsert向堆栈中插入一个元素

9. HeapIncreaseKeyValue增加堆中某个元素的值 

2. 堆排序的简单实现及算法的时间复杂度

下面是上面定义操作的伪代码实现：

 MaxHeapfiy：

BuildMaxHeap: 

HeapSort:

 

实现代码如下： 

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

namespace Alice.DataStructure
{
    public class Heap
    {
        // 数据存储 
        private List<int> heapData = new List<int>();
        private int length;
 
#region 构造函数
        public Heap(List<int> data)
        {
            this.heapData = data;
            this.length = data.Count;
        }
        
        // 默认构造函数
        public Heap()
        {
            this.length = 0;
        }
#endregion

#region 堆上操作
        // 父节点下标
        public int Parent(int i)
        {
            // 向下取整
            return (int)(i / 2);
        }

        // 左孩子下标
        public int Left(int i)
        {
            // 由于list的第一个元素的下标是0
            return (2 * i) + 1;
        }

        // 右孩子下标
        public int Right(int i)
        {
            // 由于list的第一个元素的下标是0
            return (2 * i + 2);

        }


        // 建立最大堆，这里假设left和right对应的子树已经
        // 是最大堆
        public void MaxHeapify(int i)
        {
            int left = this.Left(i);
            int right = this.Right(i);
            // 递归出口条件
            // 1. left超界，return
            // 2. left未超界，right超界，继续
            // 3. left未超界，right未超界，继续
            if ((left > (this.length - 1)))
                return;

            // 查找i，left，right中的最大值
            int largest = i;        // largest最大元素下标
            // 这里需要加上限制条件来判断是否能够使用left和right
            if ( (left <= this.length - 1) &&  (this.heapData[left] > this.heapData[largest]))
                largest = left;
            if ( (right <= this.length - 1) && (this.heapData[right] > this.heapData[largest]))
                largest = right;

            // 递归调用
            int tmp;
            if (largest != i)
            {
                // 交换largest和i的值
                tmp = this.heapData[largest];
                this.heapData[largest] = this.heapData[i];
                this.heapData[i] = tmp;

                // 递归调用
                
                this.MaxHeapify(largest);
            }
        }

        // 建立最大堆，调用MaxHeapify
        public void BuildMaxHeap()
        {
            // 从数组的最后位置开始计算
            int last = (this.length + 1) / 2 - 1;
            for (int i = last; i >= 0; --i)
            {
                this.MaxHeapify(i);
            }
        }


        // 堆排序
        public void HeapSort()
        {
            this.BuildMaxHeap();
            Console.WriteLine(this.ToString());

            int tmp;
            // 交换第一个元素和最后一个元素
            for (int i = 0; this.length > 0; ++i )
            {
                // 交换第一个元素和最后一个元素
                tmp = this.heapData[0];
                this.heapData[0] = this.heapData[this.length - 1];
                this.heapData[this.length - 1] = tmp;

                // 堆长度减少1
                this.length--;
                // 保持堆特性
                this.MaxHeapify(0);
            }
        }

        // 输出堆栈中内容
        public override string ToString()
        {
            System.Text.StringBuilder builder = 
                new System.Text.StringBuilder();
            for (int i = 0; i < this.length - 1; ++i )
            {
                builder.Append(this.heapData[i] + "\t");
            }

            return builder.ToString();
        }
#endregion

#region 优先队列操作
        // 仅仅是返回最大堆中的最大元素
        public int HeapMaximum()
        {
            return this.heapData[0];
        }

        // 提取最大堆的最大元素，并将该元素删除
        public int HeapExtractMax()
        {
            // 得到最大值
            int max = this.heapData[0];

            // 交换最后一个和第一个元素
            this.heapData[0] = this.heapData[this.length - 1];
            this.length--;
            
            // 保持堆特性
            this.MaxHeapify(0);

            // 返回最大值
            return max;
        }

        // 增加堆中第i个元素的值为val 
        public void  HeapIncreaseKeyValue(int i, int val)
        {
            if (val < this.heapData[i])
                return;
            this.heapData[i] = val;

            // 保持堆特性
            int tmp;
            // 
            while ( (i >= 0) && 
                (this.heapData[i] > this.heapData[this.Parent(i)]))
            {
                tmp = this.heapData[i];
                this.heapData[i] = this.heapData[this.Parent(i)];
                this.heapData[this.Parent(i)] = tmp;
                
                i = this.Parent(i);
            }
        }

        // 向堆大队中插入元素val
        public void HeapInsert(int val)
        {
            this.length++;
            this.heapData.Add(int.MinValue);

            this.HeapIncreaseKeyValue((this.length - 1), val);
        }
#endregion

        public int Get(int i)
        {
            if (i > this.length - 1)
                throw new Exception();

            return this.heapData[i];
        }
    }

}  

 其中需要注意的是：

1. 如何对所有情况进行分类讨论。

2. 对于函数传递的参数，不去假设出入参数的可用性，需要进行参数的检查。

3. 递归算法中如何确定递归的终止条件：只能通过简单的实例来验证，然后debug，最终确定递归终止条件。

 

3. 代码下载

/Files/xuqiang/Heap.rar