第六章 二叉树（Binary Tree）

已于 2022-03-24 23:28:31 修改
阅读量2.3k 收藏 7
点赞数 5
分类专栏： 恋上数据结构与算法 第一季 文章标签： 数据结构 算法 二叉树 深度优先遍历 广度优先
于 2022-03-10 10:30:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sj15814963053/article/details/123395097
版权

第六章 二叉树（Binary Tree）

树形结构

Untitled

生活中的树形结构

Untitled

Untitled

  • 使用树形结构可以大大提高效率
  • 树形结构是算法面试的重点

树（Tree）的基本概念

Untitled

节点、根节点、父节点、子节点、兄弟节点

一棵树可以没有任何节点，称为空树

一棵树可以只有 1 个节点，也就是只有根节点

子树、左子树、右子树

节点的度（degree）：子树的个数

树的度：所有节点度中的最大值

叶子节点（leaf）：度为 0 的节点

非叶子节点：度不为 0 的节点

层数（level）：根节点在第 1 层，根节点的子节点在第 2 层，以此类推（有些教程也从第 0 层开始计算）

节点的深度（depth）：从根节点到当前节点的唯一路径上的节点总数

节点的高度（height）：从当前节点到最远叶子节点的路径上的节点总数

树的深度：所有节点深度中的最大值

树的高度：所有节点高度中的最大值

数的深度 等于 树的高度

有序树、无序树、森林

有序树：树中任意节点的子节点之间有顺序关系

无序树：树中任意节点的子节点之间没有顺序关系，也称为 “自由树”

森林：由 m（m ≥ 0）棵互不相交的树组成的集合

二叉树（Binary Tree）

Untitled

二叉树的特点：

  • 每个节点的度最大为 2（最多拥有 2 棵子树）
  • 左子树和右子树是有顺序的，二叉树是有序树
  • 即使某节点只有一棵子树，也要区分左右子树

Untitled

上面这几种都是二叉树

问题：二叉树是有序树 还是 无序树？

回答：二叉树是有序树，因为二叉树的左右子树是严格区分的，不能调换，所以二叉树是有序树

二叉树的性质

Untitled

  • 非空二叉树的第 i 层，最多有 2 ^ ( i - 1 ) 个节点（ i ≥ 1 ）
  • 在高度为 h 的二叉树上最多有 2 ^ h - 1 个结点（ h ≥ 1 ）
  • 对于任何一棵非空二叉树，如果叶子节点个数为 n0，度为 2 的节点个数为 n2，则有：n0 = n2 + 1
    • 假设度为 1 的节点个数为 n1，那么二叉树的节点总数 n = n0 + n1 + n2
    • 二叉树的边数 T = 1 * n1 + 2 * n2 = n – 1 = n0 + n1 + n2 – 1
    • 因此 n0 = n2 + 1

真二叉树（Proper Binary Tree）

真二叉树：所有节点的度都要么为 0，要么为 2

Untitled

下图不是真二叉树：

Untitled

满二叉树（Full Binary Tree）

满二叉树：最后一层节点的度为0，其他节点的度都为2

Untitled

  • 假设满二叉树的高度为 h（ h ≥ 1 ），那么
    • 第 i 层的节点数量： 2 ^ ( i − 1 )
    • 叶子节点数量： 2 ^ ( h − 1 )
    • 总节点数量: n
    • n = 2 ^ h − 1 = 2^0 + 2^1 + 2^2 + ⋯ + 2 ^ ( h − 1 )
    • 树高度与总节点的关系：h = log2 (n + 1)

在同样高度的二叉树中，满二叉树的叶子节点数量最多、总节点数量最多

满二叉树一定是真二叉树，真二叉树不一定是满二叉树

完全二叉树（Complete Binary Tree）

完全二叉树：对节点从上至下、左至右开始编号，其所有编号都能与相同高度的满二叉树中的编号对应

Untitled

完全二叉树从根节点 至 倒数第2层是一棵满二叉树

满二叉树一定是完全二叉树，完全二叉树不一定是满二叉树

完全二叉树的性质

Untitled

Untitled

Untitled

根节点从1开始编号

Untitled

根节点从0开始编号

Untitled

下图不是完全二叉树

Untitled

面试题（完全二叉树）

Untitled

国外教材的说法（了解一下）

Untitled

二叉树的遍历

  • 遍历是数据结构中的常见操作

    • 把所有元素都访问一遍

  • 线性数据结构的遍历比较简单：

    • 正序遍历
    • 逆序遍历

  • 根据节点访问顺序的不同，二叉树的常见遍历方式有 4 种：

    • 前序遍历（Preorder Traversal）
    • 中序遍历（Inorder Traversal）
    • 后序遍历（Postorder Traversal）
    • 层序遍历（Level Order Traversal）

  • 遍历的应用：

    • 前序遍历：树状结构展示（注意左右子树的顺序）
    • 中序遍历：二叉搜索树的中序遍历按升序或者降序处理节点
    • 后序遍历：适用于一些先子后父的操作
    • 层序遍历：计算二叉树的高度、判断一棵树是否为完全二叉树

