Question

我有一个模拟队列的程序，其中有两种类型的输入join和leave。

join输入附加一个整数，表示人的高度，如join 180，而leave输入附加一个整数，表示人数离开队列leave 3。

每次调用join或leave查询时，程序都应返回可以查看队列前端的人数。如果他/她前面的队列中的每个人都比他/她短，或者他/她是队列中的第一个人，则可以看到前方。

输入/输出的一个例子如图所示。

这是我的代码，我创建了两个堆栈来存储队列中的人数，以及可以查看前端的人数：

 private void run() {
        Scanner sc = new Scanner(System.in);
        int no_queries = Integer.parseInt(sc.nextLine());

        for(int i = 0; i < no_queries; i++){
            String[] queries = sc.nextLine().split(" ");
            int value = Integer.parseInt(queries[1]);
            switch(queries[0]){
                    case "join":
                        if(!height.empty()){
                            if(height.peek() < value){
                                height.add(value);
                            }
                        }else{
                            height.add(value);
                        }
                        stack.add(value);
                        System.out.println(height.size());
                    break;
                    case "leave":
                        for(int j = 0; j < value; j++){
                            stack.pop();
                            }
                        //how do i remove the height stack?
                        System.out.println(height.size());
                    break;
            }
        }
    }

这是我的输出，最后三个条目是错误的：

我的问题在于身高堆栈。在给出leave 3查询时，将从队列堆栈中删除整数160，170和165。

但是，高度堆栈只包含两个整数160和170，尽管不应删除身高160的人，但查询将删除这两个值从队列中排队，而不是离开的3人。

我考虑使用Person对象来存储最高的person变量，但是有更优雅的方法来解决这个问题吗？

Answer 1

我认为你可以使用Person对象，而不是存储最高的人，但是可以比较两个堆栈的值。我的意思是，当你执行stack.pop();时，你需要一种方法来检查你是否从堆栈中删除了最高人物对象，如果是这样的话，也将它从最高人群中移除。

static class Person {
    int height;
    Person (int height) {
        this.height = height;
    }
}

private static void run() {
    Stack<Person> stack = new Stack<>();
    Stack<Person> highest = new Stack<>();
    Scanner sc = new Scanner(System.in);
    int n = Integer.parseInt(sc.nextLine());

    for (int i = 0; i < n; i++) {
        String[] queries = sc.nextLine().split(" ");
        int value = Integer.parseInt(queries[1]);
        switch (queries[0]) {
            case "join":
                Person person = new Person(value);
                if (highest.empty()) {
                    highest.push(person);
                } else if (value > highest.peek().height) {
                    highest.push(person);
                }
                stack.push(person);
                System.out.println(highest.size());
                break;
            case "leave":
                for (int j = 0; j < value; j++) {
                    Person left = stack.pop();
                    if (left == highest.peek()) {
                        highest.pop();
                    }
                }
                System.out.println(highest.size());
                break;
        }
    }
}

Answer 2

这是解决问题的另一种方法。添加到堆栈的每个元素都会被赋予标识符y_或n_，以表示它们是否在特定堆栈中是最高的。

private void run() {
    Scanner sc = new Scanner(System.in);
    int no_queries = Integer.parseInt(sc.nextLine());

    for(int i = 0; i < no_queries; i++){
        String[] queries = sc.nextLine().split(" ");
        int value = Integer.parseInt(queries[1]);
        switch(queries[0]){
                case "join":
                    if(stack.empty()){
                        stack.add(String.format("y_%d", value));
                        height.add(String.format("y_%d", value));  
                    }else{
                        if(!height.empty()){
                            if(Integer.parseInt(height.peek().substring(2)) < value){
                                stack.add(String.format("y_%d", value));
                                height.add(String.format("y_%d", value)); 
                            }else{
                                stack.add(String.format("n_%d", value));                                    
                            }
                        }
                    }
                    System.out.println(height.size());
                break;
                case "leave":
                    for(int j = 0; j < value; j++){
                        if(!height.empty()){
                            if(height.peek().equals(stack.pop())){
                                height.pop();
                            }
                        }
                    }
                    System.out.println(height.size());
                break;
        }
    }
}

Java堆栈队列获取可以查看前端的人数

2 个答案: