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

Question

各位。如何检查 2 个堆栈是否具有相同的值？

例如，在 stack1 中我有 [1,3,4,5]，在 stack2 中我有 [4,3,1,5]，所以堆栈具有相同的值，方法需要 return 正确。

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

我已经开始着手处理它，但不幸的是效果不佳：

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]，这将 return 为真。

初步回答： 由于 Java Stack 是 Vector 又是 Collection（特别是 List），我们可以从堆栈迭代或创建流并收集它在 Set (HashSet) 中。这不会影响元素（不会被删除）。在堆栈中或它们的顺序中。

或者简单地说，因为 HashSet 构造函数像我们喜欢的那样接受 Collection：

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的回答比较简单。但是如果你使用 HashSet，你可以在检查集合内容之前检查堆栈大小是否相等。

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

Answer 2

一种简单的方法是使用 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)); 
   }

Answer 3

我们可以使用 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;
    }
}

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

How can I check if 2 given stacks has the same values? (Not necessarily in the same order)

java

stack

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