二叉树的遍历

1.构建一棵二叉树

private static class TreeNode{
    int data;
    TreeNode leftChild;
    TreeNode rightChild;
    
    TreeNode(int data){
        this.data = data;
    }
}
public static TreeNode createBinaryTree(LinkedList<Integer> list){
	Treenode node = null;
    if(list == null || list.isEmpty()){
        return null;
    }
    Integer data = list.removeFirst();
    if(data != null){
        node = TreeNode(node);
        node.leftChild = createBinaryTree(list);
        node.rightChild = createBinaryTree(list);
    }
    return node;
}

2.二叉树的遍历

2.1递归方式实现

2.1.1前序遍历

#前序遍历遵循：根节点——左节点——右节点

public static void preOrderTranveral(TreeNode node){
	if(node == null){
        return ;
    }
    System.out.pritnln(node.data);
    preOrderTranveral(node.leftChild);
    preOrderTranveral(node.rightChild);
}

2.1.2中序遍历

#中序遍历遵循：左节点——根节点——右节点

public static void inOrderTranveral(TreeNode node){
	if(node == null){
        return ;
    }
    inOrderTranveral(node.leftChild);
    System.out.println(node.data);
    inOrderTranveral(node.rightChild);
}

2.1.3后序遍历

#后序遍历遵循：左节点——右节点——根节点

public static void postOrderTranveral(TreeNode node){
    if(node == null){
        return ;
    }
    postOrderTranveral(node.leftChild);
    postOrderTranveral(node.rightChild);
    System.out.println(node.data);
}

2.2.4 测试main方法

public static void main(String[] args){
        Integer[] integers = {3, 2, 9, null, null, 10, null, null, 8, null, 4};
        LinkedList<Integer> linkedList = new LinkedList<>(Arrays.asList(integers));
        TreeNode treeNode = createBinaryTree(linkedList);
        System.out.println("前序遍历");
        preOrderTraveral(treeNode);
        System.out.println("中序遍历");
        inOrderTraveral(treeNode);
        System.out.println("后序遍历");
        postOrderTraveral(treeNode);
        System.out.println("层次遍历");
        levelOrderTranversal(treeNode);
    }

2.2非递归方式实现

2.2.1前序遍历

public static void preOrderTranveralWithStack(TreeNode root){
    Stack<TreeNode> stack = new Stack<TreeNode>();
    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;
        }
    }
}

2.2.2中序遍历

public static void inOrderTranveralWithStack(TreeNode node){
    TreeNode current = node;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    while(stack != null || !stack.isEmpty()){
        while(current != null){
            stack.push(current);
            current = current.leftChild;
        }
        if(!stack.isEmpty()){
            current = stack.pop();
            System.out.println(curent.data);
            current = current.rightChild;
        }
    }
}

2.2.3后序遍历

public static void postOrderTranveralWithStack(TreeNode node){
		Stack<BinaryNode> stack1 = new Stack<>();
        Stack<Integer> stack2 = new Stack<>();
        int i = 1;
        while(node != null || !stack1.empty())
        {
            while (node != null)
            {
                stack1.push(node);
                stack2.push(0);
                node = node.left;
            }

            while(!stack1.empty() && stack2.peek() == i)
            {
                stack2.pop();
                System.out.print(stack1.pop().element + "   ");
            }

            if(!stack1.empty())
            {
                stack2.pop();
                stack2.push(1);
                node = stack1.peek();
                node = node.right;
            }
        }
}

2.2.4层序遍历

public static void levelOrderTranversalWithQueue(TreeNode root){
    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    queue.offer(root);
    while(!queue.isEmpty()){
        TreeNode node = queue.poll();
        System.out.println(node.data);
        if(node.leftChild != null){
            queue.offer(node.leftChild);
        }
        if(node.rightChild != null){
            queue.offer(node.rightChild);
        }
    }
}

2.2.5 测试main方法

public static void main(String[] args){

        TreeNode t1 = new TreeNode('a');
        TreeNode t2 = new TreeNode('b');
        TreeNode t3 = new TreeNode('c');
        TreeNode t4 = new TreeNode('d');
        TreeNode t5 = new TreeNode('e');
        t1.leftChild = t2;
        t1.rightChild = t3;
        t2.leftChild = t4;
        t2.rightChild = t5;
        System.out.println("前序遍历");
        preOrderTraveralWithStack(t1);
        System.out.println("中序遍历");
        inOrderTranveralWithStack(t1);
        System.out.println("后序遍历");
        postOrderTranveralWithStack(t1);
        System.out.println("层次遍历");
        levelOrderTrversalWithQueue(t1);
    }