卜若的代码笔记-数据结构系列-第十五章：栈的经典应用.深度优先搜索

1.这是在Leetcode上的一道题，我们去看一下它的题目

实现过程比较简单，因为代码会在LeetCode里面提交，我们就不用自己的写的栈和链表了，我们学习使用一下Java的内部栈对象和动态数组 

以下代码是通过LeetCode测试的代码。

/*
 * @lc app=leetcode.cn id=1020 lang=java
 *
 * [1020] 飞地的数量
 */

// @lc code=start
class Solution {
    public int numEnclaves(int[][] A) {
        

                FlyLandProblem fs = new FlyLandProblem(A);
            int sum = fs.dfs();

       
            return sum;
    }

   

}
interface Element {


    Element getNext();
    void setNext(Element t);
    T getValue();
    void setValue(T t);

}
interface IVector2Element extends Element {

    int getX();
    int getY();
    IVector2Element last();
    void setLast(IVector2Element t);

}

class Vector2 implements IVector2Element {

    Element last;
    Element next;

    int x;
    int y;
    T value;
    public Vector2(int x,int y,T value){

        this.x  = x;
        this.y = y;
        this.value = value;
    }
    @Override
    public int getX() {
        return x;
    }

    @Override
    public int getY() {
        return y;
    }

    @Override
    public IVector2Element last() {
        return (IVector2Element)last;
    }

    @Override
    public void setLast(IVector2Element t) {
        last  = t;
    }

    @Override
    public Element getNext() {
        return  (IVector2Element)next;
    }

    @Override
    public void setNext(Element t) {
        this.next = t;
    }

    @Override
    public T getValue() {
        return this.getValue();
    }

    @Override
    public void setValue(T t) {
        this.value = t;
    }

}
class FlyLandElement extends Vector2 {


    public FlyLandElement(int x, int y, Integer value) {
        super(x, y, value);
        statu = false;
    }
    public boolean statu;
    public boolean isBorder(int w,int h){

        if (x ==0){
          return true;
        }
        if (x==w-1){

            return true;
        }
        if (y == 0){

            return true;
        }
        if (y==h-1){

           return true;
        }
        return false;
    }

     public ArrayList nextDirArray(int[][] data, int[][] label, int w, int h){

        ArrayList tt = new ArrayList<>();
        if (x - 1>=0){

            if (data[x-1][y] == 1&&label[x-1][y]!= 100){

                FlyLandElement tl =  new FlyLandElement(x-1,y,data[x-1][y]);
                tl.setLast(this);
                tt.add(tl);
            }


        }
        if (x+1=0){
            if (data[x][y-1] == 1&&label[x][y-1]!= 100){
                FlyLandElement tl =  new FlyLandElement(x,y-1,data[x][y-1]);
                tl.setLast(this);
                tt.add(tl);
            }

        }

        if (y+1 ost ;

    public FlyLandProblem(int[][] data) {
        this.data = data;
        h = data.length;
        w = data[0].length;
        label = new int[h][w];


        ost = new Stack<>();
        endData = new int[h][w];
        for (int i =0;i0){

            FlyLandElement fe = ost.pop();

            if (label[fe.getX()][fe.getY()] == 100){
                continue;
            }
            label[fe.getX()][fe.getY()] = 100;
            ArrayList nextPoint = fe.nextDirArray(data,label,w,h);

            for (int i =0;i"+se.getY());
        for (int i =0;i

这个是LeetCode的性能评价。

我感觉我创造了一个记录，这个记录不是很妙，哈哈~

 

实现思路其实相当简单：

获取所有边缘的地，往里面搜，对所有能够搜索到的路径标记为可通过，最后返回无法搜索的地的数量。

这就是栈的深度优先的魅力。

当然，为什么我会使用那么多的内存，核心因素在于，我在实现这个算法的过程中，每一条路径都会产生一个新的节点，这样其实不是很好，节点多了，那么内存就多了。

哈哈~