• 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.
  • 相关阅读:
    Java 面向对象(十二)类的成员 之 代码块
    Java 关键字:static
    Java 常用类(二):包装类(Wrapper)
    Java 之 clone 方法(对象拷贝)
    SQL分组聚合查询
    Rabbitmq消息持久化
    idea 插件
    TCP粘包,拆包及解决方法
    redis内存淘汰策略及如何配置
    MySQL存储过程/存储过程与自定义函数的区别
  • 原文地址:https://www.cnblogs.com/xuyanran/p/8415918.html
Copyright © 2020-2023  润新知