二叉树以及前序、中序、后序、层序遍历（JAVA）

最新推荐文章于 2024-08-31 16:54:26 发布
最新推荐文章于 2024-08-31 16:54:26 发布
阅读量315 收藏
点赞数
分类专栏： 学习笔记 文章标签： 数据结构 算法 二叉树 JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cedarjo/article/details/88982277
版权

二叉树

public interface BTree<E> {

    /**
     * 树中的节点个数
     * @return
     */
    int size();

    /**
     * 树是否为空
     * @return
     */
    boolean isEmpty();

    /**
     * 前序遍历
     * 中左右
     */
    void preOrder();

    /**
     * 中序遍历
     * 左中右
     */
    void inOrder();

    /**
     * 后续遍历
     * 左右中
     */
    void postOrder();

    /**
     * 层序遍历
     */
    void levelOrder();

    /**
     *       A
     *     /  \
     *   B    C
     *  / \  / \
     * D  E F  G
     *
     * 前序遍历结果：A-B-D-E-C-F-G
     * 中序遍历结果：D-B-E-A-F-C-G
     * 后序遍历结果：D-E-B-F-G-C-A
     * 层序遍历结果：A-B-C-D-E-F-G
     */

}

基于数组：顺序二叉树
基于链表：链式二叉树

顺序二叉树

  1. 根节点存储在index = 1
  2. 某节点存储在index = i，那么其左子节点将存储在index = 2*i，其右子节点将存储在index = 2*i + 1，其父节点将存储在index = i/2
import java.util.LinkedList;
import java.util.Queue;

public class ArrayBTree<E> implements BTree<E> {

    private E[] array;

    /**
     * 暂时不考虑扩展性，这里基于数组的二叉树是配角
     * 等它成主角了再改
     */
    public ArrayBTree() {
        array = (E[]) new Object[10];
    }

    public ArrayBTree<String> testBTree() {
        /**
         *            A
         *          B   C
         *       D  E  F  G
         */
        ArrayBTree<String> btree = new ArrayBTree<>();
        String[] arr = {"A", "B", "C", "D", "E", "F", "G"};
        for (int i = 0; i < arr.length; i++) {
            Object[] array = btree.array;
            array[i + 1] = arr[i];
        }
        return btree;
    }

    @Override
    public int size() {
        return array.length - 1;
    }

    @Override
    public boolean isEmpty() {
        return size() == 0;
    }

    private int parentIndex(int sonIndex) {
        return sonIndex >> 1;
    }

    private int leftIndex(int parentIndex) {
        return parentIndex << 1;
    }

    private int rightIndex(int parentIndex) {
        return leftIndex(parentIndex) + 1;
    }

    @Override
    public void preOrder() {
        preOrder(1);
    }

    private void preOrder(int index) {
        if (index > size() || array[index] == null) {
            return;
        }

        int left = leftIndex(index);
        int right = rightIndex(index);
        System.out.println(array[index]);
        preOrder(left);
        preOrder(right);
    }

    @Override
    public void inOrder() {
        inOrder(1);
    }

    private void inOrder(int index) {
        if (index > size() || array[index] == null) {
            return;
        }

        int left = leftIndex(index);
        int right = rightIndex(index);
        inOrder(left);
        System.out.println(array[index]);
        inOrder(right);
    }

    @Override
    public void postOrder() {
        postOrder(1);
    }

    private void postOrder(int index) {
        if (index > size() || array[index] == null) {
            return;
        }

        int left = leftIndex(index);
        int right = rightIndex(index);
        postOrder(left);
        postOrder(right);
        System.out.println(array[index]);
    }

    /**
     * 层序遍历
     */
    @Override
    public void levelOrder() {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        while (!queue.isEmpty()) {
            Integer poll = queue.poll();
            System.out.println(array[poll]);

            int left = leftIndex(poll);
            if (left < array.length && array[left] != null) {
                queue.add(left);
            }

            int right = rightIndex(poll);
            if (right < array.length && array[right] != null) {
                queue.add(right);
            }
        }
    }

