• Heap Sort


    Heap Sort 

    1. Build a max heap using exsiting array, which is called Heapify
    2. Swap root with the last element, and re-Heapify the root node

    Heapify

    Heapify(array, n, i) = 1) compare node[i] with children   2)node[i] is already the largest one, no op.  3) child is largest one, swap, then Heapify(array, n, 2*i + 1 or 2i* + 2)

    Code

        public class HeapSort
        {
            /// <summary>
            /// Heapify the array
            /// </summary>
            /// <param name="array">array</param>
            /// <param name="n">total size of the heap</param>
            /// <param name="i">starting node</param>
            public void Heapify(int[] array, int n, int i)
            {
                int left = 2*i + 1;
                int right = 2*i + 2;
    
                int largest = i;
    
                if (left < n)
                {
                    if (array[left] > array[largest])  //  <---- 此处注意,要用array[largest] instead of array[i], 这样我们可以一直跟踪最大的下标, 而不会错误的交换次大的下标
                    {
                        largest = left;
                    }
                }
    
                if (right < n)
                {
                    if (array[right] > array[largest])
                    {
                        largest = right;
                    }
                }
    
                if (largest != i)
                {
                    int temp = array[i];
                    array[i] = array[largest];
                    array[largest] = temp;
                    Heapify(array, n, largest);
                }
            }
    
            public void BuildHeap(int[] array)
            {
                for(int i = array.Length / 2 - 1; i >= 0; i--)
                {
                    Heapify(array, array.Length, i);
                }
            }
    
            public void Sort(int[] array)
            {
                if (array == null || array.Length == 0)
                {
                    return;
                }
    
                BuildHeap(array);
    
                for(int i = array.Length - 1; i >= 0; i--)
                {
                    Swap(ref array[0], ref array[i]);
                    Heapify(array, i, 0);
                }
            }
    
            public void Print(int[] array)
            {
                for(int i = 0; i < array.Length; i++)
                {
                    Console.WriteLine(array[i]);
                }
            }
    
            private void Swap(ref int a, ref int b)
            {
                int temp = a;
                a = b;
                b = temp;
            }
        }

    Comments

    1. Heap sort is a in place sort.
    2. Time complexity is O(NLogN) for Heapify.A quick look over the above algorithm suggests that the running time is O(nlg(n)), since each call to Heapify costs O(lg(n)) and Build-Heap makes O(n) such calls.
  • 相关阅读:
    js 的防抖与节流
    Vue---图形二维码、rules校验规则、el-dialog展示图片
    vue ----弹框
    vue的背景加载--旋转*号
    利用ES6新特性将时间戳转换为yyyy-mm-dd格式
    路由守卫之离开守卫
    Java的运行环境与开发环境
    list<map<string,object>> 按照某字段排序
    没有CSRF保护的HTML表单 漏洞解决办法
    通过mybatis-plus的分页插件,实现分页
  • 原文地址:https://www.cnblogs.com/xuyanran/p/8415918.html
Copyright © 2020-2023  润新知