码迷,mamicode.com
首页 > 编程语言 > 详细

算法排序之堆排序

时间:2017-10-12 13:08:09      阅读:162      评论:0      收藏:0      [点我收藏+]

标签:else   ati   .net   [1]   []   接下来   递归   上进   lock   

在算法导论第三版中介绍“堆排序是一种原地排序,如果试图引入数组,那么将失去这一优势。”堆排序的基础是在原有堆上进行排序,即将等待排序的集合先建堆

1.建立最大堆(Max_Heapify)

 

最大堆满足条件A[Parent[i]]>=A[i] 
最大堆唯一能确立的就是数组中的最大元素,相当于一个复杂的Max方法,但是重新确立一个最大堆比较快

 

 

//伪代码片段
Max_Heapify(A,i) l=LEFT(i) r=RIGHT(i) if l<=A.heap-size and A[l]>A[i] largest=l else largest=i if r<=A.heap-size and A[r]>A[largest] largest=r if largest !=i exchange A[i] with A[largest] Max_Heapify(A,largest)

 

 

2.堆排序(Heap_Sort)

每次从最大堆中选出第一个元素Array[0](数组中最大的元素),将其与最后一个元素Array[n-1]交换,这样最大元素就放到了最后一个位子,接下来就可以把它剔除了,n–1,将刚刚的Arrayn-1在新的最大堆(元素少了一个,挑一个最大的出来)中找到合适的位置。 

相当于第一次建立最大堆是建立,剩下的每次都是修补,将交换的元素找到一个合适的位置,这样每次Array[0]又成了最大元素

//伪代码片段

Heap_Sort(A)
  Build_Max_Heap(A)
  for i=A.length downto 2
     exchange A[1] with A[i]
     A.heap-size=A.heap-size - 1
     Max_Heapify(A,1)

  这是基于最大堆排序,结果是从小到大,因为最大的元素放在数组末尾,最小堆排序相反,但原理一样

public class 堆排序 {
    // 先建堆

    public static void main(String[] args) {
        int Array[] = { 16, 14, 10, 8, 7, 9, 3, 2, 4, 1 };
        System.out.print("构建最大堆之前: ");
        for (int m : Array) {
            System.out.print(" " + m);
        }
        System.out.println("");
        Heap_Sort(Array);
        System.out.print("堆排序完成之后: ");
        for (int m : Array) {
            System.out.print(" " + m);
        }

    }

    public static void Heap_Sort(int Array[]) {
        int m_size = Array.length - 1;
        // Build_Max_Heapify(),将使A[0]达到最大值。这样一直循环交换存放在数组A[i]中,递归调用。
        Build_Max_Heapify(Array);// 堆排序算法利用Build_Max_Heapify(Array)将数组Array建成最大堆
        System.out.print("构建最大堆之后: ");
        for (int m : Array) {
            System.out.print(" " + m);
        }
        System.out.println("");
        for (int i = m_size; i >= 1; i--) {
            Array[i] += Array[0]; // 因为数组中的最大元素总在根结点Array[0],与Array[m_size}交换,相当于将该节点已经确定出位置,接下来的排序可以不用再考虑该元素(它已经有了最后的位置)
            Array[0] = Array[i] - Array[0];
            Array[i] -= Array[0];
            // swap(A[0], A[i]);
            --m_size;// 剔除刚刚交换的Array[m_size]
            Max_Heapify(Array, 0,m_size);// 再构建最大堆,在原有的最大堆基础之上乱了一个Array[0],找到Array[0]的位置,又是一个新的最大堆(少了刚刚那个确立的最大元素)
        }
    }

    public static void Build_Max_Heapify(int A[]) { // 建堆:子数组A[n/2+1...n]中的元素都是叶子节点,因此每个都可以看作只含一个元素的堆.
        int m_size = A.length - 1;                  // m_size/2与m_size一样都正确,也就是上面句子的解释。
        for (int i = m_size / 2; i >= 0; i--)
            Max_Heapify(A, i,m_size);
    }

    public static void Max_Heapify(int Array[], int i,int needSize) {
        int m_size = needSize;
        int largest;
        int left = Left(i);
        int right = Right(i);

        if ((left <= m_size) && (Array[left] > Array[i]))
            largest = left;
        else
            largest = i;
        if ((right <= m_size) && (Array[right] > Array[largest]))
            largest = right;
        if (largest != i) {
            Array[i] += Array[largest]; // 第一次交换确立最大元素Array[largest]
            Array[largest] = Array[i] - Array[largest];
            Array[i] -= Array[largest];
            Max_Heapify(Array, largest,m_size); // 将刚刚与最大元素交换的元素Array[i]在最大堆中找到一个合适的位置
        }

    }

    int Parent(int i) { // Parent node
        return i / 2;
    }

    static int Right(int i) { // right node
        return 2 * i + 2;
    }

    static int Left(int i) { // left node
        return 2 * i + 1;
    }

}

  

 

算法排序之堆排序

标签:else   ati   .net   [1]   []   接下来   递归   上进   lock   

原文地址:http://www.cnblogs.com/kevinchan/p/7655494.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!