第6章 堆排序 java实现 简单版 泛型版 最大优先级队列

方案一、只考虑int类型的排序，最简单的实现如下。

public class Heap {
    
    public int heap_size;//在build_max_heap中初始化，由heap_sort自动调用
    
    public int parent(int i){
        return (i - 1) / 2;
    }
    public int left(int i){
        return 2 * i + 1;
    }
    public int right(int i){
        return 2 * i + 2;
    }
    
    /** 保持堆的性质,
     * 假定left(i), right(i)为根的两根二叉树都是最大堆，
     * A[i]可能小于其子女，这样就违背了最大堆性质
     * 该函数让A[i]在最大堆中“下降”，使以i为根的子树成为最大堆
     * */
    public void max_heapify(int[] A, int i){
        int l = left(i);
        int r = right(i);
        int largest;
        // 从A[i] A[left(i)] A[right(i)] 中找出最大，下标存在largest中
        // 若A[i]为最大，则根据假设，i为根的子树已是最大堆，函数结束
        // 否则交换A[i]和A[largest],交换后下标为largest的节点值为A[i]
        // 该节点的子树可能违反最大堆,因此对largest下标递归调用
        if(l < heap_size && A[l] > A[i]){
            largest = l;
        } 
        else{
            largest = i;
        }    
        if(r < heap_size && A[r] > A[largest]){
            largest = r;
        }
        if(largest != i){
            int tmp = A[i];
            A[i] = A[largest];
            A[largest] = tmp;
            
            max_heapify(A, largest);
        }
    }
    
    /**
     * 建堆
     * 自底向上将数组A[1..n]（此处n=length[A]）变成最大堆
     * 子数组A[(floor(n / 2) + 1) .. n]中的元素都是树中的叶子
     * 所以对每一个非叶子节点都调用一次该过程
     * */
    public void build_max_heap(int[] A){
        heap_size = A.length; // 初始化heap_size
        for(int i = (heap_size/2 - 1); i > -1; --i){
            max_heapify(A, i);
        }
    }
    
    /**
     * 堆排序算法
     * 先建造最大堆，根A[1]即为最大，则置换到数组的正确位置A[n]
     * 从堆中去掉节点n，A[1..n-1]建成最大堆，但新根可能违背了最大堆性质，
     * 此时调用max_heapify(A,1)可以保持该性质，在A[1..n-1]构造出最大堆。
     * 不断重复，堆大小从n-1降到2
     * */
    public void heapsort(int[] A){
        build_max_heap(A);
        for(int i = A.length-1; i > 0; --i){
            int tmp = A[0];
            A[0] = A[i];
            A[i] = tmp;
            --heap_size;
            max_heapify(A, 0);
        }
    }
    
    public static void show_array(int[] A){
        for(int i = 0; i < A.length; ++i){
            System.out.print(A[i] + ". ");
        }
        System.out.println();
    }
    
    public static void main(String[] args){
        int[] A = {4, 1, 3, 2, 16, 9, 10, 14, 8, 7};
        
        
        System.out.println("before heapsort：");
        show_array(A);
        
        Heap h = new Heap();
        h.heapsort(A);
        
        System.out.println("after heapsort：");
        show_array(A);
        
    }
    
}

 运行结果：

方案二、考虑泛型，使用泛型数组的实现如下：

public class HeapTwo<T extends Comparable<T>> {
    
    T[] A;
    int heap_size;//在build_max_heap中初始化，由heap_sort自动调用，或在类实例化时构造
    
    public HeapTwo(T[] A){
        this.A = A;
        this.heap_size = A.length;
    }
    
    public int parent(int i){
        return (i - 1) / 2;
    }
    public int left(int i){
        return 2 * i + 1;
    }
    public int right(int i){
        return 2 * i + 2;
    }
    
    /** 保持堆的性质,
     * 假定left(i), right(i)为根的两根二叉树都是最大堆，
     * A[i]可能小于其子女，这样就违背了最大堆性质
     * 该函数让A[i]在最大堆中“下降”，使以i为根的子树成为最大堆
     * */
    public void max_heapify(int i){
        int l = left(i);
        int r = right(i);
        int largest;
        // 从A[i] A[left(i)] A[right(i)] 中找出最大，下标存在largest中
        // 若A[i]为最大，则根据假设，i为根的子树已是最大堆，函数结束
        // 否则交换A[i]和A[largest],交换后下标为largest的节点值为A[i]
        // 该节点的子树可能违反最大堆,因此对largest下标递归调用
        if(l < heap_size && A[l].compareTo(A[i]) > 0 ){
            largest = l;
        } 
        else{
            largest = i;
        }    
        if(r < heap_size && A[r].compareTo(A[largest]) > 0){
            largest = r;
        }
        if(largest != i){
            T tmp = A[i];
            A[i] = A[largest];
            A[largest] = tmp;
            
            max_heapify(largest);
        }
    }
    
    /**
     * 建堆
     * 自底向上将数组A[1..n]（此处n=length[A]）变成最大堆
     * 子数组A[(floor(n / 2) + 1) .. n]中的元素都是树中的叶子
     * 所以对每一个非叶子节点都调用一次该过程
     * */
    public void build_max_heap(){
        heap_size = A.length; // 初始化heap_size
        for(int i = (heap_size/2 - 1); i > -1; --i){
            max_heapify(i);
        }
    }
    
