Question

我正在尝试实现一个堆栈，将一个字符串分解为单独的组件，并将它们放入一个链表中。到目前为止，我构建了一个令牌工具，通过抓取角色，构建对象并将其放置在链表中来正确工作。当我们到达“（”或“）”字符表示必须制作新的子列表时，问题就出现了。我创建了一个包含子列表的LispList对象，但列表始终为空并停止打印。我会很感激有关如何正确设置堆栈的一些帮助，所以当我们达到“（”然后当我们完成语句时弹出它“）”时我可以推送它。谢谢！

这是将要发送的字符串的示例。然后它会将其分解为

（4 -1a（45“abc”3）7/5）

（45“abc”3）是一个子列表。 7/5是比率。 4是整数 -1a符号 45整数

这是LispConversion类的一个示例，它将字符串分解为字符并将它们放入对象中。当我们检查“（或”）“字符并尝试实现堆栈时，问题出现在类的末尾。

public class LispConversion{

public LispObject head;
public LispObject temphead;
public Stack<LispObject> stack;


public void parse(String values){  
    StreamTokenizer t = new StreamTokenizer(new BufferedReader(new StringReader(values)));
    t.resetSyntax();   
    t.wordChars(0,255); 
    t.whitespaceChars(0,' '); 
    t.commentChar(';'); 
    t.quoteChar('"');
    t.ordinaryChar('('); 
    t.ordinaryChar(')');

    stack = new Stack<LispObject>();

    try {
        t.nextToken();
    }
    catch (IOException e){
        System.out.println(e);
    }

    while (t.ttype != StreamTokenizer.TT_EOF){
        switch (t.ttype) {

        case StreamTokenizer.TT_WORD: 
            try{ 
                int value = Integer.parseInt(t.sval);
                head = new LispInteger(head, value);
                } 

            catch (NumberFormatException e1){
                try{
                    double value = Double.parseDouble(t.sval);
                    head = new LispFloat(head, value);
                    } 
                catch (NumberFormatException e2){
                    String[] array = t.sval.split("/");
                    if (array.length != 2){ 
                        String value = t.sval;
                        head = new LispSymbol(head, value);
                    } 
                    else {
                        int numerator = Integer.parseInt(array[0]);
                        int denominator = Integer.parseInt(array[1]);
                        head = new LispRatio(head, numerator, denominator);
                    }
                }
            }
        break;

    case '"': 
        String value = t.sval;
        head = new LispString(head, value);
    break;

    default: 
    if((char)t.ttype == '('){

        //this is an opening expression. Here, we are going deeper
        //so lets add the current head to our stack

        LispList newList = new LispList(head);
        head = newList;
        stack.push(newList);
        stack.push(head);

        //set the new head to be the head of the new list
       head = newList.listHead;    
        }
    if((char)t.ttype == ')'){
        head = stack.pop();
        System.out.println();
    }


    }

    try {
        t.nextToken();
    }
    catch (IOException e){
        System.out.println(e);
    }
}

这是LispList类的一个示例，它保存子列表并打印它们。

public class LispList extends LispObject {

    public LispObject listHead;


public LispList(LispObject next){
    super(next);
}

public void printList(){
    System.out.print("List: ");
    if(listHead == null){
        System.out.println("The list is empty.");
        return;
    }
    LispObject temp = listHead;
    while(temp != null){
        System.out.print(temp + " ");
        temp = temp.next;
    }
    System.out.println();
}
}

使用链接列表构建堆栈

0 个答案: