堆排序 C#实现

今天看堆排序，以前没注意，写个小程序记忆一下。

堆排序实际上就是个完全二叉树，试着画一棵试试，记忆算法很简单，大根堆满足跟比叶子大，小根堆反之。

算法思想见百度百科：

1，先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区

2，再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

3，由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将 R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n- 1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

拿数组 int[] lst = new int[6] { 4, 9, 5, 1, 7, 3};举例说明

(1) 第一次找到最大根 lst[1] = 9,跟lst[5]交换，结果-> { 4, 3, 5, 1, 7，9} ，无序区为{ 4, 3, 5, 1, 7} ，有序区为{9}

(2) 第二次找到 无序区为{ 4, 3, 5, 1, 7}最大根lst[4]=7跟自己交换，结果-> { 4, 3, 5, 1, 7，9} ，无序区为{ 4, 3, 5, 1} ，有序区为{7，9}

(3) 第三次找到 无序区为{ 4, 3, 5, 1}最大根lst[2]=5跟lst[3]=1交换，结果-> { 4, 3, 1, 5, 7，9} ，无序区为{ 4, 3, 1} ，有序区为{5，7，9}

(3) 第四次找到 无序区为{ 4, 3, 1}最大根lst[0]=4跟lst[2]=1交换，结果-> { 1, 3, 4, 5, 7，9} ，无序区为{ 1, 3} ，有序区为{4，5，7，9}

...

时间复杂度O(nlogn)

 

代码如下：

 

 static void Main(string[] args)
        {
            try
            {
                int[] lst = new int[6] { 4, 9, 5, 1, 7, 3};

                foreach (var item in lst)
                {
                    Console.WriteLine(item + ", ");
                }
                Console.WriteLine("---------------------------");

                int maxid = GetMax(lst.Length, lst);
                HeapSort(maxid, lst);

                foreach (var item in lst)
                {
                    Console.WriteLine(item + ", ");
                }

                Console.ReadKey();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.ReadKey();
        }

        /// <summary>
        /// 交换
        /// </summary>
        /// <param name="maxIdx">无序区最大值Idx</param>
        /// <param name="idx">有序区目标位置</param>
        /// <param name="lst">序列</param>
        public static void Swap(int maxIdx, int idx, int[] lst)
        {
            int midx = maxIdx;
            int temp = lst[idx];
            lst[idx] = lst[maxIdx];
            lst[maxIdx] = temp;
        }

        /// <summary>
        /// 获取无序区最大值
        /// </summary>
        /// <param name="maxLen">无序区最大长度</param>
        /// <param name="lst">序列</param>
        public static int GetMax(int maxLen, int[] lst)
        {
            int maxIdx = 0;
            for (var i = 0; i < maxLen; i++)
            {
                if (lst[i] > lst[maxIdx])
                    maxIdx = i;  
            }

            return maxIdx;
        }

        /// <summary>
        /// 堆排序
        /// </summary>
        /// <param name="maxIdx">无序区最大值位置</param>
        /// <param name="lst">序列</param>
        /// <returns>序列</returns>
        public static IList<int> HeapSort(int maxIdx, int[] lst)
        {
            int i = lst.Length - 1;
            int k = 0;

            while (i > -1)
            {
                Swap(maxIdx, i, lst);
                k++;
                //每次缩短无序区最大位置
                maxIdx = GetMax(lst.Length - k, lst);
                i--;
            }

            return lst;
        }