    /**
     * 堆排序算法
     * 先建造最大堆，根A[1]即为最大，则置换到数组的正确位置A[n]
     * 从堆中去掉节点n，A[1..n-1]建成最大堆，但新根可能违背了最大堆性质，
     * 此时调用max_heapify(A,1)可以保持该性质，在A[1..n-1]构造出最大堆。
     * 不断重复，堆大小从n-1降到2
     * */
    public void heapsort(){
        build_max_heap();
        for(int i = A.length-1; i > 0; --i){
            T tmp = A[0];
            A[0] = A[i];
            A[i] = tmp;
            --heap_size;
            max_heapify(0);
        }
    }
    
    public void show_array(){
        for(int i = 0; i < A.length; ++i){
            System.out.print(A[i] + ". ");
        }
        System.out.println();
    }
    
    public static void main(String[] args){
        Double[] A = {4.3, 1.2, 3.2, 2.8, 16.5, 9.3, 10.6, 14.6, 8.4, 7.0};
        
        System.out.println("before heapsort：");
        
        
        HeapTwo h = new HeapTwo(A);
        h.show_array();
        h.heapsort();
        
        System.out.println("after heapsort：");
        h.show_array();
        
    }
}

 最大优先级队列：

package org.hhj;

public class Heap {
    
    int[] A;
    int heap_size;//在build_max_heap中初始化，由heap_sort自动调用，或在类实例化时构造
    
    public Heap(int[] A){
        this.A = A;
        this.heap_size = A.length;
    }
    
    public int parent(int i){
        return (i - 1) / 2;
    }
    public int left(int i){
        return 2 * i + 1;
    }
    public int right(int i){
        return 2 * i + 2;
    }
    
    /** 保持堆的性质,
     * 假定left(i), right(i)为根的两根二叉树都是最大堆，
     * A[i]可能小于其子女，这样就违背了最大堆性质
     * 该函数让A[i]在最大堆中“下降”，使以i为根的子树成为最大堆
     * */
    public void max_heapify(int[] A, int i){
        int l = left(i);
        int r = right(i);
        int largest;
        // 从A[i] A[left(i)] A[right(i)] 中找出最大，下标存在largest中
        // 若A[i]为最大，则根据假设，i为根的子树已是最大堆，函数结束
        // 否则交换A[i]和A[largest],交换后下标为largest的节点值为A[i]
        // 该节点的子树可能违反最大堆,因此对largest下标递归调用
        if(l < heap_size && A[l] > A[i]){
            largest = l;
        } 
        else{
            largest = i;
        }    
        if(r < heap_size && A[r] > A[largest]){
            largest = r;
        }
        if(largest != i){
            int tmp = A[i];
            A[i] = A[largest];
            A[largest] = tmp;
            
            max_heapify(A, largest);
        }
    }
    
    /**
     * 建堆
     * 自底向上将数组A[1..n]（此处n=length[A]）变成最大堆
     * 子数组A[(floor(n / 2) + 1) .. n]中的元素都是树中的叶子
     * 所以对每一个非叶子节点都调用一次该过程
     * */
    public void build_max_heap(int[] A){
        heap_size = A.length; // 初始化heap_size
        for(int i = (heap_size/2 - 1); i > -1; --i){
            max_heapify(A, i);
        }
    }
    
    /**
     * 堆排序算法
     * 先建造最大堆，根A[1]即为最大，则置换到数组的正确位置A[n]
     * 从堆中去掉节点n，A[1..n-1]建成最大堆，但新根可能违背了最大堆性质，
     * 此时调用max_heapify(A,1)可以保持该性质，在A[1..n-1]构造出最大堆。
     * 不断重复，堆大小从n-1降到2
     * */
    public void heapsort(int[] A){
        build_max_heap(A);
        for(int i = A.length-1; i > 0; --i){
            int tmp = A[0];
            A[0] = A[i];
            A[i] = tmp;
            --heap_size;
            max_heapify(A, 0);
        }
    }
    
    public static void show_array(int[] A){
        for(int i = 0; i < A.length; ++i){
            System.out.print(A[i] + ". ");
        }
        System.out.println();
    }
    
    /**
     * 返回A[]中具有最大关键字的元素
     * @param A
     * @return
     */
    public int heap_maximum(int[] A){
        return A[0];
    }
    
    /**
     * 去掉并返回A中的具有最大关键字的元素
     * @param A
     * @return
     */
    public int heap_extract_max(int[] A){
        if(heap_size < 1){
            System.out.println("heap underflow");
            return -1;
        }
        int max = A[0];
        A[0] = A[heap_size - 1];
        --heap_size;
        max_heapify(A, 0);
        return max;
    }
    
    /**
     * 将元素i的关键字的值增加到key，这里key值不可小于i的原关键字的值
     * @param A
     * @param i
     * @param key
     */
    public void heap_increase_key(int[] A, int i, int key){
        if(key < A[i]){
            System.out.println("new key is smaller than current key");
        }
        A[i] = key;
        while(i > 1 && A[parent(i)] < A[i]){
            int tmp = A[i];
            A[i] = A[parent(i)];
            A[parent(i)] = tmp;
            i = parent(i);
        }
    }
    
    /**
     * 将key插入到最大堆A中，先用一个关键字值为负无穷的叶节点扩展对大队，
     * 然后调用heap_increase_key来设置新节点的关键字的正确值，并保持最大堆性质。
     * @param A
     * @param key
     */
    public void max_heap_insert(int[] A, int key){
        ++heap_size;
        A[heap_size] = Integer.MIN_VALUE;
        heap_increase_key(A, heap_size, key);
        
    }
    public static void main(String[] args){
        
        
    }
    
}