堆和堆排序

最小K个数

class Solution {
    int[] heap;
    public int[] getLeastNumbers(int[] arr, int k) {
        if(k==0) return new int[0];
        heap = new int[k];
        for(int i = 0;i<k;i++)
            heap[i] = arr[i];
        //先进行堆有序。
        for(int i = (k-1)/2;i>=0;i--)
            sink(i,k);
        for(int i=k;i<arr.length;i++){
            if(arr[i]<heap[0]){
                heap[0] = arr[i];
                sink(0,k);
            }
        }
        return heap;
    }

    private void swim(int i){
        while(i>0 && heap[i]>heap[(i-1)/2])
            exch(i,(i-1)/2);
    }
    private void sink(int i, int N){
        while((2*i+1)<= N-1){
            int j = 2*i+1;
            if(j<N-1 && heap[j]<heap[j+1]) j++;
            if(heap[i]>heap[j]) break;
            exch(i,j);
            i=j;
        }
    }

    private void exch(int i,int j){
        int temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}

堆排序

堆排序

// Java program for implementation of Heap Sort 
public class HeapSort 
{ 
    public void sort(int arr[]) 
    { 
        int n = arr.length; 
  
        // Build heap (rearrange array) 
        for (int i = n / 2 - 1; i >= 0; i--) 
            heapify(arr, n, i); 
  
        // One by one extract an element from heap 
        for (int i=n-1; i>0; i--) 
        { 
            // Move current root to end 
            int temp = arr[0]; 
            arr[0] = arr[i]; 
            arr[i] = temp; 
  
            // call max heapify on the reduced heap 
            heapify(arr, i, 0); 
        } 
    } 
  
    // To heapify a subtree rooted with node i which is 
    // an index in arr[]. n is size of heap 
    void heapify(int arr[], int n, int i) 
    { 
        int largest = i; // Initialize largest as root 
        int l = 2*i + 1; // left = 2*i + 1 
        int r = 2*i + 2; // right = 2*i + 2 
  
        // If left child is larger than root 
        if (l < n && arr[l] > arr[largest]) 
            largest = l; 
  
        // If right child is larger than largest so far 
        if (r < n && arr[r] > arr[largest]) 
            largest = r; 
  
        // If largest is not root 
        if (largest != i) 
        { 
            int swap = arr[i]; 
            arr[i] = arr[largest]; 
            arr[largest] = swap; 
  
            // Recursively heapify the affected sub-tree 
            heapify(arr, n, largest); 
        } 
    } 
  
    /* A utility function to print array of size n */
    static void printArray(int arr[]) 
    { 
        int n = arr.length; 
        for (int i=0; i<n; ++i) 
            System.out.print(arr[i]+" "); 
        System.out.println(); 
    } 
  
    // Driver program 
    public static void main(String args[]) 
    { 
        int arr[] = {12, 11, 13, 5, 6, 7}; 
        int n = arr.length; 
  
        HeapSort ob = new HeapSort(); 
        ob.sort(arr); 
  
        System.out.println("Sorted array is"); 
        printArray(arr); 
    } 
}