如何检查两个给定堆栈是否具有相同的值？（顺序不一定相同）

Question

每个人如何检查两个堆栈是否具有相同的值？

例如，在stack1中我有[1,3,4,5]，在stack2中我有[4,3,1,5]，因此堆栈具有相同的值，并且Method需要返回true。

此外，堆栈必须（最终）与给定的堆栈相同（具有原始值和相同的顺序）。

我已经开始做了，但不幸的是，效果不好：

import java.util.Stack;
public class StackMain {
    public static void main(String[] args) {
        
        Stack<Integer> st1 = new Stack<Integer>();
        st1.push(2);
        st1.push(643);
        st1.push(254);
        st1.push(13);
        st1.push(74);
        st1.push(6);
        st1.push(5);
        st1.push(99);
        
        Stack<Integer> st2 = new Stack<Integer>();
        st2.push(643);
        st2.push(2);
        st2.push(254);
        st2.push(13);
        st2.push(99);
        st2.push(5);
        st2.push(6);
        st2.push(74);
        System.out.println(isSameStacks(st1,st2));
    }
    public static boolean isSameStacks(Stack st1, Stack st2)
    {
        Stack st1Reverse = new Stack();
        Stack st2Reverse = new Stack();
        boolean isExist = false;
        while(st1.isEmpty()==false)
        {
            isExist = false;
            st1Reverse.push(st1.pop());
            while(st2.isEmpty()==false)
            {
                st2Reverse.push(st2.pop());
                if(st1Reverse.peek()== st2Reverse.peek())
                    isExist  = true;
            }
            while(st2Reverse.isEmpty()==false)
                st2.push(st2Reverse.pop());
            if(isExist!=true)
            {
                while(st1Reverse.isEmpty()==false)
                    st1.push(st1Reverse.pop());
                return false;
            }
        }
        while(st1Reverse.isEmpty()==false)
            st1.push(st1Reverse.pop());
        return true;
    }

提前谢谢。

Answer 1

更新：正如@lzruo所提到的，如果堆栈有重复的元素，这将不起作用。假设stack1有[1,1,2]，stack2有[1,2]，这将返回true。

初始答案：由于JavaStack是一个Vector，它是一个Collection（特别是一个List），我们可以从堆栈中迭代或创建一个流并将其收集到ASet（HashSet）。这不会影响堆栈中的元素（不会被删除）。

或者简单地说，由于HashSet构造函数按照我们的喜好接受集合：

Set<Integer> stack1AsSet = new HashSet<>(st1);
Set<Integer> stack2AsSet = new HashSet<>(st2);

System.out.println(stack1AsSet.equals(stack2AsSet)); //prints true

堆栈顺序或元素不会受到影响。

System.out.println(st1.pop()); //prints 99

@c0der的答案更简单。但如果使用哈希集，则可以在检查集内容之前检查堆栈大小是否相等。

return st1.size() == st1.size() &&  new HashSet<>(st1).equals(new HashSet<>(st2));

Answer 2

我们可以使用Hashmap跟踪每个堆栈中的元素计数，并使用它们检查两个堆栈是否相同

import java.util.*;
public class HelloWorld {
    public static void main(String[] args) {
        
        Stack<Integer> st1 = new Stack<Integer>();
        st1.push(2);
        st1.push(643);
        st1.push(254);
        st1.push(13);
        st1.push(74);
        st1.push(6);
        st1.push(5);
        st1.push(99);
        
        Stack<Integer> st2 = new Stack<Integer>();
        st2.push(643);
        st2.push(2);
        st2.push(254);
        st2.push(13);
        st2.push(99);
        st2.push(5);
        st2.push(6);
        st2.push(74);
        System.out.println("Is Same STack: " + isSameStacks(st1,st2));
    }
    public static boolean isSameStacks(Stack<Integer> st1, Stack<Integer> st2)
    {
        Stack<Integer> st1Reverse = new Stack<Integer>();
        Stack<Integer> st2Reverse = new Stack<Integer>();
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        boolean isExist = false;
        while(st1.isEmpty()==false)
        {
            isExist = false;
            Integer val = st1.pop();
            Integer val2 = st2.pop();
            st1Reverse.push(val);
            st2Reverse.push(val2);
            if(map.get(val) == null) {
                map.put(val, 0);
            }
            if(map.get(val2) == null) {
                map.put(val2, 0);
            }
            map.put(val, map.get(val) + 1);
            map.put(val2, map.get(val2) + 1);
        }
        boolean res = true;
        Integer tmp;
        while(st1Reverse.isEmpty()==false) {
            tmp = st1Reverse.pop();
            if(map.get(tmp)%2 != 0) {
                res = false;
            }
            st1.push(tmp);
        }
        while(st2Reverse.isEmpty()==false) {
            tmp = st2Reverse.pop();
            if(map.get(tmp)%2 != 0) {
                res = false;
            }
            st2.push(tmp);
        }
        return res;
    }
}

Answer 3

一种简单的方法是使用Collection功能：

   public static boolean isSameStacks(Stack st1, Stack st2)   {
        if(st1.size() != st1.size()) return false;
        List list = new ArrayList<>(st1);//add all st1 elements 
        list.removeAll(st2);//remove all st2 elements 
        return list.size() == 0;
   }

为了完整起见，这里是另一个使用Collection功能的解决方案。它基于@user7发布的部分解决方案：

  public static boolean isSameStacks(Stack st1, Stack st2)   {
       return st1.size() == st1.size() &&  
                    new HashSet<>(st1).equals(new HashSet<>(st2)); 
   }