堆（Java）-CFANZ编程社区

本专栏目录

蓝桥杯算法竞赛大纲数论相关（Java）

枚举相关（Java）

对象排序（Java）

字符串相关（Java）

排序相关算法（Java）

记忆化搜索（Java）

树论相关（Java）

图论相关（Java）堆（Java）
贪心（Java）

文章目录

关于堆的判断
数组建堆
依次插入建堆
优先队列

关于堆的判断

package 堆;

import java.util.Scanner;

// https://pintia.cn/problem-sets/994805046380707840/problems/994805064676261888
public class _关于堆的判断 {

    static int n,m;
    static int[] arr;

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        m = scan.nextInt();

        arr = new int[n+1];

        for (int i = 1; i <= n; i++) {
            arr[i] = scan.nextInt();
            updateSmallHeap(i);
        }

        scan.nextLine();

        for (int i = 0; i < m; i++) {
            String line = scan.nextLine();
            String[] strArr = line.split(" ");

            if (line.contains("root")){
                int x = Integer.parseInt(strArr[0]);

                if (arr[1]==x){
                    System.out.println("T");
                } else {
                    System.out.println("F");
                }

            }else if (line.contains("and")){
                int a = Integer.parseInt(strArr[0]);
                int b = Integer.parseInt(strArr[2]);

                a = find(a);
                b = find(b);

                if (arr[a/2]==arr[b/2]){
                    System.out.println("T");
                }else {
                    System.out.println("F");
                }
            }else if (line.contains("parent")){
                int a = Integer.parseInt(strArr[0]);
                int b = Integer.parseInt(strArr[5]);

                b = find(b);

                if (arr[b/2]==a){
                    System.out.println("T");
                }else {
                    System.out.println("F");
                }

            }else {
                int a = Integer.parseInt(strArr[0]);
                int b = Integer.parseInt(strArr[5]);

                a = find(a);
                if (arr[a/2]==b){
                    System.out.println("T");
                }else {
                    System.out.println("F");
                }
            }
        }
    }

    public static int find(int x){

        for (int i = 1; i <= n; i++) {
            if (arr[i]==x){
                return i;
            }
        }
        return 0;
    }

    private static void updateSmallHeap(int i) {

        if (i==1) return;
        // 上浮操作
        while (i!=1){
            if (arr[i]<arr[i/2]){
                int t = arr[i];
                arr[i] = arr[i/2];
                arr[i/2] = t;
            }
            i /= 2;
        }
    }
}

数组建堆

package 堆;

import java.util.Arrays;

public class _数组建堆 {

    public static void main(String[] args) {

        int[] arr = {1,3,3,4,4,5,1,23,3,321,2,31,23,5,54};

        int n = arr.length-1;

        // 将数组调整为大顶堆
        for (int i = ((n-1)/2); i >= 0; i--) {
            adjustBigHeap(arr, i, n);
        }

        System.out.println(Arrays.toString(arr));

        // 将数组调整为小顶堆
        for (int i = ((n-1)/2); i >= 0; i--) {
            adjustSmallHeap(arr, i, n);
        }

        System.out.println(Arrays.toString(arr));

    }

    public static void adjustBigHeap(int[] arr, int index, int last){

        // 向下更新
        for (int left = index * 2 + 1; left <= last; left = left * 2 + 1) {

            int right = left + 1;
            if (right <= last && arr[left] < arr[right]){
                left = right;
            }

            if (arr[left] > arr[(left-1)/2]){

                int t = arr[left];
                arr[left] = arr[(left-1)/2];
                arr[(left-1)/2] = t;

            }else {
                break;
            }
        }
    }

    public static void adjustSmallHeap(int[] arr, int index, int last){

        for (int left = index * 2 + 1; left <= last; left = left * 2 + 1) {

            int right = left + 1;
            if (right <= last && arr[left] > arr[right]){
                left = right;
            }

            if (arr[left] < arr[(left-1)/2]){

                int t = arr[left];
                arr[left] = arr[(left-1)/2];
                arr[(left-1)/2] = t;

            }else {
                break;
            }
        }
    }
}

