二叉树基础（一）

最新推荐文章于 2024-09-14 12:37:02 发布
最新推荐文章于 2024-09-14 12:37:02 发布
阅读量41 收藏
点赞数
分类专栏： Java 算法 文章标签： 数据结构 算法 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qa18252714222/article/details/133282584
版权
Java 同时被 2 个专栏收录
11 篇文章 0 订阅
订阅专栏
算法
11 篇文章 0 订阅
订阅专栏

二叉树理论基础篇

一、二叉树的种类

在我们解题过程中二叉树有两种主要的形式：满二叉树和完全二叉树。

1、满二叉树

满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

如图所示：

image-20220527194323696

这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。

2、完全二叉树

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。

image-20220527194639078

3、二叉搜索树

前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。

  • 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  • 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  • 它的左、右子树也分别为二叉排序树

image-20220527194746294

4、平衡二叉搜索树

平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

image-20220527194811110

二、二叉树的存储方式

二叉树可以链式存储，也可以顺序存储。

image-20220527194855375

链式存储是大家很熟悉的一种方式，那么我们来看看如何顺序存储呢？

其实就是用数组来存储二叉树，顺序存储的方式如图：

image-20220527194912565

三、二叉树的遍历方式

二叉树主要有两种遍历方式：

  1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
  2. 广度优先遍历：一层一层的去遍历。

这两种遍历是图论中最基本的两种遍历方式，后面在介绍图论的时候 还会介绍到。

那么从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式：

  • 深度优先遍历
    • 前序遍历（递归法，迭代法）
    • 中序遍历（递归法，迭代法）
    • 后序遍历（递归法，迭代法）
  • 广度优先遍历
    • 层次遍历（迭代法）

在深度优先遍历中：有三个顺序，前中后序遍历， 有同学总分不清这三个顺序，经常搞混，我这里教大家一个技巧。

这里前中后，其实指的就是中间节点的遍历顺序，只要大家记住 前中后序指的就是中间节点的位置就可以了。

看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式

  • 前序遍历：中左右
  • 中序遍历：左中右
  • 后序遍历：左右中

大家可以对着如下图，看看自己理解的前后中序有没有问题。

image-20220527195052631

四、二叉树的定义

package com.yzu.lee.treenode;

import org.junit.Test;