    public static void main(String[] args) {
        ArrayBTree<String> bTree = new ArrayBTree<>();
        bTree = bTree.testBTree();
        System.out.println("preOrder");
        bTree.preOrder();
        System.out.println("inOrder");
        bTree.inOrder();
        System.out.println("postOrder");
        bTree.postOrder();
        System.out.println("levelOrder");
        bTree.levelOrder();
    }

}

链式二叉树

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

public class LinkedBTree<E> implements BTree<E> {

    private class Node<E> {
        public E val;
        public Node<E> left, right;

        public Node(E e) {
            val = e;
            left = right = null;
        }
    }

    private Node<E> root;
    private int size;

    public LinkedBTree() {
        root = null;
        size = 0;
    }

    public LinkedBTree<String> testBTree() {
        /**
         *            A
         *          B   C
         *       D  E  F  G
         */
        LinkedBTree<String> btree = new LinkedBTree<>();
        btree.root = btree.new Node<String>("A");
        btree.root.left = btree.new Node<String>("B");
        btree.root.right = btree.new Node<String>("C");
        btree.root.left.left = btree.new Node<String>("D");
        btree.root.left.right = btree.new Node<String>("E");
        btree.root.right.left = btree.new Node<String>("F");
        btree.root.right.right = btree.new Node<String>("G");

        btree.size = 7;

        return btree;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void preOrder() {
        preOrder(root);
    }

    private void preOrder(Node<E> node) {
        if (node == null) {
            return;
        }

        System.out.println(node.val);
        preOrder(node.left);
        preOrder(node.right);
    }

    @Override
    public void inOrder() {
        inOrder(root);
    }

    private void inOrder(Node<E> node) {
        if (node == null) {
            return;
        }

        inOrder(node.left);
        System.out.println(node.val);
        inOrder(node.right);
    }

    @Override
    public void postOrder() {
        postOrder(root);
    }

    private void postOrder(Node<E> node) {
        if (node == null) {
            return;
        }

        postOrder(node.left);
        postOrder(node.right);
        System.out.println(node.val);
    }

    /**
     * 层序遍历
     */
    @Override
    public void levelOrder() {
        Queue<Node<E>> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node<E> poll = queue.poll();
            System.out.println(poll.val);

            if (poll.left != null) {
                queue.add(poll.left);
            }

            if (poll.right != null) {
                queue.add(poll.right);
            }
        }
    }

    public static void main(String[] args) {
        LinkedBTree<String> bTree = new LinkedBTree<>();
        bTree = bTree.testBTree();
        System.out.println("preOrder");
        bTree.preOrder();
        System.out.println("inOrder");
        bTree.inOrder();
        System.out.println("postOrder");
        bTree.postOrder();
        System.out.println("levelOrder");
        bTree.levelOrder();
    }

}

前序遍历、中序遍历、后续遍历中的前中后是针对当前节点而言的，当前节点先输出就是前序遍历（中左右），当前节点后输出就是后续遍历（左右中）

前序、中序、后序遍历的非递归实现

这里的非递归实现针对底层是链表的二叉树

前序遍历

/**
 * 前序遍历非递归实现
 */
public void preOrderNonRecursive() {
    Stack<Node> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        Node cur = stack.pop();
        System.out.println(cur.val);
        if (cur.right != null) {
            stack.push(cur.right);
        }
        if (cur.left != null) {
            stack.push(cur.left);
        }
    }
}

中序遍历

/**
 * 中序遍历非递归实现
 */
public void inOrderNonRecursive() {
    Stack<Node> stack = new Stack<>();

    Node cur = root;
    while (cur != null || !stack.isEmpty()) {
        while (cur != null) {
            stack.push(cur);
            cur = cur.left;
        }

        if (!stack.isEmpty()) {
            Node pop = stack.pop();
            System.out.println(pop.val);
            cur = pop.right;
        }
    }
}

