zoukankan      html  css  js  c++  java
  • 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.
  • 相关阅读:
    PAT 个位数统计
    Least Common Multiple
    PAT 输出华氏-摄氏温度转换表
    害死人不偿命的(3n+1)猜想
    牛客小白月赛1 A-简单题
    结构体 查找书籍
    TZOJ 复习时间
    JS 瀑布流效果
    JS浏览器对象
    JS 数组相关
  • 原文地址:https://www.cnblogs.com/xuyanran/p/8415918.html
Copyright © 2011-2022 走看看