/**
 * @ClassName: TreeNode
 * @Description:树定义
 * @author: Leekuangyew
 * @date: 2022/5/22  9:34
 */
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {
    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

二叉树的递归遍历

144.二叉树的前序遍历

 package com.yzu.lee.treenode;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * @ClassName: PreorderTraversal
  * @Description:给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
  * @author: Leekuangyew
  * @date: 2022/5/22  9:37
  */
 public class PreorderTraversal {
     public List<Integer> preorderTraversal(TreeNode root) {
         ArrayList<Integer> result = new ArrayList<>();
         preorder(root, result);
         return result;
     }
 
     private void preorder(TreeNode root, ArrayList<Integer> result) {
         if (root == null) {
             return;
         }
         result.add(root.val);
         preorder(root.left, result);
         preorder(root.right, result);
     }
 }

94.二叉树的中序遍历

 package com.yzu.lee.treenode;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * @ClassName: InorderTraversal
  * @Description:给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。
  * @author: Leekuangyew
  * @date: 2022/5/22  9:46
  */
 public class InorderTraversal {
     public List<Integer> inorderTraversal(TreeNode root) {
         ArrayList<Integer> result = new ArrayList<>();
         inorder(root, result);
         return result;
     }
 
     private void inorder(TreeNode root, ArrayList<Integer> result) {
         if (root == null) {
             return;
         }
 
         inorder(root.left, result);
         result.add(root.val);
         inorder(root.right, result);
     }
 }

145.二叉树的后序遍历

 package com.yzu.lee.treenode;
 
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * @ClassName: PostorderTraversal
  * @Description:给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。
  * @author: Leekuangyew
  * @date: 2022/5/22  9:50
  */
 public class PostorderTraversal {
     public List<Integer> postorderTraversal(TreeNode root) {
         ArrayList<Integer> result = new ArrayList<>();
         postorder(root, result);
         return result;
     }
 
     private void postorder(TreeNode root, ArrayList<Integer> result) {
         if (root == null) {
             return;
         }、
         postorder(root.left, result);
         postorder(root.right, result);
         result.add(root.val);
     }
 }

二叉树的迭代遍历

144.二叉树的前序遍历

​ 层次遍历使用迭代法才用队列，深度优先遍历时迭代法使用栈实现

思路：

  • 创建栈，并将根节点压入栈
  • while循环，当栈不为空，弹出栈顶节点，添加到结果数组，后判断右节点与左节点是否为空，不为空则加入
 //迭代法
 public List<Integer> preorderTraversal2(TreeNode root) {
     ArrayList<Integer> result = new ArrayList<>();
     if (root == null) {
         return result;
     }
     Stack<TreeNode> stack = new Stack<>();
     stack.push(root);
     while (!stack.isEmpty()) {
         TreeNode node 
             = stack.pop();
         result.add(node.val);
         if (node.right != null) {
             stack.push(node.right);
         }
         if (node.left != null) {
             stack.push(node.left);
         }
     }
     return result;
 }

94.二叉树的中序遍历

思路：

在迭代的过程中，其实有两个操作：

  1. 处理：将元素放进result数组中
  2. 访问：遍历节点

为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢，因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。

那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

  • 中序迭代遍历不需要先将root加入栈中
 //迭代法
 public List<Integer> inorderTraversal2(TreeNode root) {
     ArrayList<Integer> result = new ArrayList<>();
     if (root == null) {
         return result;
     }
     Stack<TreeNode> stack = new Stack<>();
     TreeNode node = root;
     while (node != null || !stack.isEmpty()) {
         if (node != null) {
             stack.push(node);
             node = node.left;
         } else {
             node = stack.pop();
             result.add(node.val);
             node = node.right;
         }
     }
     return result;
 }

145.二叉树的后序遍历

  • 与前序相似，只需要将中右左的添加顺序改成中左右，最后反转结果数组
 //迭代法
 public List<Integer> postorderTraversal2(TreeNode root) {
     ArrayList<Integer> result = new ArrayList<>();
     if (root == null) {
         return result;
     }
 
     Stack<TreeNode> stack = new Stack<>();
     stack.push(root);
     while (!stack.isEmpty()) {
         TreeNode node = stack.pop();
         result.add(node.val);
         if (node.left != null) {
             stack.push(node.left);
         }
         if (node.right != null) {
             stack.push(node.right);
         }
     }
     Collections.reverse(result);
     return result;
 }

二叉树的统一迭代法

144.二叉树的前序遍历

思路：

  • **将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。**标记，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。
 //统一迭代法
 public List<Integer> preorderTraversal3(TreeNode root) {
     ArrayList<Integer> result = new ArrayList<>();
     Stack<TreeNode> stack = new Stack<>();
 
     if (root != null) {
         stack.push(root);
     }
 
     while (!stack.isEmpty()) {
         TreeNode node = stack.peek();  //判断栈顶节点是否为null
         if (node != null) {
             stack.pop(); //如果不为null，则将栈顶弹出 并按中左右节点添加到栈里
             if (node.right != null) stack.push(node.right);//添加右节点
             if (node.left != null) stack.push(node.left);//添加左节点
             stack.push(node);//添加中节点
             stack.push(null);//添加完中节点后，需要对其进行处理 增加null标记
         } else {// 只有遇到空节点的时候，才将下一个节点放进结果集
             stack.pop();//弹出空节点
             node = stack.peek();//取出栈顶节点
             stack.pop();
             result.add(node.val);//加入结果集
         }
     }
     return result;
 }

94.二叉树的中序遍历

 //统一迭代法
 public List<Integer> inorderTraversal3(TreeNode root) {
     ArrayList<Integer> result = new ArrayList<>();
     Stack<TreeNode> stack = new Stack<>();
 
     if (root != null) {
         stack.push(root);
     }
 
     while (!stack.isEmpty()) {
         TreeNode node = stack.peek();  //判断栈顶节点是否为null
         if (node != null) {
             stack.pop(); //如果不为null，则将栈顶弹出 并按左中右节点添加到栈里
             if (node.right != null) stack.push(node.right);//添加右节点
             stack.push(node);//添加中节点
             stack.push(null);//添加完中节点后，需要对其进行处理 增加null标记
             if (node.left != null) stack.push(node.left);//添加左节点
         } else {// 只有遇到空节点的时候，才将下一个节点放进结果集
             stack.pop();//弹出空节点
             node = stack.peek();//取出栈顶节点
             stack.pop();
             result.add(node.val);//加入结果集
         }
     }
     return result;
 }

145.二叉树的后序遍历

 //统一迭代法
 public List<Integer> postorderTraversal3(TreeNode root) {
     ArrayList<Integer> result = new ArrayList<>();
     Stack<TreeNode> stack = new Stack<>();
 
     if (root != null) {
         stack.push(root);
     }
 
     while (!stack.isEmpty()) {
         TreeNode node = stack.peek();  //判断栈顶节点是否为null
         if (node != null) {
             stack.pop(); //如果不为null，则将栈顶弹出 并按中左右节点添加到栈里
             stack.push(node);//添加中节点
             stack.push(null);//添加完中节点后，需要对其进行处理 增加null标记
             if (node.right != null) stack.push(node.right);//添加右节点
             if (node.left != null) stack.push(node.left);//添加左节点
         } else {// 只有遇到空节点的时候，才将下一个节点放进结果集
             stack.pop();//弹出空节点
             node = stack.peek();//取出栈顶节点
             stack.pop();
             result.add(node.val);//加入结果集
         }
     }
     return result;
 }

102.二叉树的层序遍历

题意：给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

image-20220527204325050

思路：

  • 递归法：

    • 确定递归函数的参数和返回值： checkFun02(root, 0);
    • 确定终止条件: if (node == null) return;
    • 确定单层递归的逻辑:
      • 将传入的deep加一，表示所在的层数上升
      • 当结果集合的大小小于deep时，创建一个集合，放入结果结合中
      • 将当前节点的值填入到集合中对应的位置
      • 继续递归当前节点的左节点和右节点

  • 迭代法：

    • 判断根节点是否为空，不为空，则创建一个队列，将根节点放入到队列当中
    • 循环判断队列是否为空，如果不为空，则获取队列的大小，如果队列的size大于0，则弹出当前队首节点，并将该节点存到结果集合中，并将非空的左右子节点放入队列中
    • 每次循环将结果保存到集合中
package com.yzu.lee.treenode;

import com.sun.istack.internal.NotNull;
import com.sun.javafx.image.IntPixelGetter;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @ClassName: LevelOrder
 * @Description:
 * @author: Leekuangyew
 * @date: 2022/5/25  13:53
 */
public class LevelOrder {
    private List<List<Integer>> result = new ArrayList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        //迭代法 利用队列
        checkFun01(root);
        //递归法
        checkFun02(root, 0);
        return result;
    }

    private void checkFun02(TreeNode node, int deep) {
        if (node == null) return;
        deep++;

        if (result.size() < deep) {
            ArrayList<Integer> list = new ArrayList<>();
            result.add(list);
        }
        result.get(deep - 1).add(node.val);

        checkFun02(node.left, deep);
        checkFun02(node.right, deep);
    }

    private void checkFun01(TreeNode root) {
        if (root == null) return;
        Queue<TreeNode> queue = new LinkedList<>();

        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();

            ArrayList<Integer> list = new ArrayList<>();
            while (size > 0) {
                TreeNode node = queue.poll();
                list.add(node.val);

                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
                size--;
            }
            result.add(list);
        }
    }
}