前序遍历（Preorder Traversal）

访问顺序：

根节点、前序遍历左子树、前序遍历右子树

下图前序遍历的结果是：7、4、2、1、3、5、9、8、11、10、12

Untitled

/**
 * 前序遍历
 */
public void preorderTraversal() {
    preorderTraversal(root);
}

private void preorderTraversal(Node<E> node) {
    if (node == null) {
        return;
    }
    //先访问根节点
    System.out.println(node.element);
    //访问左子节点
    preorderTraversal(node.left);
    //访问右子节点
    preorderTraversal(node.right);
}

前序遍历 - 非递归

方法一

Untitled

/**
 * 前序遍历1
 *
 * @param visitor
 */
public void preorder2(Visitor<E> visitor) {
    if (visitor == null || root == null) {
        return;
    }
    Node<E> node = root;
    Stack<Node<E>> stack = new Stack<>();
    while (true) {
        if (node != null) {
            // 访问node节点
            if (visitor.visit(node.element)) { //如果返回值为true，停止遍历
                return;
            }
            // 将右子节点入栈
            if (node.right != null) {
                stack.push(node.right);
            }
            // 向左走
            node = node.left;
        } else if (stack.isEmpty()) { //栈为空，停止遍历
            return;
        } else { //node == null,栈不为空
            // 处理右边
            node = stack.pop();
        }
    }
}

方法二

Untitled

/**
 * 前序遍历2
 *
 * @param visitor
 */
public void preorder(Visitor<E> visitor) {
    if (visitor == null || root == null) {
        return;
    }

    Stack<Node<E>> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        Node<E> node = stack.pop();
        // 访问node节点
        if (visitor.visit(node.element)) {
            return;
        }
        if (node.right != null) {
            stack.push(node.right);
        }
        if (node.left != null) {
            stack.push(node.left);
        }
    }
}

中序遍历（Inorder Traversal）

访问顺序：

中序遍历左子树、根节点、中序遍历右子树

下图中序遍历的结果是：1、2、3、4、5、7、8、9、10、11、12

二叉搜索树的中序遍历结果是升序或者降序的

Untitled

另一种中序遍历访问顺序：

中序遍历右子树、根节点、中序遍历左子树

则上图的中序遍历的结果是：12、11、10、9、8 、7、5、4、3、2、1

/**
 * 中序遍历
 */
public void inorderTraversal() {
    inorderTraversal(root);
}

private void inorderTraversal(Node<E> node) {
    if (node == null) {
        return;
    }
    //先中序遍历左子树
    inorderTraversal(node.left);
    //输出根节点
    System.out.println(node.element);
    //再中序遍历右子树
    inorderTraversal(node.right);
}

中序遍历 - 非递归

Untitled

/**
 * 中序遍历 - 非递归
 *
 * @param visitor
 */
public void inorder(Visitor<E> visitor) {
    if (visitor == null || root == null) {
        return;
    }
    Node<E> node = root;
    Stack<Node<E>> stack = new Stack<>();
    while (true) {
        if (node != null) {
            // 入栈
            stack.push(node);
            // 向左走
            node = node.left;
        } else if (stack.isEmpty()) {
            return;
        } else {
            node = stack.pop();
            // 访问node节点
            if (visitor.visit(node.element)) {
                return;
            }
            // 让右节点进行中序遍历
            node = node.right;
        }
    }
}

后序遍历（Postorder Traversal）

访问顺序：

后序遍历左子树、后序遍历右子树、根节点

下图的后序遍历的结果是：1、3、2、5、4、8、10、12、11、9、7

Untitled

/**
 * 后序遍历
 */
public void postorderTraversal() {
    postorderTraversal(root);
}

private void postorderTraversal(Node<E> node) {
    if (node == null) {
        return;
    }
    //先遍历左子树
    postorderTraversal(node.left);
    //再遍历右子树
    postorderTraversal(node.right);
    //最后访问根节点
    System.out.println(node.element);
}

后序遍历 - 非递归

Untitled

/**
 * 后序遍历 - 非递归
 *
 * @param visitor
 */
