堆结构、堆排序

asdsa
121 阅读3分钟

什么是堆结构

  1. 堆结构就是用数组实现的完全二叉树结构
  2. 完全二叉树中如果每棵子树的最大值都在顶部就是大根堆
  3. 完全二叉树中如果每棵子树的最小值都在顶部就是小根堆
  4. 优先级队列结构，就是堆结构

大根堆实现

public static class MyMaxHeap {
    private int[] heap;
    private final int limit;
    private int heapSize;

    public MyMaxHeap(int limit) {
        heap = new int[limit];
        this.limit = limit;
        heapSize = 0;
    }

    public boolean isEmpty() {
        return heapSize == 0;
    }

    public boolean isFull() {
        return heapSize == limit;
    }

    public void push(int value) {
        if (heapSize == limit) {
            throw new RuntimeException("heap is full");
        }
        heap[heapSize] = value;
        // value heapSize
        heapInsert(heap, heapSize++);
    }

    // 用户此时，让你返回最大值，并且在大根堆中，把最大值删掉
    // 剩下的数，依然保持大根堆组织
    public int pop() {
        int ans = heap[0];
        swap(heap, 0, --heapSize);
        heapify(heap, 0, heapSize);
        return ans;
    }

    // 新加进来的数，现在停在了index位置，请依次往上移动，
    // 移动到0位置，或者干不掉自己的父亲了，停！
    private void heapInsert(int[] arr, int index) {
        // 考虑到了index为0的情况
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    // 从index位置，往下看，不断的下沉
    // 停：较大的孩子都不再比index位置的数大；已经没孩子了
    private void heapify(int[] arr, int index, int heapSize) {
        int left = index * 2 + 1;
        while (left < heapSize) { // 如果有左孩子，有没有右孩子，可能有可能没有！
            // 把较大孩子的下标，给largest
            int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if (largest == index) {
                break;
            }
            // index和较大孩子，要互换
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

}

堆排序

    // 堆排序额外空间复杂度O(1)
   public static void heapSort(int[] arr) {
      if (arr == null || arr.length < 2) {
         return;
      }
      // O(N*logN)
//    for (int i = 0; i < arr.length; i++) { // O(N)
//       heapInsert(arr, i); // O(logN)
//    }
      // O(N) 因为heapify的次数,下层节点比上层节点小
      for (int i = arr.length - 1; i >= 0; i--) {
         heapify(arr, i, arr.length);
      }
      int heapSize = arr.length;

      // 每次来到堆最右边的数都是当前堆里最大的
      // O(N*logN)
      while (heapSize > 1) {
         swap(arr, 0, --heapSize);
         heapify(arr, 0, heapSize);
      }
   }

   // arr[index]刚来的数，往上
   public static void heapInsert(int[] arr, int index) {
      while (arr[index] > arr[(index - 1) / 2]) {
         swap(arr, index, (index - 1) / 2);
         index = (index - 1) / 2;
      }
   }

   // arr[index]位置的数，能否往下移动
   public static void heapify(int[] arr, int index, int heapSize) {
      int left = index * 2 + 1; // 左孩子的下标
      while (left < heapSize) { // 下方还有孩子的时候
         // 两个孩子中，谁的值大，把下标给largest
         // 1）只有左孩子，left -> largest
         // 2) 同时有左孩子和右孩子，右孩子的值<= 左孩子的值，left -> largest
         // 3) 同时有左孩子和右孩子并且右孩子的值> 左孩子的值， right -> largest
         int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
         // 父和较大的孩子之间，谁的值大，把下标给largest
         largest = arr[largest] > arr[index] ? largest : index;
         if (largest == index) {
            break;
         }
         swap(arr, largest, index);
         index = largest;
         left = index * 2 + 1;
      }
   }

   public static void swap(int[] arr, int i, int j) {
      int tmp = arr[i];
      arr[i] = arr[j];
      arr[j] = tmp;
   }

与堆有关的题目

  1. 已知一个几乎有序的数组。几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离一定不超过k，并且k相对于数组长度来说是比较小的。请选择一个合适的排序策略，对这个数组进行排序。 
    public static void sortedArrDistanceLessK(int[] arr, int k) {
   if (k == 0) {
      return;
   }
   // 默认小根堆
   PriorityQueue<Integer> heap = new PriorityQueue<>();
   int index = 0;
   // 0...K-1 之间的数放到堆中
   for (; index <= Math.min(arr.length - 1, k - 1); index++) {
      heap.add(arr[index]);
   }
   int i = 0; // i从头开始
   // 如果数组长度小于k,这个循环显然跳过
   // 一个长度为k的窗口,每次把这个窗口内最小的数放到窗口最左侧
   for (; index < arr.length; i++, index++) {
      heap.add(arr[index]);
      arr[i] = heap.poll();
   }
   // 边界,窗口剩下的数,按照从小到大弹出
   while (!heap.isEmpty()) {
      arr[i++] = heap.poll();
   }
}
  2. 给定很多线段，每个线段都有两个数[start, end]，表示线段开始位置和结束位置，左右都是闭区间 规定：1）线段的开始和结束位置一定都是整数值。2）线段重合区域的长度必须>=1。 返回线段最多重合区域中，包含了几条线段。
public static int maxCover2(int[][] m) {
   Line[] lines = new Line[m.length];
   for (int i = 0; i < m.length; i++) {
      lines[i] = new Line(m[i][0], m[i][1]);
   }
   // 把所有线段,按照起点由小到大排序
   Arrays.sort(lines, new StartComparator());
   // 小根堆，每一条线段的结尾数值，使用默认的
   PriorityQueue<Integer> heap = new PriorityQueue<>();
   int max = 0;
   for (int i = 0; i < lines.length; i++) {
      // 为什么要先弹出?如果之某个前线段的终点,小于等于当前线段的起点
      // 那么之前的这个线段,显然不能穿过当前线段的起点
      while (!heap.isEmpty() && heap.peek() <= lines[i].start) {
         heap.poll();
      }
      heap.add(lines[i].end);
      //heap.size() 是指,穿过当前线段起始点的线段有几条
      //所有线端重合的区域,一定是某条线段的起始点
      //所以求所有起始点哪个重合最多线段,就是问题答案
      max = Math.max(max, heap.size());
   }
   return max;
}

public static class Line {
   public int start;
   public int end;

   public Line(int s, int e) {
      start = s;
      end = e;
   }
}

public static int maxCover3(int[][] m) {
    // m是二维数组，可以认为m内部是一个一个的一维数组
    // 每一个一维数组就是一个对象，也就是线段
    // 如下的code，就是根据每一个线段的开始位置排序
    // 比如, m = { {5,7}, {1,4}, {2,6} } 跑完如下的code之后变成：{ {1,4}, {2,6}, {5,7} }
    Arrays.sort(m, (a, b) -> (a[0] - b[0]));
    // 准备好小根堆，和课堂的说法一样
    PriorityQueue<Integer> heap = new PriorityQueue<>();
    int max = 0;
    for (int[] line : m) {
        while (!heap.isEmpty() && heap.peek() <= line[0]) {
            heap.poll();
        }
        heap.add(line[1]);
        max = Math.max(max, heap.size());
    }
    return max;
}
avatar
文章
阅读
粉丝