107.二叉树的层次遍历II

题意：给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

image-20220527205535544

思路：

  • 递归法，层序遍历，然后反转
  • 迭代法，层序遍历，然后反转
package com.yzu.lee.treenode;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @ClassName: LevelOrderBottom
 * @Description:给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
 * @author: Leekuangyew
 * @date: 2022/5/25  15:09
 */
public class LevelOrderBottom {
    List<List<Integer>> result = new ArrayList<>();

    public List<List<Integer>> levelOrderBottom(TreeNode root) {

        levelOrder(root, 0);
        Collections.reverse(result);
        return result;

    }

    private void levelOrder(TreeNode node, int deep) {
        if (node == null) return;
        int size = result.size();
        deep++;

        if (size < deep) {
            List<Integer> list = new ArrayList<>();
            result.add(list);
        }
        result.get(deep - 1).add(node.val);

        if (node.left != null) levelOrder(node.left, deep);
        if (node.right != null) levelOrder(node.right, deep);
    }
}

199. 二叉树的右视图

题意：给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

image-20220527210138056

思路：

  • 利用BFS进行层次遍历，记录下每层的最后一个元素。
  • DFS
package com.yzu.lee.treenode;

import com.sun.org.apache.bcel.internal.generic.NEW;

import java.util.ArrayList;
import java.util.List;
import java.util.zip.Inflater;

