栈的经典应用

        前言

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

              应用。

        栈的应用举例

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

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

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

                    http://blog.youkuaiyun.com/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中就是栈的基本应用了。