第四章 栈与队列3 （堆栈的应用）

4.3 堆栈的应用

4.3.1 进制转换

十进制转成8进制：

package com.datastructure.chapter04.demo;

import com.datastructure.chapter04.impl.StackSLinked;
import com.datastructure.chapter04.interfaces.Stack;

public class ApplicationOfStack {

    
    
    /** 
     * @Title: baseConversion 
     * @Description:  
     * 10进制转成8进制：每次对十进制数求余后的结果接着求余，余数的逆序就是8进制数
     *  2007/8=250余7
     *  250/8=31余2
     *  31/8=3余7
     *  3/8=0余3
     * 所以8进制结果3727
     * @param @param i
     * @param @return  
     * @return Stack   
     * @throws 
     */
    public Stack baseConversion(int i){
        Stack s = new StackSLinked();
        while(i>0){
            s.push(i%8+"");
            i=i/8;
        }
        return s;
    }
    
    public static void main(String[] args) {
        
        ApplicationOfStack app = new ApplicationOfStack();
        Stack stack = app.baseConversion(2007);
        //输出3727
        while(!stack.isEmpty()){
            System.out.print(stack.pop());
        }
        
    }
    
    
}

4.3.2 括号匹配检测

package com.datastructure.chapter04.demo;

import com.datastructure.chapter04.impl.StackSLinked;
import com.datastructure.chapter04.interfaces.Stack;

public class ApplicationOfStack {

    
    
    /** 
     * @Title: baseConversion 
     * @Description:  
     * 10进制转成8进制：每次对十进制数求余后的结果接着求余，余数的逆序就是8进制数
     *  2007/8=250余7
     *  250/8=31余2
     *  31/8=3余7
     *  3/8=0余3
     * 所以8进制结果3727
     * @param @param i
     * @param @return  
     * @return Stack   
     * @throws 
     */
    public Stack baseConversion(int i){
        Stack s = new StackSLinked();
        while(i>0){
            s.push(i%8+"");
            i=i/8;
        }
        return s;
    }
    
    /** 
     * @Title: bracketMatch 
     * @Description: 括号匹配检测 
     * @param @param str
     * @param @return  
     * @return boolean   
     * @throws 
     */
    public boolean bracketMatch(String str){
        StackSLinked s = new StackSLinked();
        
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            switch(c){
            case '{':
            case '[':
            case '(':
                s.push(Integer.valueOf(c));
                break;
            case '}'://当遇到'}'它的时候，那么栈顶元素必然是'{'与之对应，否则就是非法的
                if(!s.isEmpty() && ((Integer)s.pop()).intValue() == '{')
                    break;
                else
                    return false;
            case ']'://当遇到']'它的时候，那么栈顶元素必然是'['与之对应，否则就是非法的
                if(!s.isEmpty() && ((Integer)s.pop()).intValue() == '[')
                    break;
                else
                    return false;
            case ')'://当遇到')'它的时候，那么栈顶元素必然是'('与之对应，否则就是非法的
                if(!s.isEmpty() && ((Integer)s.pop()).intValue() == '(')
                    break;
                else
                    return false;
            }
        }
        
        if(s.isEmpty()) return true;
        return false;
    }
    
    
    public static void main(String[] args) {
        
        ApplicationOfStack app = new ApplicationOfStack();
        // Stack stack = app.baseConversion(2007);
        // //输出3727
        // while(!stack.isEmpty()){
        // System.out.print(stack.pop());
        // }
        
        System.out.println(app.bracketMatch("[{()}]"));//true
        
    }
    
    
}

 4.3.3 迷宫求解

每个单元格类Cell以及解法：

package com.datastructure.chapter04.demo;

import com.datastructure.chapter04.impl.StackSLinked;
import com.datastructure.chapter04.interfaces.Stack;

/** 
 * @ClassName: Cell 
 * @Description:每个单元格 
 * @author 
 * @date 2018年3月17日 下午10:50:56 
 *  
 */
public class Cell {
    
    int x = 0;//单元所在行
    
    int y = 0;//单元所在列
    
    boolean visited = false;//是否访问过
    
    char c = ' ';//是墙('1')、可通路('0')或期待到终点的路径
    
    public Cell(){}
    