/**
 * @ClassName: RightSideView
 * @Description:给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
 * @author: Leekuangyew
 * @date: 2022/5/25  17:21
 */
public class RightSideView {
    List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<Integer> rightSideView(TreeNode root) {
        rightSide(root, 0);

        ArrayList<Integer> result = new ArrayList<>();
        for (List<Integer> list : resList) {
            result.add(list.get(list.size() - 1));
        }

        return result;
    }

    private void rightSide(TreeNode node, int deep) {
        if (node == null) return;
        deep++;

        if (resList.size() < deep) {
            List<Integer> list = new ArrayList<>();
            resList.add(list);
        }
        resList.get(deep - 1).add(node.val);

        if (node.left != null) rightSide(node.left, deep);
        if (node.right != null) rightSide(node.right, deep);
    }
}

637.二叉树的层平均值

题意：给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

image-20220527210747623

思路：

  • 利用BFS进行层次遍历，然后对每一层的结果进行取平均值操作
package com.yzu.lee.treenode;

import com.sun.org.apache.bcel.internal.generic.NEW;
import org.w3c.dom.ls.LSException;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: AverageOfLevels
 * @Description:
 * @author: Leekuangyew
 * @date: 2022/5/25  17:32
 */
public class AverageOfLevels {

    List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<Double> averageOfLevels(TreeNode root) {
        averageOfLevels(root, 0);
        ArrayList<Double> result = new ArrayList<>();
        for (List<Integer> list : resList) {
            int size = list.size();
            double sum = 0;
            for (Integer integer : list) {
                sum += integer;
            }
            Double res =  sum / (double) size;
            result.add(res);
        }
        return result;
    }

    private void averageOfLevels(TreeNode node, int deep) {
        if (node == null) return;
        deep++;
        int size = resList.size();

        if (size < deep) {
            ArrayList<Integer> list = new ArrayList<>();
            resList.add(list);
        }
        resList.get(deep - 1).add(node.val);

        if (node.left != null) averageOfLevels(node.left, deep);
        if (node.right != null) averageOfLevels(node.right, deep);
    }
}

429.N叉树的层序遍历

题意：给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

image-20220527210954880

思路：

  • 利用BFS的递归法层次遍历，只有对于操作子节点的方式不同
package com.yzu.lee.treenode;

import java.awt.geom.RoundRectangle2D;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: LevelOrderT
 * @Description:给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
 * 树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
 * @author: Leekuangyew
 * @date: 2022/5/25  18:21
 */
public class LevelOrderT {
    List<List<Integer>> result = new ArrayList<>();

