堆排序HeapSort

1. 堆排序与快速排序，归并排序一样都是时间复杂度为O(N*logN)的几种常见排序方法。学习堆排序前，先讲解下什么是数据结构中的二叉堆。

二叉堆的定义

二叉堆是完全二叉树或者是近似完全二叉树。

二叉堆满足二个特性：

 1）父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。

 2）每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆

堆分为大顶堆和小顶堆,其中下图（1）中是大顶堆，（2）为小顶堆

2.   堆排序的思想

   利用大顶堆(小顶堆)堆顶记录的是最大关键字(最小关键字)这一特性，使得每次从无序中选择最大记录(最小记录)变得简单。

    其基本思想为(大顶堆)：

    1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；

    2)将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n]; 

    3)由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

下面举例说明(大顶堆)：

     给定一个整形数组a[]={16,7,3,20,17,8}，对其进行堆排序。

    1）首先根据该数组元素构建一个完全二叉树，得到

 

 2）然后需要构造初始堆，则从最后一个非叶节点开始调整，调整过程如下：

20和16交换后导致16不满足堆的性质，因此需重新调整

这样就得到了初始堆。

即每次调整都是从父节点、左孩子节点、右孩子节点三者中选择最大者跟父节点进行交换(交换之后可能造成被交换的孩子节点不满足堆的性质，因此每次交换之后要重新对被交换的孩子节点进行调整)。有了初始堆之后就可以进行排序了。

3)

此时3位于堆顶不满堆的性质，则需调整继续调整

其实就是每次把堆顶元素和最后没交换过的子节点元素交换，然后将此子节点之前的二叉树重新排序，变成大顶堆。

如果按递增排序，需要用到大顶堆，每次把堆顶（无序堆最大值）放到有序堆前面，重新得到无序区大顶堆；

如果按递减排序，需要用到小顶堆，每次把堆顶（无序堆最小值）放到有序堆前面，重新得到无序区小顶堆；

程序如下（包含递增和递减）：

 

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

namespace conHeapSort
{
    class HeapSort
    {
        private static Boolean Asce = true;//heap sorted by ascending order
        private static Boolean Desc = false;//heap sorted by descending order
        static void Main(string[] args)
        {
            List<int> input = new List<int>();
            HeapSort exap = new HeapSort();
            String str;

            input.Add(0);//start from index one
            str = Console.ReadLine();
            while(str != "exit"){
                input.Add(Int32.Parse(str));
                str = Console.ReadLine();
            }

            exap.SortHeap(input, Desc);
            for (int i = 1; i < input.Count; i++ )
            {
                Console.WriteLine(input[i].ToString());
            }
        }
        void SortHeap(List<int> data, Boolean order)
        {
            BuildHeap(data, order);

            if (order)
            {
                for (int i = data.Count - 1; i >= 1; i--)
                {
                    Swap(data, 1, i); //exchange between index 1 and index i
                    MaxHeap(data, 1, i - 1); //get max heap
                }
            }
            else
            {
                for (int i = data.Count - 1; i >= 1; i--)
                {
                    Swap(data, 1, i);//exchange between index 1 and index i
                    MinHeap(data, 1, i - 1); //get min heap
                }
            }
        }
        void BuildHeap(List<int> data, Boolean order)
        {
            if (order) //make maximal heap
            {
                for (int i = data.Count / 2; i >= 1; i--)
                {
                    MaxHeap(data, i, data.Count - 1); //initialize
                }
            }
            else //make minimal heap
            {
                for (int i = data.Count / 2; i >= 1; i--)
                {
                    MinHeap(data, i, data.Count - 1);//initialize
                }
            }
        }
        //get max heap
        void MaxHeap(List<int> data, int i, int size)
        {
            int lchild = 2 * i;
            int rchild = lchild + 1;
            int max = i;
            if (i <= size / 2)
            {
                if (lchild <= size && data[lchild] > data[max])
                {
                    max = lchild;
                }
                if (rchild <= size && data[rchild] > data[max])
                {
                    max = rchild;
                }
                if (max != i)
                {
                    Swap(data, i, max); //exchange child and parent node
                    MaxHeap(data, max, size); //continue to adjust 
                }
            }
        }
        //get min heap
        void MinHeap(List<int> data, int i, int size)
        {
            int lchild = 2 * i;
            int rchild = lchild + 1;
            int min = i;
            if (i <= size / 2)
            {
                if (lchild <= size && data[lchild] < data[min])
                {
                    min = lchild;
                }
                if (rchild <= size && data[rchild] < data[min])
                {
                    min = rchild;
                }
                if (min != i)
                {
                    Swap(data, i, min);//exchange child and parent node
                    MinHeap(data, min, size);
                }
            }
        }
        //exchange index1 and index2 in data
        void Swap(List<int> data, int index1, int index2)
        {
            int temp = data[index2];
            data[index2] = data[index1];
            data[index1] = temp;
        }
    }
}