[数据结构]java 队列实现广度优先搜索栈实现深度优先搜索

队列是先入先出的数据结构，栈是后入先出的数据结构，下面直接上代码实现

这个是节点类，是下边两段代码通用的

// 节点类
class Node {
    private String name = "";
    public ArrayList<Node> neighbor = new ArrayList<>();
    public boolean flag = false;

    public Node(String name) {
        this.name = name;
    }

    public void addNeighbor(Node... nodes) {
        if (nodes != null) {
            neighbor.addAll(Arrays.asList(nodes));
        }
    }
    public String getName() {
        return name;
    }
}

// 排列好图的内容
Node a = new Node("A");
Node b = new Node("B");
Node c = new Node("C");
Node d = new Node("D");
Node e = new Node("E");
Node f = new Node("F");
Node g = new Node("G");
Node h = new Node("H");
Node i = new Node("I");

a.addNeighbor(b, f);
b.addNeighbor(a, g, i, c);
c.addNeighbor(b, i, d);
d.addNeighbor(c, i, g, h, e);
e.addNeighbor(d, h, f);
f.addNeighbor(a, g, e);
h.addNeighbor(g, d, e);
i.addNeighbor(b, c, d);

广度优先搜索BFS

主要思路如下：

1. 将头结点入队，更改访问标识
2. 队列如不为空循环队列将临近节点入队并更改访问标识

重点在于循环队列的过程中将节点入队这样可以保证while条件一直满足，一直循环到没有节点为止

// 用队列实现广度优先搜索
    Queue<Node> queue = new LinkedList<>();
    // 将头结点入队
    queue.offer(a);
    // 将头节点访问标识变为true
    a.flag = true;
    // 如果队列不为空
    while (!queue.isEmpty()) {
        // 取出队列中节点
        Node curNode = queue.poll();
        System.out.print(curNode.getName());
        // 遍历队列中节点的临近节点并将临近节点访问标识改为true，并将节点入队
        for (Node temp : curNode.neighbor) {
            if (!temp.flag) {
            	// 将节点入队
                queue.offer(temp);
                temp.flag = true;
            }
        }
    }
    System.out.print("\n");

补充一个队列知识

Queue<Integer> queue=new LinkedList<Integer>();

// 移除队列头元素
queue.remove(); // 如果队列为空，会报 NoSuchElementException 异常
queue.poll();  // 如果队列为空，会返回null

// 添加元素
queue.add(1); // 如果队列满会报unchecked异常
queue.offer(1); // 如果队列满会返回false

// 在不移除的情况下返回队列头
queue.peek(); // 如果队列空，返回null
queue.element(); // 如果队列空，会报 NoSuchElementException 异常

栈实现深度优先搜索 DFS

主要思路：
和队列实现广度优先搜索一样，只是利用栈先入后出的特性

// 用栈实现深度优先搜索
Stack<Node> stack = new Stack<>();
// 头结点入栈
stack.push(a);
// 标记访问过
a.flag = true;
while (!stack.isEmpty()) {
    // 拿到栈顶元素
    Node curNode = stack.pop();
    System.out.print(curNode.getName());
    // 遍历访问栈顶元素的临近节点
    for (Node temp : curNode.neighbor) {
        // 如果结点未被访问过
        if (!temp.flag) {
            // 进行入栈操作
            stack.push(temp);
            temp.flag = true;
        }
    }
}
System.out.println("\n");