依次插入建堆

package 堆;

import java.util.Arrays;
import java.util.Scanner;

public class _依次插入建堆 {

    static int n;
    static int[] arr;

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        n = scan.nextInt();
        arr = new int[n];

        for (int i = 0; i < n; i++) {
            arr[i] = scan.nextInt();
//            updateBigHeap(i);
            updateSmallHeap(i);
        }

        System.out.println(Arrays.toString(arr));
    }

    // 依次插入构建大顶堆
    public static void updateBigHeap(int ind){

        // 往上更新
        while (ind>0){

            if (arr[ind]<=arr[(ind-1)/2]){
                return;
            }

            int t = arr[ind];
            arr[ind] = arr[(ind-1)/2];
            arr[(ind-1)/2] = t;

            ind = (ind-1) / 2;
        }
    }

    // 依次插入构建小顶堆
    public static void updateSmallHeap(int ind){
        while (ind>0){

            if (arr[ind]>=arr[(ind-1)/2]){
                return;
            }

            int t = arr[ind];
            arr[ind] = arr[(ind-1)/2];
            arr[(ind-1)/2] = t;

            ind = (ind-1) / 2;
        }
    }
}

优先队列

package 堆;

public class _优先队列 {

    public static void main(String[] args) {

        PriorityQueue queue = new PriorityQueue(20);

        queue.push(new Node(10, "xiaowang"));
        queue.push(new Node(13, "xiaoli"));
        queue.push(new Node(11, "xiaomei"));
        queue.push(new Node(3, "xiaozhao"));
        queue.push(new Node(9, "xiaoba"));

        while (!queue.isEmpty()){

            System.out.println(queue.poll().id);
        }

    }

    static class PriorityQueue{

        int maxsize;
        int last = -1;  // 最后一个元素下标
        Node[] BigHeap;

        public PriorityQueue(int maxsize) {
            this.maxsize = maxsize;
            BigHeap = new Node[maxsize];
        }

        public boolean isEmpty(){

            if (last==-1){
                return true;
            }
            return false;
        }

        public void push(Node node){

            if (last == maxsize-1){
                System.out.println("队列满了");
                return;
            }

            BigHeap[++last] = node;
            updateBigHeap(last);
        }

        public Node poll(){

            if (last<0){
                System.out.println("队列为空");
                return null;
            }

            Node curr = BigHeap[0];

            BigHeap[0] = BigHeap[last];
            last--;

            adjustBigHeap(0,last);

            return curr;
        }


        // 将ind为根的子树调整为大顶堆
        private void adjustBigHeap(int ind, int last) {


            for (int left = ind * 2 + 1; left <= last; left = left * 2 + 1) {

                int right = left + 1;

                if (right <= last && BigHeap[right].prioriy > BigHeap[left].prioriy){
                    left = right;
                }

                if (BigHeap[left].prioriy > BigHeap[(left-1)/2].prioriy){

                    Node node = BigHeap[left];
                    BigHeap[left] = BigHeap[(left-1)/2];

                    BigHeap[(left-1)/2] = node;

                }else {
                    return;
                }
            }
        }

        public Node peek(){
            return BigHeap[0];
        }

        // 依次插入建堆
        public void updateBigHeap(int ind){

            // 更新插入元素的位置
            while (ind>0){

                if (BigHeap[ind].prioriy <= BigHeap[(ind-1)/2].prioriy){
                    return;
                }

                Node node = BigHeap[ind];
                BigHeap[ind] = BigHeap[(ind-1)/2];
                BigHeap[(ind-1)/2] = node;

                ind = (ind-1) / 2;
            }
        }
    }

    static class Node{
        int prioriy;
        String id;

        public Node(int prioriy, String id) {
            this.prioriy = prioriy;
            this.id = id;
        }
    }
}