Java实现深度优先遍历和广度优先遍历 （转载复习）

 

内容摘抄自@TingWang7916  手打一遍复习自用

深度优先搜索步骤：
1）节点1进栈，节点1在栈顶

2） 节点1出栈，访问节点1

3）节点1的右孩子3进栈，节点1的左孩子2进栈

4）节点2在栈顶，节点2出栈，访问节点2

5）节点2的右孩子5进栈，左孩子4进栈

6）节点4在栈顶，节点4出栈，访问节点4

7）节点4右左孩子为空，节点5在栈顶，节点5出栈，访问节点5

8）节点5右左孩子为空，节点3在栈顶，节点3出栈，访问节点3

9）节点3右孩子7进栈，节点3左孩子6进栈

10）节点6在栈顶，节点6出栈，访问节点6

11）节点6右左孩子为空，节点7在栈顶，访问节点7

12）节点7右左孩子为空，此时栈为空，遍历结束

 

广度优先遍历：是连通图的一种遍历策略，思路为从v0开始，辐射状地遍历其周围节点，根据广度优先遍历特点用queue来实现

1）节点1进队，节点1在队头，节点1出队，访问节点1

2）节点1的左孩子2进队，节点1的右孩子3进队

3）节点2在队头，节点2出队，访问节点2

4）节点2的左孩子4进队，右孩子5进队

5）节点3在队头，节点3出队，访问节点3

6）节点3的左孩子6进队，节点3的右孩子7进队

7）节点4在队头，节点4出队，访问节点4

8）节点4左右孩子为空，节点5在队头，节点5出队，访问节点5

9）节点5左右孩子为空，节点6在队头，节点6出队，访问节点6

10）节点6左右孩子为控，节点7在队头，节点7出队，访问节点7

11）节点7左右孩子为空，此时队列为空，遍历结束

 

二叉树的基础代码：

// 二叉树数据机构
public class TreeNode {
    int data;
    TreeNode leftNode;
    TreeNode rightNodde;
    public TreeNode(){}
    public TreeNode(int d) {data=d;}
    public TreeNode(TreeNode left,TreeNode right,int d) { 
        leftNode = left;
        rightNode = rigth;
        data = d;
    }
 } 

 

广度优先遍历和深度优先遍历算法实现：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class DeepFirstSort {
    public static void main(String[] args) {
        TreeNode head=new TreeNode(1);
		TreeNode second=new TreeNode(2);
		TreeNode three=new TreeNode(3);
		TreeNode four=new TreeNode(4);
		TreeNode five=new TreeNode(5);
		TreeNode six=new TreeNode(6);
		TreeNode seven=new TreeNode(7);
		head.rightNode=three;
		head.leftNode=second;
		second.rightNode=five;
		second.leftNode=four;
		three.rightNode=seven;
		three.leftNode=six;
		System.out.print("广度优先遍历结果：");
		new DeepFirstSort().BroadFirstSearch(head);
		System.out.println();
		System.out.print("深度优先遍历结果：");
		new DeepFirstSort().depthFirstSearch(head)

        }
        
        public void BroadFirstSearch(TreeNode nodeHead) {
        if(nodeHead == null) return;
        Queue<TreeNode> myQueue = new LinkedList<>();
        myQueue.add(nodeHead);
        while(!myQueue.isEmpty()) {
            TreeNode node = myqueue.poll();
            System.out.pring(node.data + " ");
            
            if(node.leftNode != null) myQueue.add(node.LeftNode);
            if(node.rightNode != null) myQueue.add(node.rightNode);
            }
        }

        public void depthFirstSearch(TreeNode nodeHead) {
            if(nodeHead == null) return;
            Stack<TreeNode> myStack = new Stack<>();
            myStack.add(nodeHead);
            
            while(!myStack.isEmpty()) {
                TreeNode node = myStack.pop();
                System.out.print(node.data + " ");
                if(node.rightNode != null) myStack.push(node.rightNode);
                if(node.leftNode != null) myStack.push(node.leftNode);
                }
            }
    }

预期结果：

广度优先遍历：1 2 3 4 5 6

深度优先遍历：1 2 4 5 3 6 7