二叉树的四种遍历方式

系列文章目录

历史文章：
平衡二叉树

红黑树

---

前言

本文主要讲述二叉树的几种遍历方式，以及代码实战

一、四种遍历方式

1.前序遍历：先访问根节点，后访问左节点，最后右节点
2.中序遍历：先访问左节点，后访问根节点，最后右节点
3.后续遍历：先访问左节点，后访问右节点，最后根节点
4.层次遍历：一层一层访问，广度优先

总结：前中后序遍历采用DFS思想，即压栈，先进后出，层次遍历需要采用BFS思想，利用队列，先进先出的思想实现

二、代码实战

package com.zg.demo.arithmetic.binarytree;



import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * TreeSort class
 *
 * @author zg
 * @date 2021/3/22 18:04
 *
 * 前序遍历：先访问根节点，后访问左节点，最后右节点
 *
 * 中序遍历：先访问左节点，后访问根节点，最后右节点
 *
 * 后续遍历：先访问左节点，后访问右节点，最后根节点
 *
 * 层次遍历：一层一层访问，广度优先
 */
public class TreeSort {

    /**
     *                    7
     *              /          \
     *            3             9
     *         /    \         /    \
     *        1      5       8      10
     *      /  \    /  \             \
     *     0    2  4    6            11
     * @param args 参数
     */
    public static void main(String[] args) {
        //平衡二叉树
        AVLTree avlTree = new AVLTree();
        for (int i = 0; i < 12; i++) {
            avlTree.insertNode(i);
        }
        printLevel(avlTree.getRoot());
        //红黑树
        RBTree rbTree = new RBTree();
        for (int i = 0; i < 12; i++) {
            rbTree.insertNode(i);
        }
        printLevel(rbTree.getRoot());
    }

    /**
     * 前序遍历
     * @param root 参数
     */
    private static void beforeSort(AVLNode root) {
        System.out.println(root.getValue());
        if (root.getLeftNode() != null) {
            beforeSort(root.getLeftNode());
        }
        if (root.getRightNode() != null) {
            beforeSort(root.getRightNode());
        }
    }

    /**
     * 中序遍历
     * @param root 参数
     */
    private static void centreSort(AVLNode root) {
        if (root.getLeftNode() != null) {
            centreSort(root.getLeftNode());
        }
        System.out.println(root.getValue());
        if (root.getRightNode() != null) {
            centreSort(root.getRightNode());
        }
    }

    /**
     * 后序遍历
     * @param root 参数
     */
    private static void afterSort(AVLNode root) {
        if (root.getLeftNode() != null) {
            afterSort(root.getLeftNode());
        }
        if (root.getRightNode() != null) {
            afterSort(root.getRightNode());
        }
        System.out.println(root.getValue());
    }

    /**
     * 层次遍历
     * @param root 参数
     */
    private static void levelSort(AVLNode root) {
        LinkedBlockingQueue<AVLNode> queue = new LinkedBlockingQueue<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            AVLNode currentNode = queue.poll();
            System.out.println(currentNode.getValue());
            if (currentNode.getLeftNode() != null) {
                queue.add(currentNode.getLeftNode());
            }
            if (currentNode.getRightNode() != null) {
                queue.add(currentNode.getRightNode());
            }
        }
    }


    private static void printLevel(AVLNode root) {
        LinkedBlockingQueue<AVLNode> queue = new LinkedBlockingQueue<>();
        queue.add(root);
        List<List<Integer>> lists = new ArrayList<>();
        lists.add(new ArrayList<>());
        while (!queue.isEmpty()) {
            AVLNode currentNode = queue.poll();
            int level = getLevel(currentNode, 0);
            if (lists.size() == level) {
                lists.add(new ArrayList<>());
            }
            List<Integer> list1 = lists.get(level);
            list1.add(currentNode.getValue());
            if (currentNode.getLeftNode() != null) {
                queue.add(currentNode.getLeftNode());
            }
            if (currentNode.getRightNode() != null) {
                queue.add(currentNode.getRightNode());
            }
        }
        lists.forEach(integers -> {
            integers.forEach(v -> {
                System.out.print(v);
                System.out.print("  ");
            });
            System.out.println();
        });
    }


    private static void printLevel(RBNode root) {
        LinkedBlockingQueue<RBNode> queue = new LinkedBlockingQueue<>();
        queue.add(root);
        List<List<RBNode>> lists = new ArrayList<>();
        lists.add(new ArrayList<>());
        while (!queue.isEmpty()) {
            RBNode currentNode = queue.poll();
            int level = getLevel(currentNode, 0);
            if (lists.size() == level) {
                lists.add(new ArrayList<>());
            }
            List<RBNode> list1 = lists.get(level);
            list1.add(currentNode);
            if (currentNode.getLeftNode() != null) {
                queue.add(currentNode.getLeftNode());
            }
            if (currentNode.getRightNode() != null) {
                queue.add(currentNode.getRightNode());
            }
        }
        lists.forEach(nodes -> {
            nodes.forEach(node -> {
                System.out.print(node.getValue() + "-" + node.isRed());
                System.out.print("  ");
            });
            System.out.println();
        });
    }

    private static int getLevel(RBNode node, Integer level) {
        if (node.getParentNode() != null) {
            return getLevel(node.getParentNode(), ++level);
        }
        return level;
    }

    /**
     * 获取节点所处层数
     * @param node node
     * @return result
     */
    private static int getLevel(AVLNode node, Integer level) {
        if (node.getParentNode() != null) {
            return getLevel(node.getParentNode(), ++level);
        }
        return level;
    }


}