排序算法：堆排序（C#实现）

堆的概念：堆是一种特殊的完全二叉树，每个节点都比他的左右孩子节点大的完全二叉树叫做大顶堆，每个节点都比他的左右孩子节点小的完全二叉树叫做小顶堆。

 算法思路：首先把数组中的元素排列成大顶堆，然后把大顶堆的根节点取出来和最后一个叶子节点互换，然后把堆中的最后一个元素去除，构建新的堆，重复以上步骤，直到排序完成。

算法实现如下：

 class Program
    {
        static void Main(string[] args)
        {
            int[] arr = { 12, 2, 3, 65, 5, 89, 7, 0, 3, 57 };
            HeapSort(arr);
            for(int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine(arr[i]);
            }

        }
        static void HeapSort(int[] arr)
        {
            BuildingMaxHeap(arr);
            for(int i = arr.Length - 1; i > 0; i--)
            {
                Swap(ref arr[0], ref arr[i]);
                MaxHeaping(arr, 0, i);
            }
        }

        static void BuildingMaxHeap(int[] arr)
        {
            for(int i = arr.Length / 2 - 1; i >= 0; i--)
            {
                MaxHeaping(arr, i, arr.Length);
            }
        }

        static void MaxHeaping(int[] arr,int i,int heapSize)
        {
            int leftChild = i * 2 + 1;
            int rightChild = i * 2 + 2;
            int large = i;
            if (leftChild < heapSize && arr[leftChild] > arr[large])
            {
                large = leftChild;
            }
            if(rightChild < heapSize && arr[rightChild] > arr[large])
            {
                large = rightChild;
            }
            if (large != i)
            {
                Swap(ref arr[large], ref arr[i]);
                MaxHeaping(arr, large, heapSize);
            }
        }

        static void Swap(ref int a,ref int b)
        {
            int temp = a;
            a = b;
            b = temp;
        }
    }