public void postorder(Visitor<E> visitor) {
    if (visitor == null || root == null) {
        return;
    }
    // 记录上一次弹出访问的节点
    Node<E> prev = null;

    Stack<Node<E>> stack = new Stack<>();
    //将根节点入栈
    stack.push(root);
    while (!stack.isEmpty()) { //栈不为空
        Node<E> top = stack.peek(); //返回栈顶元素
        if (top.isLeaf() || (prev != null && prev.parent == top)) {
            prev = stack.pop();
            // 访问节点
            if (visitor.visit(prev.element)) {
                return;
            }
        } else {
            if (top.right != null) {
                stack.push(top.right); //将右节点入栈
            }
            if (top.left != null) {
                stack.push(top.left); //将左节点入栈
            }
        }
    }
}

层序遍历（Level Order Traversal）

访问顺序：

从上到下、从左到右依次访问每一个节点

下图的层序遍历的结果是：7、4、9、2、5、8、11、1、3、10、12

Untitled

实现思路：使用队列

  1. 将根节点入队

  2. 循环执行以下操作，直到队列为空

    将队头节点A出队，进行访问

    将A的左子节点入队

    将A的右子节点入队

/**
 * 层序遍历
 */
public void levelOrderTranversal() {
    if (root == null) {
        return;
    }
    //新建一个队列
    Queue<Node<E>> queue = new LinkedList<>();
    //将头节点入队
    queue.offer(root);
    while (!queue.isEmpty()) {
        //将头结点出队
        Node<E> node = queue.poll();
        System.out.println(node.element);
        //如果左子节点不为空，就将左子节点入队
        if (node.left != null) {
            queue.offer(node.left);
        }
        //如果右子节点不为空，就将右子节点入队
        if (node.right != null) {
            queue.offer(node.right);
        }
    }
}

定制遍历接口

”可以定制输出的格式，首先得有个内部接口类

/**
 * Visitor 接口
 * @param <E>
 */
public static interface Visitor<E> {
    void visit(E element);
}

前序遍历接口

public void preorder(Visitor<E> visitor) {
    preorder(root, visitor);
}

private void preorder(Node<E> node, Visitor<E> visitor) {
    if (node == null || visitor == null) {
        return;
    }
    visitor.visit(node.element);
    preorder(node.left, visitor);
    preorder(node.right, visitor);
}

中序遍历接口

public void inorder(Visitor<E> visitor) {
    inorder(root, visitor);
}

private void inorder(Node<E> node, Visitor<E> visitor) {
    if (node == null || visitor == null) {
        return;
    }
    inorder(node.left, visitor);
    visitor.visit(node.element);
    inorder(node.right, visitor);
}

后序遍历接口

public void postorder(Visitor<E> visitor) {
    postorder(root, visitor);
}

private void postorder(Node<E> node, Visitor<E> visitor) {
    if (node == null || visitor == null) {
        return;
    }
    postorder(node.left, visitor);
    postorder(node.right, visitor);
    visitor.visit(node.element);
}

层序遍历接口

public void levelOrder(Visitor<E> visitor) {
    if (root == null || visitor == null) {
        return;
    }
    Queue<Node<E>> queue = new LinkedList<>();
    //将头节点入队
    queue.offer(root);
    while (!queue.isEmpty()) {
        //将头结点出队
        Node<E> node = queue.poll();
        visitor.visit(node.element);
        //如果左子节点不为空，就将左子节点入队
        if (node.left != null) {
            queue.offer(node.left);
        }
        //如果右子节点不为空，就将右子节点入队
        if (node.right != null) {
            queue.offer(node.right);
        }
    }
}

遍历的应用

前序遍历

树状结构展示（注意左右子树的顺序）

@Override
public String toString() {
    StringBuilder sb = new StringBuilder();
    toString(root, sb, "");
    return sb.toString();
}

private void toString(Node<E> node, StringBuilder sb, String prefix) {
    if (node == null) {
        return;
    }
    sb.append(prefix).append(node.element).append("\n");
    toString(node.left, sb, prefix + "L---");
    toString(node.right, sb, prefix + "R---");
}

中序遍历

二叉搜索树的中序遍历按升序或者降序处理节点

后序遍历

适用于一些先子后父的操作

层序遍历

计算二叉树的高度

判断一棵树是否为完全二叉树

练习

练习 - 计算二叉树的高度

递归解法

/**
 * 计算二叉树的高度
 *
 * @return
 */
public int height() {
    return height(root);
}

/**
 * 获取某一个节点的高度
 * 递归解法
 *
 * @param node
 * @return
 */
private int height(Node<E> node) {
    if (node == null) {
        return 0;
    }
    return 1 + Math.max(height(node.left), height(node.right));
}

迭代解法

/**
 * 计算二叉树的高度
 * 非递归解法
 */