上述代码等价于

/**
 * 中序遍历非递归实现
 */
public void inOrderNonRecursive() {
    Stack<Node> stack = new Stack<>();

    Node cur = root;
    while (cur != null || !stack.isEmpty()) {
        if (cur != null) {
            stack.push(cur);
            cur = cur.left;
        } else {
            Node pop = stack.pop();
            System.out.println(pop.val);
            cur = pop.right;
        }
    }
}

后序遍历

/**
 * 后序遍历非递归实现
 */
public void postOrderNonRecursive() {
    Stack<Node> stack = new Stack<>();
    Set<Node> rightFlags = new HashSet<>();

    Node cur = root;
    while (cur != null || !stack.isEmpty()) {
        while (cur != null) {
            stack.push(cur);
            cur = cur.left;
        }

        if (!stack.isEmpty()) {
            Node pop = stack.peek();
            if (rightFlags.contains(pop)) {
                // 如果访问过当前节点的右子树，直接打印
                stack.pop();
                System.out.println(pop.val);
                rightFlags.remove(pop);
            } else {
                // 如果没访问过当前节点的右子树，将cur赋值给右子树
                rightFlags.add(pop);
                cur = pop.right;
            }
        }
    }
}

双栈法

/**
 * 后序遍历非递归实现
 */
public void postOrderNonRecursive() {
    Stack<Node> stack1 = new Stack<>();
    Stack<Node> stack2 = new Stack<>();

    stack1.push(root);
    while (!stack1.isEmpty()) {
        Node pop = stack1.pop();
        // 入stack2
        stack2.push(pop);
        // 先左
        if (pop.left != null) {
            stack1.push(pop.left);
        }
        // 再右
        if (pop.right != null) {
            stack1.push(pop.right);
        }
        // 这样等到左右入stack2时，就成了“中-右-左”
        // 最终出stack2时就成了“左-右-中”，即后序遍历
    }

    while (!stack2.isEmpty()) {
        System.out.println(stack2.pop().val);
    }
}

令我眼前一亮的前中后序非递归遍历的实现

定义一个指令类

class Msg {
    static final boolean GO = false;
    static final boolean PRINT = true;
    boolean go; // false表示访问，true表示打印
    Node node;

    Msg(boolean go, Node node) {
        this.go = go;
        this.node = node;
    }
}

前序

public void preOrderNonRecursive2() {
    LinkedList<Msg> stack = new LinkedList<>();
    stack.push(new Msg(Msg.GO, root));

    while (!stack.isEmpty()) {
        Msg pop = stack.pop();
        if (Msg.PRINT == pop.go) {
            System.out.println(pop.node.val);
        } else {
            // 以右左中入栈
            if (pop.node.right != null) {
                stack.push(new Msg(Msg.GO, pop.node.right));
            }
            if (pop.node.left != null) {
                stack.push(new Msg(Msg.GO, pop.node.left));
            }
            stack.push(new Msg(Msg.PRINT, pop.node));
        }
    }
}

中序

public void inOrderNonRecursive2() {
    LinkedList<Msg> stack = new LinkedList<>();
    stack.push(new Msg(Msg.GO, root));

    while (!stack.isEmpty()) {
        Msg pop = stack.pop();
        if (Msg.PRINT == pop.go) {
            System.out.println(pop.node.val);
        } else {
            // 以右中左入栈
            if (pop.node.right != null) {
                stack.push(new Msg(Msg.GO, pop.node.right));
            }
            stack.push(new Msg(Msg.PRINT, pop.node));
            if (pop.node.left != null) {
                stack.push(new Msg(Msg.GO, pop.node.left));
            }
        }
    }
}

后序

