程式碼：

/// <summary>  
        /// 堆排序方法。  
        /// </summary>  
        /// <param name="a">  
        /// 待排序陣列。  
        /// </param>  
        private void Heapsort(int[] a)
        {
            HeapSort_BuildMaxHeap(a); // 建立大根堆。  
            Console.WriteLine("Build max heap:");
            foreach (int i in a)
            {
                Console.Write(i + " "); // 列印大根堆。  
            }

            Console.WriteLine("\r\nMax heap in each iteration:");
            for (int i = a.Length - 1; i > 0; i--)
            {
                HeapSort_Swap(ref a[0], ref a[i]); // 將堆頂元素和無序區的最後一個元素交換。  
                HeapSort_MaxHeaping(a, 0, i); // 將新的無序區調整為大根堆。  

                // 列印每一次堆排序迭代後的大根堆。  
                for (int j = 0; j < i; j++)
                {
                    Console.Write(a[j] + " ");
                }

                Console.WriteLine(string.Empty);
            }
        }

        /// <summary>  
        /// 由底向上建堆。由完全二叉樹的性質可知，葉子結點是從index=a.Length/2開始，所以從index=(a.Length/2)-1結點開始由底向上進行大根堆的調整。  
        /// </summary>  
        /// <param name="a">  
        /// 待排序陣列。  
        /// </param>  
        private static void HeapSort_BuildMaxHeap(int[] a)
        {
            for (int i = (a.Length / 2) - 1; i >= 0; i--)
            {
                HeapSort_MaxHeaping(a, i, a.Length);
            }
        }

        /// <summary>  
        /// 將指定的結點調整為堆。  
        /// </summary>  
        /// <param name="a">  
        /// 待排序陣列。  
        /// </param>  
        /// <param name="i">  
        /// 需要調整的結點。  
        /// </param>  
        /// <param name="heapSize">  
        /// 堆的大小，也指陣列中無序區的長度。  
        /// </param>  
        private static void HeapSort_MaxHeaping(int[] a, int i, int heapSize)
        {
            int left = (2 * i) + 1; // 左子結點。  
            int right = 2 * (i + 1); // 右子結點。  
            int large = i; // 臨時變數，存放大的結點值。  

            // 比較左子結點。  
            if (left < heapSize && a[left] > a[large])
            {
                large = left;
            }

            // 比較右子結點。  
            if (right < heapSize && a[right] > a[large])
            {
                large = right;
            }

            // 如有子結點大於自身就交換，使大的元素上移；並且把該大的元素調整為堆以保證堆的性質。  
            if (i != large)
            {
                HeapSort_Swap(ref a[i], ref a[large]);
                HeapSort_MaxHeaping(a, large, heapSize);
            }
        }

        /// <summary>  
        /// 交換兩個整數的值。  
        /// </summary>  
        /// <param name="a">整數a。</param>  
        /// <param name="b">整數b。</param>  
        private static void HeapSort_Swap(ref int a, ref int b)
        {
            int tmp = a;
            a = b;
            b = tmp;
        }