    public Cell(int x,int y,char c,boolean visited) {
        this.x = x; this.y = y;
        this.c = c; this.visited = visited;
    }
    
    
    public void mazeExit(char[][] maze,int sx,int sy,int ex,int ey){
        
        Cell[][] cells = createMaze(maze);//创建初始化迷宫;
        printMaze(cells);//打印迷宫
        
        Stack stack = new StackSLinked();//构造堆栈
        
        Cell startCell = cells[sx][sy];
        Cell endCell = cells[ex][ey];
        
        stack.push(startCell);//起点入栈
        
        startCell.visited = true;
        
        while(!stack.isEmpty()){
            Cell current = (Cell) stack.peek();
            
            if(current == endCell){//路径找到
                while(!stack.isEmpty()){
                    Cell cell = (Cell) stack.pop();//沿着原路返回，将路径上的单元设置为*
                    cell.c = '*';
                    //堆栈中与cell相邻的单元才是路径的组成部分，除此之外
                    //堆栈中还有记录下来但是未继续向下探索的单元，
                    //这些单元直接出栈
                    while(!stack.isEmpty() && !isAdjoinCell((Cell)stack.peek(),cell))
                        stack.pop();
                    
                }
                System.out.println("找到从起点到终点的路劲.");
                printMaze(cells);
                return ;
            } else {//如果当前位置不是终点
                int x = current.x;
                int y = current.y;
                int count = 0;
                if(isValidWayCell(cells[x+1][y])){//向下
                    stack.push(cells[x+1][y]);
                    cells[x+1][y].visited = true;
                    count++;
                }
                
                if(isValidWayCell(cells[x][y+1])){//向右
                    stack.push(cells[x][y+1]);
                    cells[x][y+1].visited = true;
                    count++;
                }
                
                if(isValidWayCell(cells[x-1][y])){//向上
                    stack.push(cells[x-1][y]);
                    cells[x-1][y].visited = true;
                    count++;
                }
                
                if(isValidWayCell(cells[x][y-1])){//向左
                    stack.push(cells[x][y-1]);
                    cells[x][y-1].visited = true;
                    count++;
                }
                if(count == 0) stack.pop();//如果是死点，出栈
            }
        }
        System.out.println("没有从起点到终点的路径");
    }


    /** 
     * @Title: isValidWayCell 
     * @Description: 判断这个单元格是不是墙，是不是已经入栈过的
     * @param @param cell
     * @param @return  
     * @return boolean   
     * @throws 
     */
    private boolean isValidWayCell(Cell cell) {
        return cell.c=='0' && !cell.visited;
    }

    /** 
     * @Title: isAdjoinCell 
     * @Description:  判断是否是相邻的单元格
     * @param @param peek
     * @param @param cell
     * @param @return  
     * @return boolean   
     * @throws 
     */
    private boolean isAdjoinCell(Cell cell1, Cell cell2) {
        
        if(cell1.x == cell2.x && Math.abs(cell1.y-cell2.y)<2) return true;
        if(cell1.y == cell2.y && Math.abs(cell1.x-cell2.x)<2) return true;
        
        return false;
    }

    private void printMaze(Cell[][] cells) {
        for (int x = 0; x < cells.length; x++) {
            for (int y = 0; y < cells[x].length; y++) {
                System.out.print(cells[x][y].c);
            }
            System.out.println();
        }
    }


    private Cell[][] createMaze(char[][] maze) {
        
        Cell[][] cells = new Cell[maze.length][];
        for (int x = 0; x < maze.length; x++) {
            char[] row = maze[x];
            cells[x] = new Cell[row.length];
            for(int y=0;y<row.length;y++)
                cells[x][y] = new Cell(x,y,maze[x][y],false);
        }
        return cells;
    }
    
    
    public static void main(String[] args) {
        Cell cell = new Cell();
        
        char[][] maze = {
                {'1','1','1','1','1','1','1','1','1','1'},
                {'1','0','0','1','1','1','0','0','1','1'},
                {'1','0','0','1','1','0','0','1','0','1'},
                {'1','0','0','0','0','0','0','1','0','1'},
                {'1','0','0','0','0','1','1','0','0','1'},
                {'1','0','0','1','1','0','0','1','0','1'},
                {'1','0','0','0','0','1','0','1','0','1'},
                {'1','0','1','1','0','0','0','1','0','1'},
                {'1','1','0','0','0','0','1','0','0','1'},
                {'1','1','1','1','1','1','1','1','1','1'},
        };
        cell.mazeExit(maze , 1, 7, 3, 1);
        
    }
}

结果：