public void postOrderNonRecursive2() {
    LinkedList<Msg> stack = new LinkedList<>();
    stack.push(new Msg(Msg.GO, root));

    while (!stack.isEmpty()) {
        Msg pop = stack.pop();
        if (Msg.PRINT == pop.go) {
            System.out.println(pop.node.val);
        } else {
            // 以中右左入栈
            stack.push(new Msg(Msg.PRINT, pop.node));
            if (pop.node.right != null) {
                stack.push(new Msg(Msg.GO, pop.node.right));
            }
            if (pop.node.left != null) {
                stack.push(new Msg(Msg.GO, pop.node.left));
            }
        }
    }
}
晋韩野
关注
专栏目录
二叉树的先序，中序，后序三种遍历方式（Java实现）
whiteBearClimb的博客
01-27 1187
首先了解生成二叉树： Java实现生成二叉树 遍历的思路很简单 （1）先序 先序遍历意思是根节点在最前面，也就是根左右，找到叶子节点后，优先输出根节点即可 private static void frontSearch(TreeNode tree) { // 先序遍历先打印出当前节点的值 System.out.println(tree.getValue()); // 先找左节点 if (!Objects.isNull(tree.getLeftN
二叉树前序遍历、中序遍历、后序遍历、层序遍历简单理解，秒懂
qq_49425839的博客
03-19 906
文章开始前，说一句废话：希望大家对所学能认真好好理解，那样才能自己的东西，理解万岁！ 能到这里我相信大家最少知道二叉树是什么东西了吧，那我们直奔主题； 前序遍历，中序遍历，后序遍历，层序遍历到底是什么 一棵二叉树由根结点、左子树和右子树三部分组成，若规定 D、L、R 分别代表遍历根结点、遍历左子树、遍历右子树，我们开始讨论最常见的三种遍历方式 DLR--前序遍历（根在前，从左往右，一棵树的根永远在左子树前面，左子树又永远在右子树前面 ） LDR--中序遍历（根在中，从左往右，一棵树的左子树永远在根.
Java实现二叉树中序遍历（递归+非递归）
公号：黎杜编程
02-09 9235
一、中序遍历（递归） 实现的思路和前序遍历其实差不多，但是访问的顺序就是：左节点->根节点->右节点，为了节省一些篇幅把节点数设置的少一些，重在大家的理解，话不多说直接上代码： public void inOrderRecur(Node root) { if (root == null) { return; } inOrderRecur(root.left); S...
二叉树的后序遍历
最新发布
qq_65297619的博客
08-31 668
二叉树的后序遍历算法
Java算法--二叉树的中序遍历
QilanAllen的博客
09-29 316
题目： 给定一个二叉树，返回它的中序遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 解法： class Solution { public List<Integer> inorderTraversal(TreeNode root) { List < Inte...
剑指offer--面试题24:二叉搜索树的后序遍历序列--Java实现
酱油的专栏
06-21 1625
题目描述： 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是返回true，否则返回false。假设输入的数组的任意两个数字互不相同。解题思路： 要明确两个概念： 1. 二叉搜索树的特点，就是如果有对任何一个非空结点，假如左子树存在，那么左子树的中任意一个结点都比该根结点小，假如右子树存在，那么右子树中的任何一个节点都比该根结点大。2.二叉树的后序遍历，也就是 左→右→根
二叉树的后序遍历 --java
zkhong07的博客
10-11 233
给定一个二叉树，返回它的 后序 遍历。 利用递归，先递归左节点然后递归右节点，最后访问节点值。 class Solution { public List<Integer> postorderTraversal(TreeNode root) { LinkedList<Integer> list = new LinkedList<Integer&g...
二叉树已知前序中序求后序(超简单)(java)
weixin_41947362的博客
05-22 1337
二叉树已知前序中序求后序(超简单)(java)
用Java描述数据结构之二叉树，前序遍历，中序遍历，后序遍历
qq_46209845的博客
03-24 441
什么是二叉树？ 一棵二叉树是节点的一个有限集合，该集合或者为空，或者是由一个节点加上两棵别称为左子树和右子树的二叉树组成。 根据二叉树的概念，可以知道二叉树有以下两个特点： 1.每个节点最多有两棵子树，即二叉树不存在度大于二的节点。 2.二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。 二叉树的基本形态： 上图给出了几种特殊的二叉树形态，从左往右依次是：空树、只有根节点的二叉树、节点只有左子树、节点只有右子树，一般二叉树都是由上述基本形态结合而成。 两种特殊的二叉树： 满二叉树：一个二
已知二叉树的前序和中序遍历，打印后序遍历
03-26
前序、中序和后序遍历是二叉树三种基本的遍历方式，每种方式都有其特定的访问顺序。这里我们将重点讨论如何在已知二叉树的前序和中序遍历的情况下，通过非递归算法实现后序遍历。 **前序遍历**：根节点 -> 左子树 -...
二叉树的基本遍历方式（前序遍历、中序遍历、后序遍历的递归和循环实现，层序遍历的实现）
weixin_44146570的博客
06-22 990
二叉树的基本遍历方式1 二叉树的概念1.1 二叉树的Java实现2 二叉树的遍历2.1 递归实现二叉树的遍历前序遍历：递归实现中序遍历：递归实现后序遍历：递归实现2.1 循环实现二叉树的遍历前序遍历1：模拟递归的方式前序遍历2：DFS，深度优先算法中序遍历：模拟递归的方式后序遍历2.3 二叉树的层序遍历层序遍历：广度优先遍历 数据结构：二叉树 1 二叉树的概念 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且
java实现二叉树的后序遍历
weixin_45986454的博客
10-22 313
标题：java实现二叉树的后序遍历 /** * 我的二叉树 【后序遍历】 * @author dell * */ public class TestMyTreeB03 { /** * 测试遍历二叉树的后序遍历【先输出节点的值】 * @param p */ public void backorder(IntNode p) { if(p == null) { return ; }else { this.backorder(p.left); this.backo
二叉树中序遍历 java
ddu_lmm的博客
12-28 477
如下提供两大类——递归和栈，实现二叉树的中序遍历。 每一大类都提供多种模式——leetcode答题模式、IDEA运行模式。 其中leetcode答题模式答案可以参考官方，本文将只对该部分简略描述。 一、递归 模式一：leetcode /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; *
二叉树中序遍历 Java
wenjinjie1的博客
11-20 669
二叉树的中序遍历 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 输入：root = [1,null,2,3] 输出：[1,3,2] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1] 输出：[1] 方法：迭代法 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNo
Java 实现 二叉树的 中序遍历
ideal-lingyun
05-22 1091
Java 实现 二叉树的 中序遍历
leetcode 二叉树的后序遍历 java
u010575303的博客
07-13 761
给定一个二叉树，返回它的 后序 遍历。示例:输入: [1,null,2,3] 1 \ 2 / 3 输出: [3,2,1]/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * Tre...
LeetCode-94. 二叉树的中序遍历(java)
**My Coding Family**
03-18 825
金三银四，又到了刷题月。有时间的话，希望大家还是尽量刷起来咯。帮助往往不是直接体现出来的，但会让你对很多东西的底层实现了解的更深刻。
用java实现二叉树的后序遍历（递归和迭代）
m0_57248752的博客
03-29 1925
用java实现二叉树的后序遍历（递归和迭代两种方法），有详细注释以及图解
145.二叉树的后序遍历（java）
m0_37605197的博客
04-07 146
解法一：迭代 中左右的stack输入次序，进行中右左的二叉树模拟从头插入list中，得到一个左右中的list class Solution { public List<Integer> postorderTraversal(TreeNode root) { List<Integer> list=new ArrayList(); S...
JAVA课程设计：二叉树遍历的源代码实现
资源摘要信息:"二叉树遍历方法包括前序遍历、中序遍历、后序遍历以及层序遍历。在本资源中，涉及的源代码是由JAVA编写的，专门用于完成二叉树的遍历操作，并且这些代码可能是某个JAVA课程设计项目的组成部分。通过源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值