算法005：二叉树遍历：深度优先

题目：
二叉树，深度优先遍历：结果1 2 4 5 3 6 7 

思路：
使用栈数据结构实现
1 先节点 1 进栈，节点1在栈顶
2 节点1出栈，访问节点1，节点1的孩子节点3进栈，节点2进栈
3 节点2在栈顶，然后节点2出栈，访问节点2
4 节点2的孩子节点5进栈，节点4进栈
5 节点4在栈顶，节点4出栈，访问节点4
6 节点4左右孩子为空，然后节点5在栈顶，节点5出栈，访问节点5
7 节点5左右孩子为空，然后节点3在站顶，节点3出栈，访问节点3
8 节点3的孩子节点7进栈，节点6进
9 节点6在栈顶，节点6出栈，访问节点6
10 节点6的孩子为空，这个时候节点7在栈顶，节点7出栈，访问节点
11 节点7的左右孩子为空，此时栈为空，遍历结束

1.代码如下：

1.1TreeNode .java

package com.yuhl.right.tree1;

/**
 * @author yuhl
 * @Date 2020/10/24 21:20
 * @Classname TreeNode
 * @Description 二叉树的数据结构
 * 数据、左节点、右节点
 */
public class TreeNode {
    int data;
    TreeNode leftNode;
    TreeNode rightNode;
    public TreeNode() {

    }
    public TreeNode(int d) {
        data=d;
    }

    public TreeNode(TreeNode left,int d,TreeNode right) {
        leftNode=left;
        rightNode=right;
        data=d;
    }
}

1.2TreeNodeTest2.java

package com.yuhl.right.tree1;

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

/**
 * @author yuhl
 * @Date 2020/10/24 21:28
 * @Classname TreeNodeTest
 * @Description 深度优先
 * 1 先节点 1 进栈，节点1在栈顶；
 * 2 节点1出栈，访问节点1，节点1的孩子节点3进栈，节点2进栈；
 * 3 节点2在栈顶，然后节点2出栈，访问节点2
 * 4 节点2的孩子节点5进栈，节点4进栈
 * 5 节点4在栈顶，节点4出栈，访问节点4，
 * 6 节点4左右孩子为空，然后节点5在栈顶，节点5出栈，访问节点5；
 * 7 节点5左右孩子为空，然后节点3在站顶，节点3出栈，访问节点3；
 * 8 节点3的孩子节点7进栈，节点6进栈
 * 9 节点6在栈顶，节点6出栈，访问节点6；
 * 10 节点6的孩子为空，这个时候节点7在栈顶，节点7出栈，访问节点7
 * 11 节点7的左右孩子为空，此时栈为空，遍历结束。
 */
public class TreeNodeTest2 {

    public static void main(String[] args) {
        TreeNode node7=new TreeNode(7);
        TreeNode node6=new TreeNode(6);
        TreeNode node5=new TreeNode(5);
        TreeNode node4=new TreeNode(4);
        TreeNode node3=new TreeNode(node6,3,node7);
        TreeNode node2=new TreeNode(node4,2,node5);
        TreeNode head=new TreeNode(node2,1,node3);

        System.out.print("深度优先遍历结果：");
        depthFirstSearch(head);
    }

    /**
     *  广度优先遍历是使用队列实现的LinkedList 是Queue的子类
     */


    //深度优先：使用栈的数据结构先进先出
    public static 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);
            }
        }

    }
}

2.执行结果：

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