我认为你应该使用Null Object Pattern。你可以将任何对象（最好是不可变的）定义为null值，并在任何地方使用它，而不是null。例如，如果你使用Jackson：

public static final TreeNode NULL = NullNode.getInstance();

Deque<TreeNode> queue = new ArrayDeque<>();
queue.offer(NULL);

while(!queue.isEmpty()) {
    TreeNode node = queue.poll();

    if(node == NULL)
        System.err.println("null object");
    else
        System.out.println("not null object");
}

另一种解决方案是，您可以在Deque中使用Optional而不是TreeNode：

Deque<Optional<TreeNode>> queue = new ArrayDeque<>();
queue.offer(Optional.empty());

while (!queue.isEmpty()) {
    Optional<TreeNode> optNode = queue.poll();

    if (optNode.isEmpty())
        System.err.println("null object");
    else
        System.out.println("not null object");
}

谢谢你的启发！这是我的最终版本算法：

class Solution {
    static final TreeNode NULL_TREENODE = new TreeNode(101);

    public boolean isSymmetric(TreeNode root) {
        Deque<TreeNode> queue = new ArrayDeque<>();
        Deque<Integer> stack = new ArrayDeque<>();
        
        if (root != null) {
            queue.offer(root);
            while (!queue.isEmpty()) {
                int size = queue.size();
                for (int i = 0; i < size; i++) {
                    TreeNode node = queue.poll();
                    if (node != root) {  
                       stack.push(node.val);
                    } 
                    if (node != NULL_TREENODE) {

                        if (node.left != null) {
                            queue.offer(node.left);
                        } 
                        if (node.left == null) {  
                            queue.offer(NULL_TREENODE);
                        }
                        if (node.right != null) {
                            queue.offer(node.right);
                        }
                        if (node.right == null) {
                            queue.offer(NULL_TREENODE);
                        }
                   }
                }
          
                while (!stack.isEmpty()) {
                    if (stack.removeFirst() != stack.removeLast()) {
                        return false;
                    }
                }
            }
        }

        return true;
    }
}

然而，这不是一个很好的算法这个问题，因为它需要很多额外的内存空间的堆栈。

除了ArrayDeque，为什么不简单地使用LinkedListaddLast方法，

public void addLast(E e)
Appends the specified element to the end of this list.
This method is equivalent to add(E).

Specified by:
addLast in interface Deque<E>
Parameters:
e - the element to add

简单但不太好的解决方案：

• 使用ArrayDeque<Optional<MyClass>>，MyClass是你的类，然后你可以添加一个空的Optional。
• 您也可以使用任何其他 Package 器类，并将包含的元素设置为null。
  更好的解决方案：

但是为了更好地解决你的问题，一般来说我建议你有一些特殊的元素，定义为常量，如下所示：
如果需要更多信息，static public final MyClass STOP_INDICATOR = new MyClass();和MyClass可能会安装一些特殊的TOR。
如果您随后检索并检查它，您甚至可以使用 identity 检查a == b，而不必使用a.equals(b)，因为它是一个常量。