public int height() {
    if (root == null) {
        return 0;
    }
    //树的高度
    int height = 0;
    //存储着每一层的元素数量
    int levelSize = 1;
    Queue<Node<E>> queue = new LinkedList<>();
    //将头节点入队
    queue.offer(root);
    while (!queue.isEmpty()) {
        //将头结点出队
        Node<E> node = queue.poll();
        levelSize--;
        //如果左子节点不为空，就将左子节点入队
        if (node.left != null) {
            queue.offer(node.left);
        }
        //如果右子节点不为空，就将右子节点入队
        if (node.right != null) {
            queue.offer(node.right);
        }
        if (levelSize == 0) { //意味着即将要访问下一层
            levelSize = queue.size();
            height++;
        }
    }
    return height;
}

练习 - 判断一棵树是否为完全二叉树

写法一 思路分析

  • 如果树为空，返回 false
  • 如果树不为空，开始层序遍历二叉树（用队列）
    • 如果 node.left != null && node.right != null，将 node.left、node.right 按顺序入队
    • 如果 node.left == null && node.right != null，返回 false
    • 如果 node.left != null && node.right == null 或者 node.left == null && node.right == null
      • 那么后面遍历的节点应该都为叶子节点，才是完全二叉树
      • 否则返回 false
    • 遍历结束，返回 true
/**
 * 判断这棵二叉树是不是完全二叉树
 */
public boolean isComplete() {
    if (root == null) {
        return false;
    }
    Queue<Node<E>> queue = new LinkedList<>();
    //将头节点入队
    queue.offer(root);

    boolean leaf = false;
    while (!queue.isEmpty()) {
        //将头结点出队
        Node<E> node = queue.poll();

        //要求是叶子节点，但这个节点却不是叶子节点
        if (leaf && !node.isLeaf()) {
            return false;
        }
        if (node.left != null && node.right != null) {
            queue.offer(node.left);
            queue.offer(node.right);
        } else if (node.left == null && node.right != null) {
            return false;
        } else { //后面遍历的节点都必须是叶子节点
            leaf = true;
            if (node.left != null) {
                queue.offer(node.left);
            }
        }
    }
    return true;
}

写法二思路分析：推荐

  • 如果树为空，返回 false
  • 如果树不为空，开始层序遍历二叉树（用队列）
    • 如果 node.left != null，将 node.left 入队
    • 如果 node.left == null && node.right != null，返回 false
    • 如果 node.right != null，将 node.right 入队
    • 如果 node.right == null
      • 那么后面遍历的节点应该都为叶子节点，才是完全二叉树
      • 否则返回 false
    • 遍历结束，返回 true
/**
 * 判断这棵二叉树是不是完全二叉树
 */
public boolean isComplete() {
    if (root == null) {
        return false;
    }
    Queue<Node<E>> queue = new LinkedList<>();
    //将头节点入队
    queue.offer(root);

    boolean leaf = false;
    while (!queue.isEmpty()) {
        //将头结点出队
        Node<E> node = queue.poll();
        //要求是叶子节点，但这个节点却不是叶子节点
        if (leaf && !node.isLeaf()) {
            return false;
        }

        if (node.left != null) {
            queue.offer(node.left);
        } else if (node.right != null) {
            //node.left == null && node.right != null
            return false;
        }

        if (node.right != null) {
            queue.offer(node.right);
        } else {
            //包含下面两种情况
            //node.left == null && node.right == null
            //node.left != null && node.right == null
            leaf = true;
        }
    }
    return true;
}

练习 - 翻转二叉树

226_翻转二叉树：https://leetcode-cn.com/problems/invert-binary-tree/

Untitled

解法一：前序遍历

package 二叉树;

/**
 * https://leetcode-cn.com/problems/invert-binary-tree/
 *
 * @author xiexu
 * @create 2021-07-30 6:56 下午
 */
public class _226_翻转二叉树 {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        //交换左右子树
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;

        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}

解法二：后序遍历

package 二叉树;

/**
 * https://leetcode-cn.com/problems/invert-binary-tree/
 *
 * @author xiexu
 * @create 2021-07-30 6:56 下午
 */
public class _226_翻转二叉树 {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        invertTree(root.left);
        invertTree(root.right);

        //交换左右子树
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;

        return root;
    }
}

解法三：类似于中序遍历，但要注意交换后的左右子树顺序

package 二叉树;

/**
 * https://leetcode-cn.com/problems/invert-binary-tree/
 *
 * @author xiexu
 * @create 2021-07-30 6:56 下午
 */
public class _226_翻转二叉树 {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        invertTree(root.left);

        //交换左右子树
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;

        invertTree(root.right);

        return root;
    }
}

解法四：层序遍历

package 二叉树;

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

/**
 * https://leetcode-cn.com/problems/invert-binary-tree/
 *
 * @author xiexu
 * @create 2021-07-30 6:56 下午
 */
