Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Priority Queue

A priority queue is a data structure which maintains a set $S$ of elements, each of with an associated value (key), and supports the following operations:

$insert(S, k)$: insert an element $k$ into the set $S$

$extractMax(S)$: remove and return the element of $S$ with the largest key

Write a program which performs the $insert(S, k)$ and $extractMax(S)$ operations to a priority queue $S$.
The priority queue manages a set of integers, which are also keys for the priority.

Input

Multiple operations to the priority queue $S$ are given. Each operation is given by "insert $k$", "extract" or "end" in a line. Here, $k$ represents an integer element to be inserted to the priority queue.

The input ends with "end" operation.

Output

For each "extract" operation, print the element extracted from the priority queue $S$ in a line.

Constraints

The number of operations $\leq 2,000,000$

$0 \leq k \leq 2,000,000,000$

Sample Input 1

insert 8
insert 2
extract
insert 10
extract
insert 11
extract
extract
end

Sample Output 1

8
10
11
2

Solution in JAVA (judge verdict: Wrong Answer)

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        array1 arr = new array1();
        do {
            String[] frase = in.nextLine().split(" ");
            if (frase[0].equals("insert")) {
                arr.insert(Integer.parseInt(frase[1]));
            } else if (frase[0].equals("extract")) {
                arr.extract();
            } else {
                break;
            }
        } while (true);
    }
}

class array1 {
    ArrayList<Integer> heapArray;
    protected int curr = 0;

    public array1() {
        heapArray = new ArrayList<Integer>();
    }

    public void insert(int key) {
        curr = heapArray.size() - 1;
        if (heapArray.size() == 0) {
            heapArray.add(key);
        } else {
            heapArray.add(key);
            heapify(heapArray.size() - 1);
        }
    }

    public void extract(){
        int aux = heapArray.get(0);
        heapArray.set(0, heapArray.get(heapArray.size()-1));
        heapArray.remove(heapArray.size() - 1);
        if(heapArray.size() != 0) {
            heapifyCorrectAll(heapArray.size() - 1);
        }
        System.out.println(aux);
    }

    public void swap(int curr, int changeTo){
        int aux = heapArray.get(curr);
        heapArray.set(curr, heapArray.get(changeTo));
        heapArray.set(changeTo, aux);
    }

    public void heapify(int curr) {
        int father;
        if (curr != 0 && curr % 2 == 0) {
            father = (curr - 2) / 2;
        } else if(curr % 2 == 1) {
            father = (curr - 1) / 2;
        } else{
            return;
        }

        if (heapArray.get(father) < heapArray.get(curr)) {
            swap(curr, father);
            curr = father;
            heapify(curr);
        }else{
            return;
        }
    }

    void heapifyCorrectAll(int curr) {
        int largest = curr;
        int l = 2 * curr + 1;
        int r = 2 * curr + 2;

        if (l < heapArray.size() && heapArray.get(l) > heapArray.get(largest)) {
            largest = l;
        }
        if (r < heapArray.size() && heapArray.get(r) > heapArray.get(largest)) {
            largest = r;
        }

        if (largest != curr) {
            swap(curr, largest);
            heapifyCorrectAll(largest);
        }
    }
}