hihocoder：堆

时间限制:10000ms
单点时限:1000ms
内存限制:256MB
描述

小Ho有一个糖果盒子，每过一段时间小Ho都会将新买来的糖果放进去，同时他也会不断的从其中挑选出最大的糖果出来吃掉，但是寻找最大的糖果不是一件非常简单的事情，所以小Ho希望能够用计算机来他帮忙计算这个问题！

提示：吃糖果吃多了会变胖的！

输入

每个测试点（输入文件）有且仅有一组测试数据。

在一组测试数据中：

第1行为1个整数N，表示需要处理的事件数目。

接下来的M行，每行描述一个事件，且事件类型由该行的第一个字符表示，如果为’A’，表示小Ho将一粒糖果放进了盒子，且接下来为一个整数W，表示这颗糖果的重量；如果为’T’，表示小Ho需要知道当前盒子中最重的糖果的重量是多少，在知道这个值之后，小Ho会将这颗糖果从盒子中取出并吃掉。

对于100%的数据，满足1<=N<=10^5, 1<=w<=10^5。<>

对于100%的数据，满足没有2颗糖果的重量是相同的，最开始的时候小Ho的糖果盒子是空的，且每次小Ho想要取出一颗糖果的时候盒子里一定至少有一颗糖果。

输出

在一组测试数据中：

对于每个类型为’T’的时间，输出1个整数W_MAX，表示在这一时刻，盒子中最重的糖果的重量。

样例输入
5
A 77751
A 1329
A 26239
A 80317
T
样例输出
80317

题目的意思是编写一个数据结构，满足时间复杂度为O（logN）取得最大值O（logN）插入数据

这种数据结构就是堆了

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

/**
 * 
 * @author chenrenyuan
 * 5
A 77751
A 1329
A 26239
A 80317
T
 *
 */
public class Main {

    static int n, p;

    public static void main(String[] args) {
        Comparator<Integer> com = new Comparator<Integer>() {


            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        };

        Heap<Integer> heap = new Heap<Integer>(com, 1000000);
        Scanner cin = new Scanner(System.in);
        n = cin.nextInt();
        for(int i = 0; i < n; ++i){
            String c = cin.next();

            if("A".equals(c)){
                int val = cin.nextInt();
                heap.add(val);
            }else{
                System.out.println(heap.top());
            }
        }
    }

    public static class Heap<T extends Object> {

        Comparator<T> comparator;
        T[] elements;
        int size = 0;

        public Heap(Comparator<T> c, int maxSize) {
            this.comparator = c;
            elements = (T[]) new Object[maxSize];
        }

        public T top() {
            T value = elements[0];
            this.size--;
            int cur = 0;
            elements[cur] = elements[size];
            while(cur * 2 + 1 < this.size){
                int next = cur * 2 + 1;
                if(next + 1 < this.size){
                    next = this.comparator.compare(this.elements[next],
                            this.elements[next + 1]) > 0 ? next : next + 1;
                }
                if(this.comparator.compare(this.elements[cur], this.elements[next]) < 0){
                    swap(cur, next);
                    cur = next;
                }
                else break;
            }

            return value;
        }

        private void swap(int i, int j){
            T e = this.elements[i];
            this.elements[i] = this.elements[j];
            this.elements[j] = e;
        }

        public void add(T e) {
            this.elements[this.size] = e;
            int cur = this.size;
            this.size ++;
            while(cur > 0){
                int next = (cur - 1) / 2;
                if(this.comparator.compare(this.elements[cur], this.elements[next]) > 0){
                    swap(next, cur);
                    cur = next;
                }
                else{
                    break;
                }
            }
        }
    }

}