树的创建和遍历（java）

二叉树层次遍历，利用队列

class Solution {
    List<List<Integer>> list = new ArrayList<>();
    Queue<TreeNode> queue = new LinkedList<>();
    //记录本层有多少个元素
    int curNum = 0;

    public List<List<Integer>> levelOrder(TreeNode root) {
        //最开始加入第一个节点
        if(root != null) queue.offer(root);
        
        //队列不为空就需要一直遍历出队列 直到全部出队
        while(!queue.isEmpty()) {
            curNum = queue.size();
            List<Integer> subList = new ArrayList<>();
           //遍历本层的元素个数 为次数
            while(curNum-- > 0) {
                //每轮出一个 进两个
                TreeNode tempNode = queue.poll();
                subList.add(tempNode.val);

                if(tempNode.left != null){
                    queue.offer(tempNode.left);
                }
                if(tempNode.right != null){
                    queue.offer(tempNode.right);
                }
            }
            list.add(subList);
        }
        return list;
        

    }

}

二查询树前中后序遍历，非递归利用栈

package dataStructure.Tree;


import java.util.Arrays;
import java.util.LinkedList;
import java.util.Stack;

/**
 * @author huangzhenhui
 * @date 2020/11/18 - 16:49
 */
//递归的 深度遍历
public class RecurrenceDeepFist {


    //树的深度
    public static int TreeDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        int leftDepth = TreeDepth(root.leftChild);
        int rightDepth = TreeDepth(root.rightChild);
        return Math.max(leftDepth,rightDepth)+1;
    }

    //根据传入的链表 递归创建 二叉树
    public static TreeNode createBinaryTree(LinkedList<Integer> inputList) {
        TreeNode node = null;//先设为null
        //传进来的是null对象,或者有链表对象但是里面没有元素
        if (inputList == null || inputList.isEmpty()) {
            return null;
        }
        Integer data = inputList.removeFirst();//从此列表中删除 并返回删除前的第一个元素
        if (data != null) {
            node = new TreeNode(data);
            //把当前删掉一个元素的链表继续传进去
            node.leftChild = createBinaryTree(inputList);
            node.rightChild = createBinaryTree(inputList);
        }
        return node;//把树返回
    }
    //递归的前序遍历，传入根节点（此时根节点已经是整棵树了）
    public static void PreOrderTraveral(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.println(node.data);
        PreOrderTraveral(node.leftChild);
        PreOrderTraveral(node.rightChild);
    }
    //递归中序
    public static  void  MidOrderTraveral(TreeNode node){
        if (node == null){
            return;
        }
        MidOrderTraveral(node.leftChild);
        System.out.println(node.data);
        MidOrderTraveral(node.rightChild);
    }
    //递归后序
    public static  void  LatOrderTraveral(TreeNode node){
        if (node == null){
            return;
        }
        LatOrderTraveral(node.leftChild);
        LatOrderTraveral(node.rightChild);
        System.out.println(node.data);
    }

    //非递归前序（利用栈）
    public static void preOrderTraveralWithStack(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = root;
        while (treeNode != null || !stack.isEmpty()){
            //迭代访问左孩子，并入栈
            while (treeNode != null){
                System.out.println(treeNode.data);
                stack.push(treeNode);
                treeNode = treeNode.leftChild;
            }
            if (!stack.isEmpty()){
                treeNode = stack.pop();//删除此堆栈顶部的对象，并将该对象作为此函数的值返回。
                treeNode = treeNode.rightChild;
            }
        }
    }
    //非递归中序（利用栈）
    public static void midOrderTraveralWithStack(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = root;
        while (treeNode != null || !stack.isEmpty()){
            //迭代访问左孩子，并入栈
            while (treeNode != null){
                stack.push(treeNode);
                treeNode = treeNode.leftChild;
            }
            //没有左孩子就当前的节点弹出栈顶，访问右孩子
            if (!stack.isEmpty()){
                treeNode = stack.pop();//删除此栈顶部的对象，并将该对象作为此函数的值返回。
                System.out.println(treeNode.data);//出栈后访问一下
                treeNode = treeNode.rightChild;
            }
        }
    }

    //非递归后序（利用栈）
    public static void latOrderTraveralWithStack(TreeNode root){
        Stack<TreeNode> stack = new Stack<>();
        Stack<TreeNode> markStack = new Stack<>();
        TreeNode treeNode = root;
        while (treeNode != null || !stack.isEmpty()){
            //迭代访问左孩子，并入栈
            while (treeNode != null){
                stack.push(treeNode);
                treeNode = treeNode.leftChild;
            }
            //标记的栈
            while(!markStack.isEmpty()&& markStack.peek()== stack.peek()){
                markStack.pop();
                System.out.println(stack.pop().data);//在这出栈访问
            }
            //没有左孩子就当前的节点弹出栈顶，访问右孩子
            if (!stack.isEmpty()){
                treeNode = stack.peek();
                markStack.push(treeNode);
                treeNode = treeNode.rightChild;
            }
        }
    }
    public static void main(String[] args) {
        LinkedList<Integer> inputList = new LinkedList<>(Arrays.asList(new Integer[]{5,3,2,null,null,4,null,null,7,6,null,null,8,null,null}));
        TreeNode node = createBinaryTree(inputList);
        //前序遍历
        PreOrderTraveral(node);
        System.out.println("=======");
        preOrderTraveralWithStack(node);
        System.out.println("=======");
        //中序
        MidOrderTraveral(node);
        System.out.println("=======");
        midOrderTraveralWithStack(node);
        //后序
        System.out.println("=======");
        LatOrderTraveral(node);
        System.out.println("=======");
        latOrderTraveralWithStack(node);

        //深度
        int i = TreeDepth(node);
        System.out.println("深度 :"+i);



    }
}

或者另一个版本的
//非递归前序（利用栈）
public static void preOrderUnRecur(Node head) {
		System.out.print("pre-order: ");
		if (head != null) {
			Stack<Node> stack = new Stack<Node>();
			stack.add(head);
			while (!stack.isEmpty()) {
				head = stack.pop();
				System.out.print(head.value + " ");
				//先压栈右，再压左，打印时就是头左右
				if (head.right != null) {
					stack.push(head.right);
				}
				if (head.left != null) {
					stack.push(head.left);
				}
			}
		}
		System.out.println();
	}
//非递归中序（利用栈）
	public static void inOrderUnRecur(Node head) {
		System.out.print("in-order: ");
		if (head != null) {
			Stack<Node> stack = new Stack<Node>();
			while (!stack.isEmpty() || head != null) {
				if (head != null) {
					stack.push(head);
					head = head.left;
				} else {
					head = stack.pop();
					System.out.print(head.value + " ");
					head = head.right;
				}
			}
		}
		System.out.println();
	}
//非递归后序（利用栈）
	public static void posOrderUnRecur1(Node head) {
		System.out.print("pos-order: ");
		if (head != null) {
			Stack<Node> s1 = new Stack<Node>();
			Stack<Node> s2 = new Stack<Node>();
			s1.push(head);
			while (!s1.isEmpty()) {
				head = s1.pop();
				s2.push(head);
				//s1入栈时先左再右，出栈时是头右左，放s2后出栈是 左右头（后序）
				if (head.left != null) {
					s1.push(head.left);
				}
				if (head.right != null) {
					s1.push(head.right);
				}
			}
			while (!s2.isEmpty()) {
				System.out.print(s2.pop().value + " ");
			}
		}
		System.out.println();
	}