public class _226_翻转二叉树 {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            TreeNode tmp = node.left;
            node.left = node.right;
            node.right = tmp;

            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return root;
    }
}

根据遍历结果重构二叉树

  • 以下结果可以保证重构出唯一的一棵二叉树：
    • 前序遍历 + 中序遍历
    • 后序遍历 + 中序遍历

前序遍历+中序遍历 重构二叉树

Untitled

  • 前序遍历 + 后序遍历：
    • 如果它是一棵真二叉树（Proper Binary Tree），结果是唯一的
  • 不然结果不唯一

求二叉树的节点

前驱节点（predecessor）

Untitled

/**
 * 前驱节点: 中序遍历时的前一个节点
 * 求前驱节点
 */
private Node<E> predecessor(Node<E> node) {
    if (node == null) {
        return null;
    }
    //前驱节点在左子树中(left.right.right.right....)
    Node<E> p = node.left;
    if (node.left != null) {
        //左子树不为空，则找到它的最右节点
        while (p.right != null) {
            p = p.right;
        }
        return p;
    }

    // 能来到这里说明左子树为空, 则从父节点、祖父节点中寻找前驱节点
    // 当父节点不为空, 且某节点为父节点的左子节点
    // 则顺着父节点找, 直到找到【某结点为父节点或祖父节点的右子树中】时
    while (node.parent != null && node.parent.left == node) {
        node = node.parent;
    }

    // 来到这里有以下两种情况:
    // node.parent == null 无前驱, 说明是根结点
    // node.parent...right == node 找到【某结点为父节点或祖父节点的右子树中】
    // 那么父节点就是某节点的前驱节点
    return node.parent;
}

后继节点（successor）

Untitled

/**
 * 后继节点: 中序遍历时的后一个节点
 * 求后继节点
 */
private Node<E> successor(Node<E> node) {
    if (node == null) {
        return null;
    }
    //后继节点在右子树中(right.left.left.left....)
    Node<E> p = node.right;
    if (node.right != null) {
        //左子树不为空，则找到它的最右节点
        while (p.left != null) {
            p = p.left;
        }
        return p;
    }

    // 能来到这里说明右子树为空, 则从父节点、祖父节点中寻找后继节点
    // 当父节点不为空, 且某节点为父节点的右子节点
    // 则顺着父节点找, 直到找到【某结点为父节点或祖父节点的左子树中】时
    while (node.parent != null && node.parent.right == node) {
        node = node.parent;
    }

    // 来到这里有以下两种情况:
    // node.parent == null 无后继, 说明是根结点
    // node.parent...left == node 找到【某结点为父节点或祖父节点的左子树中】
    // 那么父节点就是某节点的后继节点
    return node.parent;
}

BinaryTreeInfo 工具

这是小码哥自己写的一款工具，可以方便的打印二叉树，github 地址如下：https://github.com/CoderMJLee/BinaryTrees。

/**
 * BinaryTreeInfo 工具，用来打印二叉树
 */
@Override
public Object root() {
        return root;
}
@Override
public Object left(Object node) {
        return ((Node<E>)node).left;
}
@Override
public Object right(Object node) {
        return ((Node<E>)node).right;
}
@Override
public Object string(Object node) {
        Node<E> myNode = (Node<E>)node;
        String parentStr = "null";
        if(myNode.parent != null){
                parentStr = myNode.parent.element.toString();
        }
        return myNode.element + "_p(" + parentStr + ")";
}

二叉树完整源码

package cn.xx.java.tree;

import cn.xx.java.printer.BinaryTreeInfo;

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

/**
 * 二叉树
 * @author xiexu
 * @create 2021-08-02 12:14 下午
 */
public class BinaryTree<E> implements BinaryTreeInfo {
    protected int size; //节点数量
    protected Node<E> root; //根节点

    public int size() {
        return size;
    }

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

    public void clear() {
        root = null;
        size = 0;
    }

    protected static class Node<E> {
        E element;
        Node<E> left; //左子节点
        Node<E> right; //右子节点
        Node<E> parent; //父节点

        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        //判断当前节点是不是叶子节点
        public boolean isLeaf() {
            return left == null && right == null;
        }

        //判断当前节点是不是拥有两个子节点
        public boolean hasTwoChildren() {
            return left != null && right != null;
        }
    }

    public static interface Visitor<E> {
        void visit(E element);
    }

    /**
     * 前序遍历
     * @param visitor
     */
    public void preorder(Visitor<E> visitor) {
        preorder(root, visitor);
    }

