堆 + 堆排序 + 优先队列

堆、堆排序、优先队列

1. 堆

  堆又分为大顶堆和小顶堆。所有节点的值都大于等于（或小于等于）其子树中所有节点的值；且为完全二叉树。堆顶总存放最大或者最小值，此即为优先队列的数据结构。我们可据此实现快速访问一组数据中的最大或最小值。但需要注意的是，堆顶存放的是最大或最小元素，但其他节点的大小顺序是未知的。如下图：

  如图，我们将节点按照层进行编号，得到的数组为 （按下标从0开始）：

0	1	2	3	4	5	6	7	8	9
90	36	17	25	26	7	1	2	3	19

  该数组即是堆的物理存储结构，而其逻辑结构为一个二叉堆，我们用公式定义该结构为：
大顶堆：heap[i] > max(heap[2*i+1] , heap[2*i+2])
小顶堆：heap[i] < min(heap[2*i+1] , heap[2*i+2])

2. 堆排序

• 建堆

  // 从最后一个非叶节点开始，向下调整
  public static  void createHeap(ArrayList<Integer> arr){
      for (int i = arr.size()/2; i >= 0 ; i--) {
          fixDown(arr,i,arr.size());
      }
  }
  

• 向上调整

  // 插入元素，将数据放在数组的最后位置，然后将其向上调整
  public static void fixUp(ArrayList<Integer> arr,int k){
      while(k >= 0){
          int i = (k - 1)/2;
          if(arr.get(k) > arr.get(i)) {
              swap(arr, i, k);
              k = i;
          }else{
              break;
          }
      }
  }
  

• 向下调整

  // 在第k个位置向下调整，将以k为根节点的子树调节为大顶堆
  public static void fixDown(ArrayList<Integer> arr,int k,int length){
      while (2 * k + 1 < length){
          int i = 2 * k + 1;
          if ( i + 1 < length && arr.get(i) < arr.get(i+1)) // 此处有坑，先判断i+1是否小于length
          	i++;
          if ( arr.get(k) < arr.get(i) ){
              swap(arr, i, k);
              k = i;
          } else {
              break;
          }
      }
  }
  

• 排序

  // 将第一个元素与最后一个元素进行交换，然后从第一个元素开始，将不包含最后一个元素的数组，重新调整为堆
  public static void heapSort(ArrayList<Integer> arr){
      for (int i = arr.size()-1;i > 0;i--){
          swap(arr,0,i);
          fixDown(arr,0,i);
      }
  }
  

优先队列：
建好的大顶堆即为优先队列，使用向上调整和向下调整即可实现向队列中添加和删除元素！

3. 完整代码

package test;

import java.util.ArrayList;

/**
 * 创建堆使用 使用向上调整的方法
 * 插入元素   使用向下调整的方法
 */
public class HeapSort {

    // 1. 建堆
    public static  void createHeap(ArrayList<Integer> arr){
        for (int i = arr.size()/2; i >= 0 ; i--) {
            fixDown(arr,i,arr.size());
        }
    }

    // 2. 向上调整
    public static void fixUp(ArrayList<Integer> arr,int k){
        while(k >= 0){
            int i = (k-1)/2;
            if(arr.get(k) > arr.get(i)) {
                swap(arr,i,k);
                k = i;
            }else{
                break;
            }
        }
    }

    // 3. 向下调整 构建大顶堆
    public static void fixDown(ArrayList<Integer> arr,int k,int length){
        while (2 * k + 1 < length){
            int i = 2*k+1;
            if ( i+1<length && arr.get(i) < arr.get(i+1)) i++;
            if (arr.get(k) < arr.get(i)){
                swap(arr,i,k);
                k = i;
            } else {
                break;
            }
        }
    }

    // 4. 插入
    public static void insertElem(ArrayList<Integer> arr,int data){
        int k = arr.size();
        arr.add(data);
        fixUp(arr,k);
    }

    // 5. 删除
    public static Integer deleteElem(ArrayList<Integer> arr) {
        swap(arr,0,arr.size()-1);
        Integer res = arr.get(arr.size()-1);
        arr.remove(arr.size()-1);
        fixDown(arr,0,arr.size());
        return res;
    }

    // 6. 堆排序
    public static void heapSort(ArrayList<Integer> arr){
        for (int i = arr.size()-1;i > 0;i--){
            swap(arr,0,i);
            fixDown(arr,0,i);
        }
    }

    public static void swap(ArrayList<Integer> arr,int i,int k){
        int tmp = arr.get(i);
        arr.set(i,arr.get(k));
        arr.set(k,tmp);
    }

    public static void print(ArrayList<Integer> arr){
        for (int i = 0; i < arr.size(); i++) {
            System.out.print(arr.get(i) + "  ");
        }
        System.out.println();
    }