算法学习之基础(背包 列队 栈) 习题1.3.9 补全括号

　　题目描述：编写一段程序，从标准输入得到一个缺少左括号的表达式，并打印出补全括号之后的中序表达式。列如 1+2 ) * 3 - 4 ) * 5 - 6 ) ) )

你的程序应该输出 ( ( 1 +2 ) * ( ( 3 - 4 )* ( 5 - 6) ) )

　　刚开始看到这个习题感觉这反扩号可以随便补没有限制啊，但按要求输出给的样例那种肯定是利用前面学过的知识，唯一有关系的就是求算术表达式的值了，

　　求算术表达式步骤很简单，首先初始化两个栈，一个运算符，一个存操作数

　　碰到数字压入操作数栈，

　　碰到运算发压入运算符栈，

　　碰到（ 忽略，

　　碰到 ） 弹出运算符，弹出运算符所需要的操作数（一般两个），将操作数和运算符计算出的结果压入操作数栈。

　　根据上面方法，只需要把最后一步改下碰到）弹出运算符，弹出运算符所需操作数将 "（"+"操作数"+"运算符"+"操作数"+"）"这个字符串压入操作数栈里(可以把操作数栈用String)，最后弹出操作数栈就ok。

　　

public static String bracket(String s){
        Stack<String> o=new Stack<String>();//运算符
        Stack<String> v=new Stack<String>();//操作数
        char[] c=s.toCharArray();
        for(int i=0;i<c.length;i++){
            s=c[i]+"";
            if("+".equals(s)||"-".equals(s)||"*".equals(s)||"/".equals(s)){
                o.push(s);
            }else if(")".equals(s)){
                String a=v.pop();
                String b=v.pop();
                s="("+b+o.pop()+a+")";//这里注意a和b的顺序
                v.push(s);
            }else if("(".equals(s)){
                //不管,主要是后面懒得写判断数字。。。
            }else{
                v.push(s);
            }
        }
        return v.pop();
    }

测试

System.out.println(bracket("1+2)*3-4)*5-6)))"));

结果：

((1+2)*((3-4)*(5-6)))

 哦，这里的Stack用的是自己写的类

package gh;

import java.util.Iterator;

/**
 * 链表实现下压栈
 * @author ganhang
 * @param <T>
 */
public class Stack<T> implements Iterable<T>{
    private Node first;//栈里的元素
    private int n;//栈大小
    private class Node{
        T item;
        Node next;
    }
    public void push(T item){
        //向栈顶添加元素（节点）
        Node oldfirst =first;
        first=new Node();
        first.item=item;
        first.next=oldfirst;
        n++;
    }
    //返回最近添加的元素，不删除
    public T peek(){
        T item=first.item;
        return item;
    }
    //删除最近添加的元素
    public T pop(){
        //删除头节点
        T item=first.item;
        first=first.next;
        n--;
        return item;
    }
    public boolean isEmpty(){
        return n==0;
    }
    public int size(){
        return n;
    }
    @Override
    public Iterator<T> iterator() {
        // TODO Auto-generated method stub
        return new StackIterator();
    }
    private class StackIterator implements Iterator<T>{
        private Node current=first;
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return n!=0;
        }

        @Override
        public T next() {
            // TODO Auto-generated method stub
            T item=current.item;
            current=current.next;
            return item;
        }

        @Override
        public void remove() {
            // TODO Auto-generated method stub
            
        }
        
    }
}