Question

我正在尝试实现一个堆栈，该堆栈以排序的方式保存项目并返回每个pop中的最少元素。我正在使用两个堆栈来实现排序堆栈。

这是我对普通香草堆的实现。

public class Stack<T> implements Iterable{
    private Node head;

    @Override
    public Iterator iterator() {
        return new StackIterator();
    }

    private class Node<T extends Comparable<T>>{
        private T data;
        private Node next;

        public Node(T data){
            this.data = data;
            next = null;
        }

        public int compareTo(T other){
            return data.compareTo(other);
        }
    }

    private class StackIterator<T> implements Iterator<T> {

        Node current = head;
        @Override
        public boolean hasNext() {
            return (current != null);
        }

        @Override
        public T next() {
            T item = (T) current.data;
            current = current.next;
            return item;
        }
    }

    public void push(T item){
        Node p = new Node((Comparable) item);
        if(head == null){
            head = p;
            return;
        }
        p.next = head;
        head = p;

    }
    public T pop(){
        if(head == null){
            System.out.println("Popping off an empty stack!!!");
            System.exit(-1);
        }
        T item = (T) head.data;
        head = head.next;
        return item;

    }
}

此堆栈用于SortedStack。这是部分代码。

public class SortedStack<T> {

    private int size;
    private  Stack<T> s1;
    private Stack<T> s2;

    public SortedStack(){

        s1 = new Stack<>();
        s1 = new Stack<>();
        size = 0;
    }
    public void push(T item){

        for (Iterator<T> iter = s1.iterator(); iter.hasNext(); iter.next()){
            if (iter.compareTo(item) > 0){
               s2.push(s1.pop());
            }else if(iter.compareTo(item) < 0){
                s1.push(item);
                break;
            }else{
                s1.push(item);
                break;
            }
        }
        for (Iterator<T> iter = s2.iterator(); iter.hasNext(); iter.next()){
            s1.push(s2.pop());
        }
    }

    public T pop(){

    }


}

问题是SortedStack中没有解析节点的T（对象）比较。 compareTo不起作用。这是可以理解的，因为Node是Stack的内部私有类。我的问题是如何将compareTo类的Node方法暴露给SortedStack以实现它的逻辑，而不会不分青红皂白地将所有内容公开？

Answer 1

您的代码中有很多错误。例如，为什么要尝试将迭代器与项目进行比较？此外，逻辑被破坏：您将插入的项目与s1的头部进行比较，然后将其推到尾部。只要插入的第一个项目是最小的项目，所有其他项目将始终以插入顺序结束。考虑插入0，然后插入3，然后插入1。

要回答您的问题，您需要在extends Comparable<T>声明中使用SortedStack类型边界，而不是Node。 Node根本不需要Comparable。

如果不是作业，请改用TreeSet。

Java中的排序堆栈

1 个答案: