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

最新推荐文章于 2024-03-07 22:13:48 发布
最新推荐文章于 2024-03-07 22:13:48 发布
阅读量292 收藏
点赞数
分类专栏： 学习笔记 文章标签： 数据结构 算法 二叉树 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));
            }
        }
    }
}
晋韩野
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java二叉树的前序+中序+后序遍历（修改后）
07-19
二叉树的遍历，全部用递归实现，很有规律！ 二叉树的遍历，全部用递归实现，很有规律
java二叉树的前序+中序+后序遍历
04-15
java实现 二叉树的遍历 前序遍历用到递归， 中序和后序遍历用到栈， 其实还是有一定难度的
【数据结构】用Java实现一棵二叉树
qq_53869058的博客
03-30 3675
这里给出从前序与中序遍历序列构造二叉树、从中序与后序遍历序列构造二叉树以及二叉树的基本操作。
【Java】二叉树
qq_61635026的博客
07-08 1834
二叉树（Binary Tree）是一种常见的树形结构，它由节点（Node）和节点之间的关系构成。每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树中的每个节点可以为空（null）。
【java】后序遍历二叉树
weixin_68266674的博客
03-07 962
else : 如果左节点和右节点都打印了，那么就打印当前节点的值，并且回退到上一个节点（父节点）if:如果左节点不为空并且没有被打印，那么就说明该节点未被调用过，进行递归操作。else if: 判断完左节点就判断右节点，这是后续遍历的操作顺序。//判断当前节点是否已经打印，如果没有就进去判断它的左右节点。//如果父节点为空说明已经遍历完了。//设置左节点的父类。//设置右节点的父类。
二叉树的中序遍历算法(Java三种实现方法)
zengchenAAA的博客
01-03 3446
的
Java语言----二叉树
tq02的博客
05-28 2797
二叉树详细讲解，以及Java实现代码
二叉树（Java版）
WYSCODER的博客
08-04 2792
二叉树，看这一篇就够了~~~
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
主要介绍了Python二叉树的遍历操作,结合实例形式分析了Python针对二叉树的前序遍历,中序遍历,后序遍历,层序遍历等相关操作实现技巧,需要的朋友可以参考下
二叉树遍历-前序中序后序层次遍历
02-28
c++代码，能够根据前序序列、中序序列生成二叉树；能够一步生成，也可以一步步自动生成。 设计前序遍历，中序遍历，后序遍历，层次遍历；
二叉树的遍历，前序遍历 中序遍历 后序遍历
11-11
二叉树的遍历，前序遍历 中序遍历 后序遍历
94. 二叉树的中序遍历(java)
大河的博客
11-11 1992
题目描述 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 首先是递归方法。 访问顺序：先左子树，再根节点，最后右子树； 原理：要先观察最后一个，从后往前进行分析。 随后进入D的右节点，运行inorder(res,root.right);D的右节点为空，函数返回。 到这里当然没结束，会依次返回到B点E点，回到A点。 此时，A的左侧节点已经加入完了，接下来是A的右侧节点。 代码如下 class Solution { public List<Integer> inorderT
用java实现二叉树的中序遍历（递归和迭代）
m0_57248752的博客
03-29 694
用java实现二叉树的中序遍历（递归和迭代）（有图解）
java创建二叉树
蜗牛小将
04-20 7679
最近有人问二叉树问题，这里写点文章记录一下。 如下二叉树，如何用java在代码里创建出来？ 关注这方面的，大概都知道一个二叉树有前序、中序、后序，层序共4种遍历方法。 不清楚的看我的另一篇文章：https://blog.csdn.net/weixin_36939535/article/details/115910919 这里可以用一个数组把来表示上图二叉树：[1, 2, 0, 3, 4, 0, 0, 0, 5, 6, 0, 0, 7, 8, 9, 0, 0, 0, 0] 定义一个树的节点 public
Java二叉树的前中后序遍历
xinhang10的博客
03-19 2188
本文章主要讲解了Java数据结构中何为二叉树的前中后序遍历，并附带了对应的题目，希望大家可以学习到二叉树的一些知识。
用java 实现二叉树创建
花生日记
04-21 2598
二叉树是数据结构中的一个重要的概念，二叉树的概念最早由 Linus Torvalds在1958年提出。他给出了一个树形数据结构，可以用来存储二叉树。每个节点的左子树和右子树都是空，中间层是子树。在一个给定的空间中，每一个节点都有两个左右子树。 在 Java中，我们可以用类似的方法来创建二叉树，但是这个方法只支持最简单的二叉树类型。例如，对于下面这种类型的二叉树，它需要四个节点：左子树、右子树和根结点。如果我们想创建一个节点为树根的二叉树，则需要更复杂的方法。 在本文中，我们将介绍如何在 Java中
Java数据结构————二叉树
爱敲代码的三毛的博客
08-20 958
文章目录一、树型结构（了解）1.概念2. 树与非树3. 树的一些重要的概念4. 树的表示形式（了解）5. 树的一些应用二、二叉树1.二叉树的概念2.二叉树的基本形态3.两种特殊的二叉树4. 二叉树的性质5. 二叉树的存储三、二叉树的基本操作1.二叉树的遍历2.前序遍历3. 中序遍历4. 后序遍历5. 求结点个数6.求叶子结点个数7. 求第 k 层结点个数8.获取二叉树的高度9. 查找 val 所在结点10. 层序遍历11. 判断一棵树是不是完全二叉树完！ 要想了解二叉树先要知道什么是树 一、树型结构（..
二叉树遍历方法——前、中、后序遍历（java）
热门推荐
loss_rose777的博客
06-26 4万+
前序遍历是一种访问二叉树的每一个结点的方法，它的遍历顺序是根节点，左子树，右子树。
用java实现二叉树的后序遍历（递归和迭代）
m0_57248752的博客
03-29 1798
用java实现二叉树的后序遍历（递归和迭代两种方法），有详细注释以及图解
java二叉树遍历前序中序后序层次
最新发布
04-29
Java中二叉树的遍历方式包括前序遍历、中序遍历、后序遍历和层次遍历。下面是它们的介绍： 1. 前序遍历（Preorder Traversal）： 前序遍历是指先访问根节点，然后按照先左后右的顺序递归地访问左子树和右子树。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值