栈于队列

一：栈

1.栈的应用背景

         栈是一种线性数据结构，并且只能在某一端存数据和取数据。

关键词：先进先出。

2.栈的两种实现方法：

2.1用ArrayList实现栈

具体代码如下：

[java]  view plain copy

1. import java.util.ArrayList;  
2. public class ArrayListAsStack {  
3.     ArrayList stack = new ArrayList();  
4.     public ArrayListAsStack(int n){  
5.        stack.ensureCapacity(n);  
6.     }  
7.     public void push(Object o1){  
8.        stack.add(o1);  
9.     }  
10.     public Object pop(){  
11.        return stack.remove(stack.size()-1);  
12.     }  
13.     public Object topEle(){  
14.        return stack.get(stack.size()-1);  
15.     }  
16.     public boolean isEmpty(){  
17.         
18.        return stack.isEmpty();  
19.     }  
20.     public void clean(){  
21.        stack.clear();  
22.     }  
23. }  

Pop：只用删除ArrayList中的最后一个元素

Push:在ArrayList中添加一个元素

2.2用LinkedList实现栈

代码如下：

[java]  view plain copy

1. import java.util.LinkedList;  
2. public class LinkedListAsStack {  
3.     LinkedList stack = new LinkedList();  
4.     public void push(Object o1){  
5.        stack.add(o1);  
6.     }  
7.     public Object pop(){  
8.        return stack.removeLast();  
9.     }  
10.     public Object topEle(){  
11.        return stack.getLast();  
12.     }  
13.     public boolean isEmpty(){  
14.        return stack.isEmpty();   
15.     }  
16.     public void clean(){  
17.        stack.clear();  
18.     }  
19. }  

Pop：删除链表中最后一个节点

Push：在链表中添加一个节点

二：队列

         队列与栈的不同之处在于，队列的两端都有用到，数据从队列的尾部添加，从队列的头部取出。FIFO原则。

1.队列的实现

         与栈相同，队列可以通过array和linkedlist两种方式实现，在此不再累述。

2.优先队列

         队列的先进先出有时候会有一定的局限性。例如：银行办业务的客户必须按照“先进先出”的性质进行等待办理，但是有的客户持有的是金卡，则应该被有限办理。优先队列则用于处理这类的问题。

即优先队：数据的存入是按照先进先出的方式放进去的，但是存入的数据有对应的优先级，则取出的时候根据优先级取出。

三：用栈实现走迷宫

         老鼠走迷宫是栈的一个典型应用，如下，有一个简单的迷宫（m代表入口，e代表出口，0代表该路行得通，1代表墙）：

1 1 0 0

0 0 0 e

0 0 m 1

思想：老鼠会尝试所有可行的路径（上、下、左、右四个方向），如果碰到了死角，则会返回到最后一步再尝试其他路径，所以上下左右方向的顺序会影响到最后寻找的出路。

实现：

我们将迷宫放在一个二维数组里，由于数组的计数从0开始，我们为了更直观，在初始二维数组周围加上2，如下

1 1 1 1 1 1

1 1 1 0 0 1

1 0 0 0 e 1

1 0 0 m 1 1

1 1 1 1 1 1

这里需要用到栈，将可能走的位置按照一定的规律压入栈中（例如上下左右），例如到了A的位置，则在A的基础上往下走，如果A后面没有可行的路径，则返回至A的上一步。下面详解实现。

（1）构建MazeCell：表示迷宫的位置

[java]  view plain copy

1. public class MazeCell {  
2.     int x;  
3.     int y;  
4.     public MazeCell(){  
5.         
6.     }  
7.     public MazeCell(int a,int b){  
8.        this.x = a;  
9.        this.y = b;  
10.     }  
11.     public Booleanequals(MazeCell cell){  
12.        if(cell.x == this.x&&cell.y==this.y)  
13.            return true;  
14.        else  
15.            return false;  
16.     }  
17. }  

（2）寻找出路的具体实现

[java]  view plain copy

1. public class Maze {  
2.     //构建maze所需的参数  
3.     char[][] maze = new char[5][6];  
4.     char entrance = 'm';  
5.     char exit = 'e';  
6.     char pass= '0';  
7.     char notPass='1';  
8.     char visited = '2';  
9.     //获得maze路径所需参数  
10.     Stack<MazeCell> pushUnvisited = new Stack<MazeCell>();  
11.     MazeCell currentCell = new MazeCell();  
12.     MazeCell exitCell = new MazeCell(2,4);  
13.     MazeCell entryCell = new MazeCell(3,3);  
14.      
15.      public static void main(String[]args){  
16.         Maze maze = new Maze();  
17.         maze.makeMaze();  
18.         maze.getPath();  
19.      }  
20.        
21.      //构造一个maze  
22.      public void makeMaze(){  
23.         //给迷宫外加上1  
24.         for(int i = 0;i<6;i++){  
25.            maze[0][i] =notPass;  
26.            maze[4][i]=notPass;  
27.         }  
28.         for(int j = 0;j<5;j++){  
29.               maze[j][0] =notPass;  
30.               maze[j][5]=notPass;  
31.             }  
32.         maze[1][1] = notPass;  
33.         maze[1][2] =notPass;  
34.         maze[1][3] = pass;  
35.         maze[1][4] = pass;  
36.         maze[2][1] = pass;  
37.         maze[2][2] =pass;  
38.         maze[2][3] = pass;  
39.         maze[2][4] =exit;  
40.         maze[3][1] = pass;  
41.         maze[3][2] =pass;  
42.         maze[3][3] = entrance;  
43.         maze[3][4] =notPass;  
44.      }  
45.        
46.      //寻找走出迷宫的路径  
47.      public void getPath(){  
48.         currentCell = entryCell;  
49.         while(!currentCell.equals(exitCell)){  
50.             int x = currentCell.x;  
51.             int y = currentCell.y;  
52.             //搜索路径为上下左右，不同的顺序会有不同结果  
53.             pushStack(x-1,y);  
54.             pushStack(x+1,y);  
55.             pushStack(x,y-1);  
56.             pushStack(x,y+1);  
57.             //把走过的位置标记成visited  
58.             if(!currentCell.equals(entryCell)){  
59.                 maze[x][y] = visited;  
60.             }  
61.             //如果在还没到达终点，栈就空了，说明该迷宫米有出路  
62.             if(pushUnvisited.isEmpty()){  
63.                System.out.println("failure");  
64.                return;  
65.             }  
66.             //将当前位置往前移  
67.             MazeCell tmp = pushUnvisited.pop();  
68.             currentCell = tmp;  
69.             //输出我走过的节点  
70.             System.out.println(tmp.x+","+tmp.y);  
71.         }  
72.      }  
73.      public void pushStack(int x ,int y){  
74.         //如果是visited或notPass，则不能压进栈  
75.         if(maze[x][y] == pass||maze[x][y]==exit){  
76.             pushUnvisited.push(new MazeCell(x,y));  
77.         }  
78.      }  
79. }