性質

• 結構近似完全二叉樹 構建時 從上到下 從左到右
• 子節點的鍵值總是都大於(或小與)父節點鍵值

通常處理順序

• 根據陣列構建堆

        /// <summary>
        /// 根據陣列構建堆
        /// </summary>
        /// <param name="nums"></param>
        public static void BuildHeapify(int[] nums)
        {
            //總節點個數
            var n = nums.Length ;
            var lastNodeIndex = n - 1;
            //獲取最後一個子節點對應的父節點下標
            var parent = (lastNodeIndex - 1) / 2;
            //從tree的最後一個節點進行heapify 依次向上heapify
            for (int i = parent; i >=0; i--)
            {
                Heapify(nums,nums.Length,i);
            }

        }

        /// <summary>
        /// 構建堆 從根節點i 進行構建
        /// </summary>
        /// <param name="nums"></param>
        /// <param name="n">堆的總節點數</param>
        /// <param name="i">構建起點--根節點對應陣列下標</param>
        public static void Heapify(int[] nums, int n, int i)
        {
            if (i > n)
                return;
            var max = i;
            //獲取i的子節點C1下標
            var c1 = 2 * i + 1;
            //獲取i的子節點C2下標
            var c2 = 2 * i + 2;
            //比較獲取 根節點i i的子節點C1 i的子節點C2  三者中的最大值 
            if (c1 < n && nums[c1] > nums[max])
                max = c1;
            if (c2 < n && nums[c2] > nums[max])
                max = c2;
            if (max != i)
            {
                Swap(nums, i, max);
                //再將交換的子節點 作為父節點 將其下的子節點進行heapify（迭代）
                Heapify(nums, n, max);
            }
        }
 

• 構建堆後 將最大值與最後一個節點交換 再將除最大節點的剩餘節點進行排序 最後所有的值都按從小到大進行排序了

 public static void HeapifySort(int[] nums,int n)
        {
            BuildHeapify(nums);
            for (int i = n-1; i >=0; i--)
            {
                //將最大值與最後一個節點交換 再將除最大節點的剩餘節點進行排序
                Swap(nums, 0, i);
                Heapify(nums, i, 0);
            }
        }