如何在Java中實現僅存儲唯一值的堆棧

Question

我正在嘗試實現唯一堆棧。 如果我嘗試擴展堆棧類並使用包含，它將查看整個堆棧，時間復雜度將變為 O(n)。 所以我嘗試擴展 LinkedHashSet ，它會自行刪除重復項並保持順序。 我能夠實現除 pop 之外的所有方法。

有人可以在這里分享想法嗎？

import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Stack;
import java.util.stream.Stream;

public class UniqueStack<E> extends LinkedHashSet<E>{

    private int size = 0;

    @Override
    public Stream<E> stream() {
        return super.stream();
    }

    public boolean push(E e) {
        if (!contains(e)) {
            ++size;
            return super.add(e);
        }
        return false;
    }

    public E pop() {       
       // struck here
    return;
    }
}

Answer 1

我正在嘗試實現唯一的堆棧。 如果我嘗試擴展堆棧類並使用contains，它將看起來整個堆棧，時間復雜度將變為O（n）。 因此，我嘗試擴展LinkedHashSet，它會自行刪除重復項並保持順序。 我可以實現除pop之外的所有方法。

有人可以在這里分享想法嗎？

import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Stack;
import java.util.stream.Stream;

public class UniqueStack<E> extends LinkedHashSet<E>{

    private int size = 0;

    @Override
    public Stream<E> stream() {
        return super.stream();
    }

    public boolean push(E e) {
        if (!contains(e)) {
            ++size;
            return super.add(e);
        }
        return false;
    }

    public E pop() {       
       // struck here
    return;
    }
}

Answer 2

我相信最好使用常規堆棧的instance進行堆棧操作，但使用HashSet的效率來跟蹤重復項。 可以使用相同的想法添加其他方法。

    UniqueStack<Integer> stack = new UniqueStack<>();

    stack.push(10);
    stack.push(20);
    stack.push(30);
    stack.push(40);
    stack.push(30); // ignored
    stack.push(50);

    System.out.println(stack);
    int v = stack.pop();
    System.out.println(v);
    System.out.println(stack);
    stack.push(1);
    stack.push(2);
    System.out.println(stack);
    v = stack.pop();
    System.out.println(v);
    System.out.println(stack);

這個的輸出是

[10, 20, 30, 40, 50]
50
[10, 20, 30, 40]
[10, 20, 30, 40, 1, 2]
2
[10, 20, 30, 40, 1]

class UniqueStack<E> extends LinkedHashSet<E> {

    Stack<E> stack = new Stack<>();
    private int size = 0;


    public Stream<E> stream() {
        return stack.stream();
    }

    public boolean push(E e) {
        if (!contains(e)) {
            ++size;
            stack.push(e);
            return add(e);
        }
        return false;
    }

    public E pop() {
        E val = null;
        if (!stack.isEmpty()) {
            --size;
            val = stack.pop();
            remove(val);
        }
        return val;
    }
}