代码中的堆栈跟踪

Question

I was wondering how I would add a trace to the stack of this code that converts infix to postix for expressions.

class Node  {
    public Object data;
    public Node next;
    public Node () {
       data =' ';  next = null; }
    public Node (Object val) {
       data = val;  next = null; }
}

public class LinkStack {
    private Node top;
    public LinkStack() {
        top = null; }
    public boolean empty(){
        return top == null; }


    public boolean full(){
        return false;
    }
public void push(Object e){
        Node tmp = new Node(e);
        tmp.next = top;
        top = tmp;
    }
public Object pop(){

    Object e =  top.data;
    top = top.next;
    return e;
}
public Object peek(){

    Object e =  top.data;

    return e;
}


public void matching(String x)
{   
    LinkStack S=new LinkStack();

    for(int i=0;i<x.length();i++)
    {
        char c=x.charAt(i);
        if(c=='(')
            S.push(c);
        else
        {
            if(c==')')
            if(S.empty())
                System.out.println("NOT MATCHING !!!");
            else
                S.pop();
        }
    }
    if(!S.empty())
        System.out.println("NOT MATCHING !!!");
    else
        System.out.println("MATCHING !!!");
}
public void Evaluation(String x)
{

    LinkStack S=new LinkStack();
    for(int i=0;i<x.length();i++)
    {
        char c=x.charAt(i);
        String s="0"+c;

        if(c=='+')
        {
            int z=Integer.parseInt((String)S.pop())+Integer.parseInt((String)S.pop());
            S.push(Integer.toString(z));
        }
        else if(c=='*')
        {
            int z=Integer.parseInt((String)S.pop())*Integer.parseInt((String)S.pop());
            S.push(Integer.toString(z));

        }
        else if(c=='/')
        {   int u=Integer.parseInt((String)S.pop());

            int z=Integer.parseInt((String)S.pop())/u;
            S.push(Integer.toString(z));

        }
        else if(c=='-')
        {   int u=Integer.parseInt((String)S.pop());
            int z=Integer.parseInt((String)S.pop())-u;
            S.push(Integer.toString(z));
        }
        else
        S.push(s);
    }
    System.out.println("THE POSTFIX = "+x);
    System.out.println("THE RESULT = "+S.pop());
}
public void postfix(String x)
{
    String output="";
    LinkStack S=new LinkStack();
    for(int i=0;i<x.length();i++)
    {
        char c=x.charAt(i);

        if(c==('+')||c==('*')||c==('-')||c==('/'))
            {while(!S.empty() && priority(S.peek())>= priority(c))
                output+=S.pop();
            S.push(c);
            System.out.println(output);
            }
        else if(c=='(')
        {
            S.push(c);
        }
        else if(c==')')
        {
            while(!S.peek().equals('('))
                    output+=S.pop();
            S.pop();
            System.out.println(output);
        }
        else
        {
            output+=c;
            System.out.println(output);
        }
    }
    while(!S.empty())
        output+=S.pop();
    System.out.println("THE INFIX = "+x);
    System.out.println("THE POSTFIX = "+output);
}
public int priority(Object x)
{
    if(x.equals('+')||x.equals('-'))
        return 1;
    else if(x.equals('*')||x.equals('/'))
        return 2;
    else
        return 0;
}

public static void main(String args[])
{


    LinkStack s=new LinkStack();
    s.postfix("x*y–z+(a–c/d)");
    System.out.println("------------------------------------------");
    s.matching("x*y–z+(a–c/d)");
    System.out.println("------------------------------------------");
}
}

Answer 1

I am pretty much wanting to follow the contents of the stack throughout the conversion

There's no rocket science solution to this.

Just add System.err.println(...) calls at the relevant places. Or if you were doing this in production code (heaven forbid!) you might use a Logger instead of System.err .

---

^{(For the record, the term "stack trace" normally means a trace of a program's call stack, not a trace of what happens to some application-specific stack data structure. You might want to choose your terminology a little more carefully next time.)}