栈 深度优先搜索（DFS）

数据结构（后入先出LIFO）

栈【java 源码】

• 其继承自Vector，亦因此Stack属于Collection家族下的一份子，它是单值存储的。

public class Stack<E> extends Vector<E> {
	//序列化id
    private static final long serialVersionUID = 1224463164541339165L;

	//构造器
    public Stack() {
    }

	//入栈
    public E push(E item) {
        this.addElement(item); 
        return item;
    }

	//出栈，需注意此处竟然上锁，表示它若没有这种同步操作，可能会出现线程不安全
    public synchronized E pop() {
        int len = this.size();
        E obj = this.peek();
        this.removeElementAt(len - 1);
        return obj;
    }

	//取栈顶元素
    public synchronized E peek() {
        int len = this.size();
        if (len == 0) {
            throw new EmptyStackException();
        } else {
            return this.elementAt(len - 1);
        }
    }

	//是否为空
    public boolean empty() {
        return this.size() == 0;
    }

	//根据参数，获取其对应位置
    public synchronized int search(Object o) {
        int i = this.lastIndexOf(o);
        return i >= 0 ? this.size() - i : -1;
    }
}

• 执行一个方法都可以说是入栈：系统栈 | 执行完毕方法后可以说是出栈

深度优先搜索（DFS）

思想：不撞南墙不回头，只有遍历到当前路径的最深处才return

• 力扣题-岛屿数量

给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。
岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
此外，你可以假设该网格的四条边均被水包围。

class Solution {
    public int numIslands(char[][] grid) {
        Stack<Integer> stack = new Stack<>();
        int n=grid.length;
        int m=grid[0].length;
        int count=0;
        //双重for循环遍历了每一个坐标
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
            	//若当前坐标内容为1，则说明有一个岛屿，将当前坐标入栈
                if(grid[i][j]=='1'){
                //count为岛屿数量，发现了一个岛屿则+1
                    count++;
                    stack.push(i*m+j); 
                }
				//遍历队列，将发现的岛屿消灭
				//当栈空时，意味着我们将当前坐标所在的岛屿的其中的全部坐标内容变为0，可以说消灭了一个岛屿
                while(!stack.empty()){
                    int y=stack.pop();
                    int x=y/m;
                    y=y%m;
                    grid[x][y]='0';
                    //四个if，判断当前坐标的上下左右位置是否为1
                    //为1则入栈，即相邻土地连成一座岛屿
                    if(x>0 && grid[x-1][y]=='1'){
                        stack.push((x-1)*m+y);
                    }
                    if(x<n-1 && grid[x+1][y]=='1'){
                        stack.push((x+1)*m+y);
                    }
                    if(y>0 && grid[x][y-1]=='1'){
                        stack.push(x*m+y-1);
                    }
                    if(y<m-1 && grid[x][y+1]=='1'){
                        stack.push(x*m+y+1);
                    }
                }
            }
        }
        return count;
    }
}

• 分析
• 首先双重循环将所有节点遍历一遍
• 第二若找到为1的节点，将该节点位置入栈
• 第三接着while循环，结束条件为栈空。
• 在while循环中，我们进行出栈操作，将该节点置为0，另外每出栈一个元素我们就扫描该节点四周位置，将节点为0的节点位置入栈。（此处看着像是广度优先搜索-》将相邻节点入栈，但我们需考虑到我们使用的是栈这个数据结构，该数据结构是后入先出的，因此实际上，我们会先把某一方向的最深处探索完，才会探索其他方向，此为深度优先搜索）
• 其中的i*m+j请先阅读笔者的队列BFS博客中的补充部分
• ok，以上使用java中Stack作为栈，接下来我们使用系统栈来解决问题，其实就是递归和递推，执行用时比上面的那种方法快很多。

class Solution {
    int n,m;
    public int numIslands(char[][] grid) {
        n=grid.length;
        m=grid[0].length;;
        int count=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(grid[i][j]=='1'){
                    count++;
                    dfs(i*m+j,grid);
                }
            }
        }
        return count;
    }
    public void dfs(int num,char[][] grid) {
        int i=num/m;
        int j=num%m;
        grid[i][j]='0';
        if(i>0 && grid[i-1][j]=='1') dfs((i-1)*m+j, grid);
        if(i<n-1 && grid[i+1][j]=='1') dfs((i+1)*m+j, grid);
        if(j>0 && grid[i][j-1]=='1') dfs(i*m+j-1, grid);
        if(j<m-1 && grid[i][j+1]=='1') dfs(i*m+j+1, grid);
    }
}