    public List<List<Integer>> levelOrder(Node root) {

        levelOrder(root, 0);
        return result;
    }

    private void levelOrder(Node node, int deep) {
        if (node == null) return;
        deep++;
        int size = result.size();

        if (size < deep) {
            ArrayList<Integer> list = new ArrayList<>();
            result.add(list);
        }
        result.get(deep - 1).add(node.val);

        if (node.children != null) {
            for (Node child : node.children) {
                levelOrder(child, deep);
            }
        }
    }
}

515.在每个树行中找最大值

题意：给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

image-20220527211307762

思路：

  • 利用BFS进行递归层次遍历，定义一个Map来存储每一层的最大值
package com.yzu.lee.treenode;

import com.sun.org.apache.bcel.internal.generic.NEW;
import org.junit.Test;

import java.util.*;

/**
 * @ClassName: LargestValues
 * @Description:给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
 * @author: Leekuangyew
 * @date: 2022/5/25  18:37
 */
public class LargestValues {
    Map<Integer, Integer> resList = new HashMap<>();

    public List<Integer> largestValues(TreeNode root) {
        largestValues(root, 0);
        ArrayList<Integer> list = new ArrayList<>();
        int i = 0;
        while (resList.containsKey(i)) {
            list.add(resList.get(i));
            i++;
        }
        return list;
    }

    private void largestValues(TreeNode node, int deep) {
        if (node == null) return;
        deep++;

        if (resList.containsKey(deep - 1)) {
            resList.put(deep - 1, Math.max(resList.get(deep - 1), node.val));
        } else {
            resList.put(deep - 1, node.val);
        }


        if (node.left != null) largestValues(node.left, deep);
        if (node.right != null) largestValues(node.right, deep);
    }
}

116.填充每个节点的下一个右侧节点指针

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

image-20220527211844477

思路：

  • 利用BFS进行迭代层次遍历，在迭代过程中，将每一层中的节点的next等于队列的头节点 node.next = queue.peek();
package com.yzu.lee.treenode.node;

/**
 * @ClassName: Node
 * @Description:
 * @author: Leekuangyew
 * @date: 2022/5/25  20:12
 */
public class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {
    }

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
}

package com.yzu.lee.treenode.node;

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

/**
 * @ClassName: Connect
 * @Description:
 * @author: Leekuangyew
 * @date: 2022/5/25  20:12
 */
public class Connect {
    public Node connect(Node root) {
        Queue<Node> queue = new LinkedList<>();
        if (root == null) return root;

        queue.offer(root);

        while (!queue.isEmpty()) {
            int size = queue.size();

            while (size > 0) {
                Node node = queue.poll();

                size--;

                if (size > 0) {
                    node.next = queue.peek();
                }
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
        }
        return root;
    }
}

117.填充每个节点的下一个右侧节点指针II

题意：给定一个二叉树

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

image-20220527212359302

思路：

  • 与116题类似
package com.yzu.lee.treenode.node;

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

/**
 * @ClassName: Connect
 * @Description:
 * @author: Leekuangyew
 * @date: 2022/5/25  20:12
 */
public class Connect {
    public Node connect(Node root) {
        Queue<Node> queue = new LinkedList<>();
        if (root == null) return root;

        queue.offer(root);

        while (!queue.isEmpty()) {
            int size = queue.size();

            while (size > 0) {
                Node node = queue.poll();

                size--;

                if (size > 0) {
                    node.next = queue.peek();
                }
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
        }
        return  root;
    }
}

226.翻转二叉树

题意：翻转一棵二叉树

image-20220527212521845

思路：

