使用单链表计算后缀表达式

Question

我正在编写一个程序，要求用户输入后缀表达式，然后将结果输出到表达式。我正试图使用一个单链表来实现这一点，并使用适配器模式来创建一个堆栈。

singlelinkedlist类、LinkedStack类和Stack实现的代码都是直接从我自己的数据结构书中获得的。因此，SinglyLinkedListTest类是唯一一个包含我自己的代码（并且有错误）的类。

我以前写过一个程序，它只使用堆栈计算后缀表达式，但这次我对包含的额外类感到困惑。

我肯定我有很多错误，但对我来说最明显的错误是在我的SinglyLinkedListTest类中，每次我将一个值推到堆栈上。我知道问题在于，我试图将对象和字符推送到堆栈上，而不是将与push（ee）匹配的参数推送到堆栈上，但我不知道如何修改代码以使其工作。

如有任何建议或意见，将不胜感激。

这是我的堆栈实现：

package PostFix;

public interface Stack<E> 
{
    int size();

    boolean isEmpty();

    void push(E e);

    E pop();
}

这是我的LinkedStack类：

package PostFix;

public class LinkedStack <E> implements Stack<E>
{
    private SinglyLinkedList<E> list = new SinglyLinkedList<>();

    public LinkedStack()
    {

    }

    public int size()
    {
        return list.size();
    }

    public boolean isEmpty()
    {
        return list.isEmpty();
    }

    public void push(E e)
    {
        list.addFirst(e);
    }

    public E pop()
    {
        return list.removeFirst();
    }
}

这是我的SingleLinkedList类：

package PostFix;

public class SinglyLinkedList<E>
{
    private static class Node<E>
    {
        private E element;
        private Node<E> next;

        public Node(E e, Node<E> n)
        {
            element = e;
            next = n;
        }

        public E getElement()
        {
            return element;
        }

        public Node<E> getNext()
        {
            return next;
        }       
    }

    private Node<E> head = null;
    private Node<E> tail = null;
    private int size = 0;

    public SinglyLinkedList()
    {

    }

    public int size()
    {
        return size;
    }

    public boolean isEmpty()
    {
        return size == 0;
    }

    public void addFirst(E e)
    {
        head = new Node<>(e, head);

        if (size == 0)
        {
            tail = head;
        }
        size++;
    }

    public E removeFirst()
    {
        if (isEmpty())
        {
            return null;
        }
        E answer = head.getElement();
        head = head.getNext();
        size--;

        if (size == 0)
        {
            tail = null;
        }
        return answer;
    }
}

这是我的最后一个SinglelyLinkedListTest类：

package PostFix;
import java.util.Scanner;

public class SinglyLinkedListTest 
{
    public static void main(String[] args)
    {
        Double num1, num2, answer;
        char c;

        Stack<Double> stack = new LinkedStack<>();
        Scanner input = new Scanner(System.in);

        System.out.println("Enter the expression you would like to evaluate: ");
        String someString = input.nextLine();

        for (int index = 0; index < someString.length(); index++)
        {
            c = someString.charAt(index);

            if (Character.isDigit(c))
            {
                stack.push((double)Character.digit(c, 10));
            }
            else if (c == '+')
            {
                num2 = stack.pop();
                num1 = stack.pop();
                answer = num1+num2;
                stack.push(answer);
            }
            else if (c == '-')
            {
                num2 = stack.pop();
                num1 = stack.pop();
                answer = num1-num2;
                stack.push(answer);
            }
            else if (c == '*')
            {
                num2 = stack.pop();
                num1 = stack.pop();
                answer = num1*num2;
                stack.push(answer);
            }
            else if (c == '/')
            {
                num2 = stack.pop();
                num1 = stack.pop();
                answer = num1/num2;
                stack.push(answer);
            }     
        }
        System.out.println("The result is: " + stack.pop());
    }
}

Answer 1

Stack<String> buffer = new LinkedStack<>();

>

 buffer.push(someString.charAt(index));

和对象：

buffer.push(answer);

并弹出int：

num1 = buffer.pop();

你从来没有推或弹出字符串。

下定决心吧。您应该根据所需的精度推送和弹出整数，或长，或双倍，或大小数。

编辑

buffer.push((double)c);

这是无效的。推送的是ASCII值，而不是它对应的数值。你需要

buffer.push((double)Character.digit(c, 10));

在每个if块之后，还需要一个else：如果字符是一个数字，它就不会是，如果它是它就不会是-，等等。