栈的经典应用

        前言

                   前面的一文中，说明了什么是栈，以及栈的两种实现方式。接下来我们简单看看栈的经典的

              应用。

        栈的应用举例

                   栈的操作是十分有效的，是以常数时间运行的。有一种观念认为栈可能是计算机科学中除了

              数组之外的最基本的数据结构了。那么栈到底有哪些运用呢？

               Tips：下面的实现都是基于前面文章中的栈的数组的方式来进行实现的。

                    http://blog.csdn.net/kiritor/article/details/8867149

           1、十进制正整数N进制

/*其实这里略有问题的
* 例如16进制的表示
* 14进制的表示
* 若14进制数为124：无法确定其具体是什么*/
public static String conversion(int num, int n) {
Stack<Integer> myStack = new ArrayStack<Integer>();
Integer result = num;
while (true) {
// 将余数入栈
myStack.push(result % n);
result = result / n;
if (result == 0) {
break;
}
}
StringBuilder sb = new StringBuilder();
// 按出栈的顺序倒序排列即可
while ((result = myStack.pop()) != null) {
sb.append(result);
}
return sb.toString();
}

           2、平衡符号的判断

                     匹配思想是： 1、首先读入字符串保存在字符数组中

                                              2、依次判断每个字符，如果是开放字符则压入栈中

                                              3、如果是关闭字符而且此时栈为空的话，那么字符串非平衡串，否则栈顶元素弹出

                                                    并与该字符进行比较若能够成对匹配则继续，否则非平衡串。

                                              4、在字符数组结尾处，如果栈非空则非平衡串，反之则是。                 

/*提取去需要检查的序列*/
    public static String strFilter(String string)
    {
        StringBuffer sb = new StringBuffer();
        char[] chars = string.toCharArray();
       
        for(char c:chars)
          if(c=='['||c=='{'||c=='('||c==']'||c=='}'||c==')')
              sb.append(c);
        return sb.toString();
    }
    
    public static boolean isMatch(String str) {  
        Stack<Character> myStack = new ArrayStack<Character>();  
        char[] arr = strFilter(str).toCharArray();
        System.out.println(strFilter(str));
        for (char c : arr) {  
            Character temp = myStack.pop();  
            // 栈为空时只将c入栈  
            if (temp == null) {  
                myStack.push(c);  
            }  
            // 配对时c不入栈  
            else if (temp == '[' && c == ']') {  
            }   
            // 配对时c不入栈  
            else if (temp == '(' && c == ')') {  
            }   
            else if (temp == '{' && c == '}') {  
            }  
            // 不配对时c入栈  
            else {  
                myStack.push(temp);  
                myStack.push(c);  
            }  
        }  
        return myStack.isEmpty();  
    } 

             测试代码：

String str = "sdfsdf{5*{2+5*(4+6)}}sdf";
System.out.println(isMatch(str));

            运行结果：

                             

           3、行编辑器

                   输入行中字符‘#’表示退格'@'表示前面的输入无效

                   来看实现方式吧           

public static String lineEdit(String input) {
Stack<Character> myStack = new ArrayStack<Character>();
char[] arr = input.toCharArray();
for (char c : arr) {
if (c == '#') {
myStack.pop();
} else if (c == '@') {
myStack.clear();
} else {
myStack.push(c);
}
}

return myStack.toString();
}

                 测试代码：

public static void main(String[] args) {
System.out.println(conversion(10, 2));
System.out.println(lineEdit("你好!#你好啊@哈哈"));
}

                 输出结果：

                          


           

             4、中缀表达式转后缀表达式

                        Tips：后缀表示具有一个优点：没有必要知道各个运算符号的优先级情况。

private static String infixToSuffix(String infix) {
Stack< Character> stack = new Stack< Character>();
String suffix = "";
int length = infix.length();
for (int i = 0; i < length; i++) {
Character temp;
char c = infix.charAt(i);
switch (c) {
// 忽略空格
case ' ':
break;
// 碰到'('，push到栈
case '(':
stack.push(c);
break;
// 碰到'+''-'，将栈中所有运算符弹出，送到输出队列中
case '+':
case '-':
while (stack.size() != 0) {
temp = stack.pop();
if (temp == '(') {
stack.push('(');
break;
}
suffix += " " + temp;
}
stack.push(c);
suffix += " ";
break;
// 碰到'*''/'，将栈中所有乘除运算符弹出，送到输出队列中
case '*':
case '/':
while (stack.size() != 0) {
temp = stack.pop();
if (temp == '(' || temp == '+' || temp == '-') {
stack.push(temp);
break;
} else {
suffix += " " + temp;
}
}
stack.push(c);
suffix += " ";
break;
// 碰到右括号，将靠近栈顶的第一个左括号上面的运算符全部依次弹出，送至输出队列后，再丢弃左括号
case ')':
while (stack.size() != 0) {
temp = stack.pop();
if (temp == '(')
break;
else
suffix += " " + temp;
}
//suffix += " ";
break;
default:
suffix += c;
}
}
while (stack.size() != 0)
suffix += " " + stack.pop();
return suffix;
}
public static void main(String args[]){
        System.out.println(infixToSuffix("3+(2-5)*6/3"));
         
    }

               结果为：
                       


                以上4中就是栈的基本应用了。