    private void preorder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor == null) {
            return;
        }
        visitor.visit(node.element);
        preorder(node.left, visitor);
        preorder(node.right, visitor);
    }

    /**
     * 中序遍历
     * @param visitor
     */
    public void inorder(Visitor<E> visitor) {
        inorder(root, visitor);
    }

    private void inorder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor == null) {
            return;
        }
        inorder(node.left, visitor);
        visitor.visit(node.element);
        inorder(node.right, visitor);
    }

    /**
     * 后序遍历
     * @param visitor
     */
    public void postorder(Visitor<E> visitor) {
        postorder(root, visitor);
    }

    private void postorder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor == null) {
            return;
        }
        postorder(node.left, visitor);
        postorder(node.right, visitor);
        visitor.visit(node.element);
    }

    /**
     * 层序遍历
     * @param visitor
     */
    public void levelOrder(Visitor<E> visitor) {
        if (root == null || visitor == null) {
            return;
        }
        Queue<Node<E>> queue = new LinkedList<>();
        //将头节点入队
        queue.offer(root);
        while (!queue.isEmpty()) {
            //将头结点出队
            Node<E> node = queue.poll();
            visitor.visit(node.element);
            //如果左子节点不为空，就将左子节点入队
            if (node.left != null) {
                queue.offer(node.left);
            }
            //如果右子节点不为空，就将右子节点入队
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

    @Override
    public Object root() {
        return root;
    }

    @Override
    public Object left(Object node) {
        return ((Node<E>) node).left;
    }

    @Override
    public Object right(Object node) {
        return ((Node<E>) node).right;
    }

    @Override
    public Object string(Object node) {
        Node<E> myNode = (Node<E>) node;
        String parentString = "null";
        if (myNode.parent != null) {
            parentString = myNode.parent.element.toString();
        }
        return ((Node<E>) node).element + "_p(" + parentString + ")";
    }

    /**
     * 前驱节点: 中序遍历时的前一个节点
     * 求前驱节点
     */
    protected Node<E> predecessor(Node<E> node) {
        if (node == null) {
            return null;
        }
        //前驱节点在左子树中(left.right.right.right....)
        Node<E> p = node.left;
        if (node.left != null) {
            //左子树不为空，则找到它的最右节点
            while (p.right != null) {
                p = p.right;
            }
            return p;
        }

        // 能来到这里说明左子树为空, 则从父节点、祖父节点中寻找前驱节点
        // 当父节点不为空, 且某节点为父节点的左子节点
        // 则顺着父节点找, 直到找到【某结点为父节点或祖父节点的右子树中】时
        while (node.parent != null && node.parent.left == node) {
            node = node.parent;
        }

        // 来到这里有以下两种情况:
        // node.parent == null 无前驱, 说明是根结点
        // node.parent...right == node 找到【某结点为父节点或祖父节点的右子树中】
        // 那么父节点就是某节点的前驱节点
        return node.parent;
    }

    /**
     * 后继节点: 中序遍历时的后一个节点
     * 求后继节点
     */
    protected Node<E> successor(Node<E> node) {
        if (node == null) {
            return null;
        }
        //后继节点在右子树中(right.left.left.left....)
        Node<E> p = node.right;
        if (node.right != null) {
            //左子树不为空，则找到它的最右节点
            while (p.left != null) {
                p = p.left;
            }
            return p;
        }

        // 能来到这里说明右子树为空, 则从父节点、祖父节点中寻找后继节点
        // 当父节点不为空, 且某节点为父节点的右子节点
        // 则顺着父节点找, 直到找到【某结点为父节点或祖父节点的左子树中】时
        while (node.parent != null && node.parent.right == node) {
            node = node.parent;
        }

        // 来到这里有以下两种情况:
        // node.parent == null 无后继, 说明是根结点
        // node.parent...left == node 找到【某结点为父节点或祖父节点的左子树中】
        // 那么父节点就是某节点的后继节点
        return node.parent;
    }

    /**
     * 计算二叉树的高度
     * 非递归解法
     */
    public int height() {
        if (root == null) {
            return 0;
        }
        //树的高度
        int height = 0;
        //存储着每一层的元素数量
        int levelSize = 1;
        Queue<Node<E>> queue = new LinkedList<>();
        //将头节点入队
        queue.offer(root);
        while (!queue.isEmpty()) {
            //将头结点出队
            Node<E> node = queue.poll();
            levelSize--;
            //如果左子节点不为空，就将左子节点入队
            if (node.left != null) {
                queue.offer(node.left);
            }
            //如果右子节点不为空，就将右子节点入队
            if (node.right != null) {
                queue.offer(node.right);
            }
            if (levelSize == 0) { //意味着即将要访问下一层
                levelSize = queue.size();
                height++;
            }
        }
        return height;
    }

    /**
     * 计算二叉树的高度
     * 递归解法
     *
     * @return
     */
    public int height2() {
        return height(root);
    }

    /**
     * 获取某一个节点的高度
     * 递归解法
     *
     * @param node
     * @return
     */
    private int height(Node<E> node) {
        if (node == null) {
            return 0;
        }
        return 1 + Math.max(height(node.left), height(node.right));
    }

    /**
     * 判断这棵二叉树是不是完全二叉树
     */
    public boolean isComplete() {
        if (root == null) {
            return false;
        }
        Queue<Node<E>> queue = new LinkedList<>();
        //将头节点入队
        queue.offer(root);

        boolean leaf = false;
        while (!queue.isEmpty()) {
            //将头结点出队
            Node<E> node = queue.poll();
            //要求是叶子节点，但这个节点却不是叶子节点
            if (leaf && !node.isLeaf()) {
                return false;
            }

            if (node.left != null) {
                queue.offer(node.left);
            } else if (node.right != null) {
                //node.left == null && node.right != null
                return false;
            }

            if (node.right != null) {
                queue.offer(node.right);
            } else {
                //包含下面两种情况
                //node.left == null && node.right == null
                //node.left != null && node.right == null
                leaf = true;
            }
        }
        return true;
    }

}
猿小羽
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
【数据结构】利用先序扩展序列建立二叉树
Chancy_Lu的博客
11-30 5393
利用先序扩展序列建立二叉树 题目 先序扩展序列是指用特定的字符表示空子树。这里用‘#’表示二叉树为空。 现给出一个字符串为二叉树的线序扩展序列，要求建立一棵二叉树。 思路 定义二叉树 初始化二叉树 定义二叉树 C定义二叉树 typedef struct TNode *Position; typedef Position BinTree; struct TNode { ElementType Data; BinTree Left; BinTree Right; };
第六章 树和二叉树(一)
xu_aml的博客
03-01 412
@第六章 树和二叉树 (一) 二叉树的递归遍历和非递归遍历算法 一、二叉链表存储结构 //二叉链表存储结构 typedef struct BTNode { char data; //这里默认结点data域为char型 struct BTNode *lchild; struct BTNode *rchild; }BTNode; 二、二叉树的递归遍历 //先序遍历 voi...
二叉树
qq_37365741的博客
10-22 527
二叉树： 是n(n>=0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。 1）每个结点最多有两颗子树，所以二叉树中不存在度大于2的结点。 2）左子树和右子树是有顺序的，次序不能任意颠倒。 3）即使树中某结点只有一棵子树，也要区分它是左子树还是右子树。 斜树： 所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右...
数据结构之二叉树(Binary Tree)详解
swadian2008的博客
06-06 1581
二叉树（Binary Tree）是一种常见的树状数据结构，它由一组节点组成，这些节点通过边连接起来。每个节点最多可以有两个子节点，分别称为左子节点和右子节点。 二叉树的特点包括： 每个节点最多有两个子节点。这两个子节点可以为空（null），也可以存在一个或两个子节点。 左子节点和右子节点的顺序是有意义的，即左子节点在右子节点之前或之后。 每个节点通常包含一个值（或称为关键字）以及其他辅助信息。
【数据结构】二叉树的介绍
WINGREZ‘S BLOG
08-31 1620
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 二叉树 二叉树是一种特殊的有序树，它的每个结点最多只有两棵子树。它与度为2的有序树的区别在于：度为2的树至少有3个结...
二叉树和树的关系
weixin_45989683的博客
07-25 2962
二叉树是树形结构，但二叉树和树是两种不同的数据结构。二叉树中结点的度不大于2，二叉树有5种基本类型，二叉树的子树分左右，且不可交换等等。二叉树并不是通过树收窄概念后得到的，树和二叉树之间并不是包含与被包含之间的关系。...
二叉树（Binary Tree）
蜗牛先生的博客
07-12 9409
二叉树（Binary Tree）是n个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。 二叉树特点： 每个结点最多有两棵子树；左子树和右子树是有顺序的，次序不能颠倒。介绍了特殊二叉树，分别为斜树、满二叉树和完全二叉树。重点介绍了二叉树的五个性质，还有二叉树的顺序存储结构和链式存储结构，顺序结构仅适于完全二叉树，链式存储较灵活。二叉树的建立
BinaryTree - 副本.zip_lisp_livew67_二叉树
09-23
本文将深入探讨使用Lisp语言实现的二叉树程序，并结合"BinaryTree - 副本.LSP"这个压缩包中的源代码，来解析其背后的逻辑和知识点。 首先，我们要了解Lisp语言。Lisp是一种古老但依然活跃的编程语言，以其独特的...
binary tree C语言算法
10-11
在计算机科学中，二叉树（Binary Tree）是一种数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。这种数据结构广泛应用于各种算法和问题解决，如搜索、排序、文件系统等。在C语言中实现二叉树，我们...
算法与数据结构：第六章 树和二叉树.ppt
09-19
完全二叉树（complete binary tree）：一棵深度为k的满二叉树的第k层的右边几个结点不存在则为完全二叉树。 二叉树的存储结构： * 顺序存储结构 * 链式存储结构 树和二叉树是非常重要的数据结构概念，它们广泛...
02 BinaryTree.rar
01-07
本篇文章将基于“02 BinaryTree.rar”压缩包中的内容，详细探讨二叉树的相关知识点。 一、二叉树的基本概念 1. 定义：二叉树是由n（n≥0）个有限节点组成一个具有层次关系的集合。通常每个节点包含两个子节点，...
binarytree:二叉搜索树
03-05
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树数据结构，它具有以下特性： 1. **定义**：每个节点包含一个键（key）、一个关联的值、一个指向左子节点的引用和一个指向右子节点的引用。对于每个...
【数据结构入门】二叉树(BinaryTree) 详解
weixin_64289779的博客
04-20 528
因为我们把数据存储在数组里面，物理存储是连续的，逻辑关系是树状关系，树之间的逻辑关系的维持是通过下标来找到父亲节点和孩子节点，向上调整是建堆的过程，父亲节点和孩子节点不断比较，将大数或者小数向上调整，来建成大堆或者小堆。实现思路：为了不使大堆或者小堆的性质发生改变，先把top元素和最后一个元素交换位置，让后再向下调整，保持原来的性质，再不断调整递归，删除一次递归调整数据个数-1，删除越多把数据放到后面的越多，那么数据进行向上调整的越少。：一个结点含有的子树的根结点称为该结点的子结点；
数据结构—二叉树(BinaryTree)的入门原理以及Java实现案例
终生学习践行者
04-24 3176
本文介绍了二叉树的入门，包括二叉树的定义、特性、性质，在最后介绍了二叉树的存储结构，并且使用Java语言分别简单实现了采用不同的存储结构的二叉树。为后续二叉树的深入学习打好基础。
二叉树、满二叉树、完全二叉树、二叉排序树、平衡二叉树
qq_51066068的博客
04-14 1825
目录 1.基本概念 1.1二叉树是有序树 1.2二叉树 1.3特殊的二叉树 1.3.1满二叉树 1.3,2完全二叉树 1.4 二叉树的性质 二叉排序树 平衡二叉树 二叉树的存储结构 1.基本概念 1.1二叉树是有序树 二叉树是树形结构中一种特殊的树形结构： 1.二叉树中的每个结点至多有2棵子树（即每个结点的度小于等于2） 2.两个子树有左右之分，顺序不可颠倒。 在二叉树中还有种特殊的二叉树就是完全二叉树：所有结点中除了叶子结点以外的结点都有两棵子树...
【数据结构】二叉树 (Binary Tree)
Living_Amethyst的博客
06-27 1975
二叉树快速入门
二叉树的遍历
南宫封清的博客
08-15 120
树形结构 树的概念 节点： 根节点、父节点、子节点、兄弟节点 空树： 一棵树可以没有任何节点 一棵树可以只有1个节点，也就是只有根节点 子树： 左子树、右子树 节点的度（degree）： 子树的个数 树的度： 所有节点度中的最大值 叶子节点（leaf）： 度为 0 的节点 非叶子节点： 度不为 0 的节点 层数（level）： 根节点在第1层，根节点的子节点在第2层，以此类推（有些教程也从第0层开始计算） 节点的深度（depth）： 从根节点到当前节点的唯一路径上的节点总数 节点的高度（height）： 从
树和二叉树介绍
weixin_43697050的博客
02-28 534
树 树形结构 是数据元素(结点)之间有分支，并且具有层次关系的结构，可用于表示数据元素之间存在的一对多关系。 树(Tree) 是由n(n≥0)个结点构成的有限集合，当n=0时称为空树。若树非空，则具有以下两个性质： (1)有且仅有一个特定的结点，称为根(Root)。 (2)其余的结点可分为m个互不相交的集合T1，T2，…，Tm，其中每一个集合都是一棵树，并且称为根的子树( Subtree)。 如下...
数据结构【顺序表】
最新发布
qq_67578580的博客
07-12 715
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
java实现创建二叉树
09-16
创建二叉树的方法在Java中有多种实现方式，其中一种常用的方式是通过递归来创建二叉树。可以按照以下步骤来实现： ...BinaryTree binaryTree = new BinaryTree(); TreeNode root = binaryTree.createTree(arr); ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿小羽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值