  • 利用DFS进行递归 前序
    • 确定递归函数的参数和返回值： invertTree(TreeNode root)
    • 确定终止条件: if (root == null) return root;
    • 确定单层递归的逻辑:swap(root); 并返回root。
  • 利用BFS进行迭代
    • 从第一层开始，依次往下交换左右节点
package com.yzu.lee.treenode;

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

/**
 * @ClassName: InvertTree
 * @Description:给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
 * @author: Leekuangyew
 * @date: 2022/5/25  22:35
 */
public class InvertTree {
//    public TreeNode invertTree(TreeNode root) {
//        //深度优先DFS
//        if (root == null) return root;
//        swap(root);
//        invertTree(root.left);
//        invertTree(root.right);
//        return root;
//    }
//
//    private void swap(TreeNode root) {
//        TreeNode temp = root.left;
//        root.left = root.right;
//        root.right = temp;
//    }

    public TreeNode invertTree(TreeNode root) {
        //广度优先 BFS
        if (root == null) return null;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            int size = queue.size();

            while (size-- > 0) {
                TreeNode node = queue.poll();
                swap(node);
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
        }
        return root;
    }

    private void swap(TreeNode node) {
        TreeNode temp = node.left;
        node.left = node.right;
        node.right = temp;
    }
}
Leekuangyee
关注
专栏目录
二叉树 基础
03-08
而在一棵二叉树中，除最后一层外，若其余层都是满的，并且最后一层或者是满的，或者是在右边缺少连续若干节点，则此二叉树为完全二叉树。具有n个节点的完全二叉树的深度为log2n+1。深度为k的完全二叉树，至少有2^(k-...
数据结构-二叉树基础.pdf
04-15
### 数据结构之二叉树基础知识点详解 #### 一、二叉树基本概念 **二叉树**是一种特殊的树形结构，在计算机科学中被广泛应用于数据存储和检索中。二叉树具有以下特点： 1. **节点（Node）**：二叉树中的每一个元素...
二叉树基础总结
2301_80841939的博客
02-14 2616
树（层级结构）是一种重要的非线性数据结构（递归的数据结构），它由n（n≥0）个有限节点组成一个具有层次关系的集合。这些节点具有如下特性：（在一个有效的树中，如果有n个节点，就会有n-1条边。每个节点有零个或多个子节点。没有父节点的节点称为根节点。根：树的最顶部的节点，唯一没有双亲的节点。每一个非根节点有且只有一个父节点。除了根节点外，每个子节点可以分为多个不相交的子树。树的术语结点：使用树结构存储的每一个数据元素都被称为“结点”。森林：多棵互不相交的树的集合称为森林。
二叉树基础知识
xujunson的博客
03-26 1590
二叉树基础知识概述5 种基本形态特殊的二叉树满二叉树完全二叉树术语术语解释节点节点的度叶子节点分支节点树的度节点的层次二叉树性质性质1性质2性质3性质4性质5常见的三种遍历代码实现二叉树遍历 我们在 MySQL 为什么用 B+ 树实现索引 提到了二叉树的相关知识，本文就来详细分析一下二叉树。 概述 维基百科定义： 在计算机科学中，二叉树（英语：Binary tree）是每个节点最多只有两个分支（即不存在分支度大于2 的节点）的树结构。通常分支被称作 “左子树” 或 “右子树”。二叉树的分支具有左右次序，不
二叉树基础
hzsd_ygdcs的博客
09-30 4707
结点（Node）：包含一个元素和若干指向其子树的分支结点的度（Degree）：一个结点拥有的子树的个数称为该节点的度树的度：一棵树的度是指该树中节点的最大度数。叶子（Leaf）结点：树中度为0的结点称为叶子结点或者终端结点。分支结点：树中度不为0的结点称为分支结点或非终端结点。一棵树的结点 除叶子结点外，其余的结点都是非终端结点，除根节点外的非终端节点也称为是内部结点。结点的层次（Level）：结点的层次是从根开始定义，根节点的层次为1，其孩子结点为2。
二叉树基础详解
qq_56999918的博客
11-21 5283
1.树的定义和基本性质 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。有一个特殊的结点，称为根结点，根节点没有前驱结点除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。 ...
二叉树 基础题解
weixin_46708745的博客
11-13 1017
二叉树基础题一.相同的树思路代码二.另一棵树的子树思路代码三.二叉树的最大深度思路代码四.平衡二叉树思路代码五.对称二叉树思路代码 这些问题都有一个类TreeNode。 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode() {} TreeNode(int val) { this.val = val; } TreeNode(int val,
二叉树基础操作
weixin_63178060的博客
10-15 1165
层序遍历相对于前三种遍历，需要用队列进行辅助操作，具体操作：定义一个队列，首先将二叉树的第一个结点入队，while循环判断该队列是否为空，不为空的话，则先进行出队，然后判断该树的左又子树是否为空，不为空则入队。在销毁时，不能先销毁根结点，因为其左子树和右子树是通过根结点访问的，如果根结点先被销毁，则其左子树和右子树在后序程序中无法被访问，会出现错误。满二叉树：一个二叉树，如果其每一层的结点都达到最大值，即结点个数为2^k-1，k为二叉树层数，则该树为满二叉树。（n0为度为0的结点，n2为度为2的结点）
二叉树理论基础
眼映星辰的博客
10-11 725
1. 二叉树的定义 二叉树是每个节点最多有两个子树的树结构。它有五种基本形态：二叉树可以是空集；根可以有空的左子树或右子树；或者左、右子树皆为空。   2. 二叉树的性质 二叉树有以下几个性质：TODO(上标和下标)性质1：二叉树第i层上的结点数目最多为 2{i-1} (i≥1)。性质2：深度为k的二叉树至多有2{k}-1个结点(k≥1)。性质3：包含n个结点的二叉树的高度至少为log...
二叉树——基础知识详解
2302_81016149的博客
05-22 1295
对于二叉树基础的理论知识，我们就学习到这里，虽然这些知识相对后面来说简单一点，但别忘记复习。有了这些预备知识才能够更好的理解后面知识。另外对于递归理解还不够的读者一定要去尽可能的去理解，对于二叉树的学习非常重要。今天的学习就结束了，有问题可在评论区交流，也可私信。我们下篇见！完！
二叉树基础知识概览
lyzzs222的博客
07-20 2120
从树的基础知识到二叉树的基础知识概况，学习高阶二叉树前您准备好了吗？
二叉树基础算法
weixin_45079974的博客
03-21 875
二叉树基本算法
二叉树基础知识和遍历算法等
04-24
### 二叉树基础知识与遍历算法详解 #### 一、二叉树基本概念 **二叉树**是一种特殊的树形结构，在计算机科学领域极为常见。它是一种数据结构，其中每个节点最多有两个子节点，通常被称为左子节点和右子节点。 ###...
python二叉树基础算法实现.pdf
05-07
### Python二叉树基础算法实现详解 #### 一、引言 在计算机科学领域，二叉树是一种重要的数据结构，广泛应用于多种算法和技术之中。它不仅有助于数据的组织与存储，还能有效地支持诸如查找、排序等功能。Python作为...
21_动态规划与数据结构结合
刘炫320的博客
09-11 475
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储
BamBoo_Bean的博客
09-10 659
C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储
数据结构——线性表（顺序存储结构和单链表结构）
weixin_74209413的博客
09-08 894
线性表（List）：由零个或多个数据元素组成的有限序列。（1）它是一个序列，也就是元素之间有个先来后到的；（2）若元素有多个，则第一个元素无前驱，最后一个无后继；（3）线性表是有限的；原子类型：不可以再分解的基本类型，例如整形、浮点型、字符型等结构类型：由若干个类型组合而成，是可以再分解的，例如整形数组是由若干个整形数据组成的。抽象数据类型抽象数据类型是指一个数学模型及定义在该模型上的一组操作；抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。
数据结构 1
最新发布
2401_83575662的博客
09-14 335
算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为 输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《程序员代码面试指南》。4.算法的效率衡量一个算法的好坏，要从它的程序的时间复杂度和空间复杂度两方面来分析。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。5.时间复杂度。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Leekuangyee

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

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

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

打赏作者

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

抵扣说明：

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

余额充值