二叉树及相关的Oj题

最新推荐文章于 2023-02-27 21:37:21 发布
最新推荐文章于 2023-02-27 21:37:21 发布
阅读量906 收藏 2
点赞数
文章标签： 数据结构 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44758862/article/details/109136631
版权

1.树

1.1 概念

树是一种非线性的数据结构，它是由n(n>=0)个结点构成的具有层次关系的集合。

  • 有一个特殊的节点，称为根节点，根节点没有前驱节点
  • 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合 Ti (1 <= i<= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继
  • 树是递归定义的。
    在这里插入图片描述

1.节点的度：一个节点含有的子树的个数称为该节点的度；
2.树的度：一棵树中，最大的节点的度称为树的度；
3.叶子节点或终端节点：度为0的节点称为叶节点；
4.双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
5.孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
6.根结点：一棵树中，没有双亲结点的结点；
7.节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
8.树的高度或深度：树中节点的最大层次；
9.非终端节点或分支节点：度不为0的节点；
10.兄弟节点：具有相同父节点的节点互称为兄弟节点；点
11堂兄弟节点：双亲在同一层的节点互为堂兄弟；
12.节点的祖先：从根到该节点所经分支上的所有节点；
13.子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
14.森林：由m（m>=0）棵互不相交的树的集合称为森林

在这里插入图片描述

2 二叉树

2.1 概念

一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉
树组成。
二叉树的特点：

  1. 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。
  2. 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。

2.2 二叉树的基本形态

在这里插入图片描述
从左往右依次是：空树、只有根节点的二叉树、节点只有左子树、节点只有右子树、节点的左右子树均存在，一般二叉树都是由上述基本形态结合而形成的。

2.3 两种特殊的二叉树

  1. 满二叉树: 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
  2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
    在这里插入图片描述

2.4 二叉树的性质

  1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 2i-1(i>0)个结点
  2. 若规定只有根节点的二叉树的深度为1，则深度为K的二叉树的最大结点数是2k-1 (k>=0)
  3. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
  4. 具有n个结点的完全二叉树的深度k为log(n+1) 上取整
  5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i
    的结点有：
    若i>0，双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
    若2i+1<n，左孩子序号：2i+1，否则无左孩子
    若2i+2<n，右孩子序号：2i+2，否则无右孩子

2.5 二叉树的存储

二叉树的存储结构分为：顺序存储和类似于链表的链式存储。

2.6 二叉树的基本操作

2.6.1 二叉树的遍历

Node结点

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

递归遍历

  • 前序遍历：
public void preOrder(TreeNode root){
        if(root!=null){
            System.out.println(root.val);
            preOrder(root.left);
            preOrder(root.right);
        }
    }
  • 中序遍历：
public void inOrder(TreeNode root){
        if(root!=null){   
            inOrder(root.left);
            System.out.println(root.val);
            inOrder(root.right);
        }
    }
  • 后序遍历：
public void postOrder(TreeNode root){
        if(root!=null){   
            postOrder(root.left);
            postOrder(root.right);
            System.out.println(root.val);
        }
    }

非递归调用

  • 前序遍历
public void preOrder2(TreeNode root){
        if(root==null){
            return;
        }
        Deque<TreeNode>stack=new LinkedList<>();
        TreeNode current=root;
        while(!stack.isEmpty()||current!=null){
            while(current!=null){
                System.out.println(current.val);
                stack.push(current);
                current=current.left;
            }
            TreeNode node=stack.pop();
            current=node.right;
        }
    }
  • 中序遍历
   public void inOrder2(TreeNode root){
        if(root==null){
            return;
        }
        Deque<TreeNode>stack=new LinkedList<>();
        TreeNode current=root;
        while(!stack.isEmpty()||current!=null){
            while(current!=null){
                stack.push(current);
                current=current.left;
            }
            TreeNode node=stack.pop();
            System.out.println(node.val);
            current=node.right;
        }
    }
  • 后序遍历
public void postOrder1(TreeNode root){
        if(root==null){
            return;
        }
        Deque<TreeNode>stack=new LinkedList<>();
        TreeNode current=root;
        TreeNode last=null;
        while(!stack.isEmpty()||current!=null){
            while(current!=null){
                stack.push(current);
                current=current.left;
            }

            TreeNode node=stack.peek();
            if(node.right==null){
                last=node;
                stack.pop();
                System.out.println(node.val);
            }else if(node.right==last){
                last=node;
                stack.pop();
                System.out.println(node.val);
            }else{
                current=node.right;
            }

        }
    }
  • 层序遍历
public void levelOrderTraversal(TreeNode root){
        if(root==null){
            return;
        }
        Queue<TreeNode>queue=new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.remove();
            System.out.println(node.val);
            if(node.left!=null){
                queue.add(node.left);
            }
            if(node.right!=null){
                queue.add(node.right);
            }
        }
    }

2.6.2其他操作

  • 遍历思路-求结点个数
static int size=0;
    public void getSize1(TreeNode root){
        if(root!=null){
            size++;
            getSize1(root.left);
            getSize1(root.right);
        }
    }
  • 子问题思路-求结点个数
public int getSize(TreeNode root){
        if(root==null){
            return 0;
        }
        return getSize(root.left)+getSize(root.right)+1;
    }
  • 遍历思路-求叶子结点个数
 static int leafSize = 0;
    public void getLeafSize1(TreeNode root){
        if(root!=null){
            if(root.left==null&&root.right==null){
                leafSize++;
            }
            getLeafSize1(root.left);
            getLeafSize1(root.right);
        }
    }
  • 子问题思路-求叶子结点个数
public int getLeafSize2(TreeNode root){
        if(root==null){
            return 0;
        }
        if(root.left==null&&root.right==null){
            return 1;
        }
        return getLeafSize2(root.left)+getLeafSize2(root.right);
    }
  • 子问题思路-求第 k 层结点个数
public int getKLevelSize(TreeNode root,int k){
        if(root==null){
            return 0;
        } else if(k==1){
            return 1;
        }
        return getKLevelSize(root.left,k-1)+getKLevelSize(root.right,k-1);
    }
  • 获取二叉树的高度
public int getHeight(TreeNode root){
        if(root==null){
            return 0;
        }
        return 1+Math.max(getHeight(root.left),getHeight(root.right));
    }
    }
  • 查找 val 所在结点，没有找到返回 null
public TreeNode find(TreeNode root, int val){
        if(root==null){
            return null;
        }
        if(root.val==val){
            return root;
        }
        TreeNode node=find(root.left,val);
        if(node!=null){
            return node;
        }
        return find(root.right,val);
    }
  • 判断一棵树是否是一个完全二叉树
 public boolean isCompleteTree(TreeNode root){
        if(root==null){
            return false;
        }
        Queue<TreeNode>queue=new LinkedList<>();
        queue.add(root);
        while(true){
            TreeNode node = queue.remove();
            if(node==null){
                break;
            }
            queue.add(node.left);
            queue.add(node.right);
        }
        while(!queue.isEmpty()){
            TreeNode node=queue.remove();
            if(node!=null){
                return false;
            }
        }
        return true;
    }

3.相关Oj题

给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
来源：力扣（LeetCode）

public boolean isSameTree(TreeNode p, TreeNode q) {
        //当两棵树都是空树的时候这两棵树是相同的树
        if(p==null&&q==null){
            return true;
        }
        //程序能走到这里说明其中一棵树是空树一棵树不是空树，则不是相同的树
        if(p==null||q==null){
            return false;
        }
        //当两颗树的根的val相同，左右子树都相同时是相同的树，否则不是
        return p.val==q.val&&isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
    }
  • 力扣572.另一个树的子树
    链接

给定两个非空二叉树 s 和 t，检验 s 中是否包含和 t 具有相同结构和节点值的子树。s 的一个子树包括 s 的一个节点和这个节点的所有子孙。s 也可以看做它自身的一棵子树。
来源：力扣（LeetCode）

    public boolean isSameTree(TreeNode p, TreeNode q) {
        //当两棵树都是空树的时候这两棵树是相同的树
        if(p==null&&q==null){
            return true;
        }
        //程序能走到这里说明其中一棵树是空树一棵树不是空树，则不是相同的树
        if(p==null||q==null){
            return false;
        }
        //当两颗树的根的val相同，左右子树都相同时是相同的树，否则不是
        return p.val==q.val&&isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
    }
    public boolean isSubtree(TreeNode s, TreeNode t) {
        if(s==null){
            return false;
        }
        //是子树就说明t与s的一部分是相同的树，就从根->左子树->右子树进行判断
        if(isSameTree(s,t)){
            return true;
        }
        if(isSubtree(s.left,t)){
            return true;
        }
        return isSubtree(s.right,t);
    }
  • 力扣110.平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

 public int maxDepth(TreeNode root) {
            if(root==null){
                return 0;
            }
            return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
    }
    public boolean isBalanced(TreeNode root) {
        if(root==null){
            return true;
        }
        if(Math.abs(maxDepth(root.left)-maxDepth(root.right))>1){
            return false;
        }
        if(!isBalanced(root.left)){
            return false;
        }
        return isBalanced(root.right);
    }
  • 力扣101.对称二叉树

给定一个二叉树，检查它是否是镜像对称的

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
   public boolean isImageTree(TreeNode p, TreeNode q){
        if(p==null&&q==null){
            return true;
        }
        if(p==null||q==null){
            return false;
        }
        return p.val==q.val&&isImageTree(p.left,q.right)&&isImageTree(p.right,q.left);
    }
    public boolean isSymmetric(TreeNode root) {
        if(root==null){
            return true;
        }
        return isImageTree(root.left,root.right);
    }
}

编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串：ABC##DE#G##F### 其中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果
链接

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

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
    public String toString(){
        return String.format("TreeNode{%d}",this.val);
    }
}
public class Main {
    private static List<Character> arrayToList(String str){
        char[] chars = str.toCharArray();
        List<Character>list=new ArrayList<>();
        for(char c:chars){
            list.add(c);
        }
        return list;
    }
    public static TreeNode buildTree(List<Character> in, List<Character> out){
        if(in.isEmpty()){
            return null;
        }
        Character c = in.remove(0);
        TreeNode root=new TreeNode(c);

        if(c=='#'){
            out.addAll(in);
            return null;
        }
        List<Character>innerList=new LinkedList<>();
         root.left=buildTree(in,innerList);
         root.right=buildTree(innerList,out);

         return root;
    }
    private static void preOrder(TreeNode root){
        if(root!=null){
            preOrder(root.left);
            System.out.printf("%c ", root.val);
            preOrder(root.right);
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        List<Character> in=arrayToList(s);
        List<Character>out=new LinkedList<>();
        
        TreeNode root = buildTree(in, out);
        preOrder(root);

    }
}
  • 力扣102 二叉树的遍历
    链接

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例：
在这里插入图片描述

 class TreeNode {
    public TreeNode left;
    public TreeNode right;
    public int val;
    TreeNode(int val){
        this.val=val;
    }
}
 static class NL{
        TreeNode node;
        int level;
        NL(TreeNode node,int lev){
            this.node=node;
            this.level=lev;
        }
    }
    public List<List<Integer>> levelOrder(TreeNode root){
        List<List<Integer>>list=new LinkedList<>();
        if(root==null){
            return list;
        }
        Queue<NL>queue=new LinkedList<>();
        queue.add(new NL(root,0));
        while(!queue.isEmpty()){
            NL node=queue.remove();
            int lev=node.level;
            TreeNode node1=node.node;
            if(list.size()==lev){
               list.add(new LinkedList<>());
            }
            List<Integer> list1=list.get(lev);
            list1.add(node1.val);
            if(node1.left!=null){
                queue.add(new NL(node1.left,node.level+1));
            }
            if(node1.right!=null){
                queue.add(new NL(node1.right,node.level+1));
            }
        }
        return list;
    }
  • 力扣236.二叉树的最近祖先
    链接

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
来源：力扣（LeetCode）

class Solution {
    private static boolean search(TreeNode root,TreeNode node){
        if(root==null){
            return false;
        }
        if(root==node){
            return true;
        }
        if(search(root.left,node)){
            return true;
        }
        return search(root.right,node);
    }
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
         if (root == p || root == q) {
            return root;
        }
        boolean pInleft=search(root.left,p);
        boolean qInleft=search(root.left,q);
        if(qInleft&&pInleft){
            return lowestCommonAncestor(root.left,p,q);
        }
        if(!qInleft&&!pInleft){
            return lowestCommonAncestor(root.right,p,q);
        }
        return root;
    }
}
Yukle
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
oj题.zip
10-18
这些文件名看起来是编程题目，很可能来源于在线编程竞赛（Online Judge，简称OJ）平台，如LeetCode、Codeforces或HackerRank等。每个.py文件可能代表一个独立的编程问题解决方案，采用Python语言编写。接下来，我们...
【数据结构】——二叉树oj题详解
weixin_62678196的博客
09-01 784
二叉树的OJ题详解
11.21二叉树oj
m0_72618437的博客
11-21 228
11.21二叉树
九度OJ 1113 二叉树（完全二叉树）
weixin_30307267的博客
03-26 171
原题地址： http://ac.jobdu.com/problem.php?pid=1113 （由于原始版面的排版实在有些不好看，所以就不贴过来啦。CSDN旧版的编辑器适应不了，这次尝试用markdown写） 解题思路 题意：给定一棵共有节点数为n的完全二叉树，对它每一层的节点从左到右编号，第一层为1，第二层为2、3，第三层为4、5、6、7……然后输入一个编号...
swust oj 987完全二叉树
weixin_45018958的博客
05-05 1345
swust oj的第987题 利用队列判断是否是完全二叉树 http://acm.swust.edu.cn/#/problems/987/271?_k=j2kydc 完全二叉树是指深度为h，除h层外其他各层结点都到达最大个数，且第h层的结点都集中在左边的二叉树 思路： 如果数为空树，直接返回false； 如果结点h左右孩子结点都存在则将其左右孩子入队列把该结点出队列； 如果结点h左孩子存在但右孩子...
Java 【数据结构OJ题十道】—— 二叉树篇2
yzhcjl_的博客
02-27 649
收录十道[二叉树]相关OJ题,第二篇~~
程序设计基础 OJ 题库 NUIST
10-22
WorkSpace文件可能包含了你在OJ平台上做题时的工作目录，其中可能包括源代码文件、测试数据、编译和运行的结果等。通过查看和分析这个工作空间，你可以回顾和改进你的解题思路，也可以与其他同学交流分享经验。 总...
平顶山学院OJ试题离线版
05-14
【平顶山学院OJ试题离线版】是一款专为平顶山学院的学生和教师设计的编程在线评测系统（Online Judge，简称OJ）的离线版本。它包含了丰富的编程题目，涵盖了计算机科学与技术、软件工程等多个学科的课程内容，旨在...
西南科技大学SWUST OJ 数据结构 树和二叉树答案 树和二叉树.zip
01-01
西南科技大学（SWUST）的在线编程平台（OJ）提供了关于这些主题的编程题目，帮助学生深入理解和应用这些知识。以下是对这些题目涉及知识点的详细解析： 1. **基本概念**： - **树**：树是一种非线性的数据结构，由...
cd.zip_THU OJ_oj_reconfiguration_thu dsa_重构 二叉树
09-23
在本压缩包“cd.zip_THU OJ_oj_reconfiguration_thu dsa_重构 二叉树”中，主要涉及的是清华大学（THU）在线判题系统（Online Judge，简称OJ）上的一个编程挑战，具体是关于二叉树的重构问题。这个任务涉及到的数据...
二叉树实现源代码 经典版
11-01
二叉树实现源代码 经典版c++源码 *建立二叉树算法描述： 用ch扫描采用括号表示法表示二叉树的字符串Str。分以下几种情况： 1、若ch='('则将前面刚创建的结点作为双亲结点进栈，并置k=1,表示其后创建的结点将做为这个结点的左孩子 结点。 2、若ch=')'表示栈中结点的左右孩子结点处理完毕，退栈。 3、若ch=','表示其后创建的结点为右孩子结点 4、其他情况表示要创建一个结点，并根据k值建立它与栈中结点之间的关系，当k=1时，表示这个结点作为栈中 结点的左孩子结点，当k=2时，表示这个结点作为栈中结点的右孩子结点。如此循环直到str处理完毕。算法中 使用一个栈st保存双亲结点，top为其栈指针，k指定其后处理的结点是双亲结点（保存在栈中）的左孩子结点 （k=1）还是右孩子结点（k=2）。 */
【数据结构】二叉树 —— 浅_刷 - OJ练习题
上上谦. 的博客
05-05 816
文章目录前言 前言 二叉树初期学习中最重要的是二叉树的遍历过程 —— 递归 递归这中最重要的思想便是分治的思想 二叉树的遍历以及递归的分治思想 👉 传送门.
【数据结构与算法】二叉树OJ练习题
weixin_63726869的博客
08-17 464
详细讲解了一些二叉树的OJ练习题和几道常见的选择题。
1043. 完全二叉树（上海交大OJ）
xyqqwer的博客
09-27 964
1043. 完全二叉树 Description 给出一棵二叉树，判断其是否为完全二叉树。 Input Format 第一行，N&lt;1000000，表示二叉树节点数。 默认序号为0的节点为树根。接下来共N-1行，依次表示序号为1，...，N-1的节点的父亲节点序号。 如果一个节点有两个孩子节点，左孩子节点序号总是小于右孩子节点序号。 Output Format 仅一行，如果是完全...
输出用先序遍历创建的二叉树是否为完全二叉树的判定结果 swustoj
yyx的博客
04-25 1845
输出用先序遍历创建的二叉树是否为完全二叉树的判定结果 1000(ms) 10000(kb) 2007 / 4239利用先序递归遍历算法创建二叉树并判断该二叉树是否为完全二叉树。完全二叉树只能是同深度的满二叉树缺少最后一层倒数连续个叶子结点。先序递归遍历建立二叉树的方法为：按照先序递归遍历的思想将对二叉树结点的抽象访问具体化为根据接收的数据决定是否产生该结点从而实现创建该二叉树的二叉链表存储结构。约...
九度OJ 教程34 （完全二叉树）树的查找
DNA的DFA
02-17 445
题目地址：http://ac.jobdu.com/problem.php?cid=1040&pid=33 //九度OJ 教程34 树的查找 顺便复习了一下二分求幂法。 //http://ac.jobdu.com/problem.php?cid=1040&pid=33 #include #define MAXS 1002 int fang(int d,int k) { if(k
判断是不是完全二叉树
yiqzq的博客
05-10 493
根据完全二叉树的定义，对完全二叉树按照从上到下、从左到右的层次遍历，应该满足一下两条要求： ●某节点没有左孩子，则一定无右孩子 ●若某节点缺左或右孩子，则其所有后继一定无孩子 若不满足上述任何一条，均不为完全二叉树。 #include &lt;bits/stdc++.h&gt; using namespace std; typedef struct node { char da...
Just oj 2018 C语言程序设计竞赛（高级组）H: CBT?（完全二叉树）
aeipyuan
12-03 338
H: CBT? 时间限制: 1 s      内存限制: 128 MB      提交 我的状态 题目描述 对于二叉树，如果这棵树的节点排布是按行从上到下，每行从左到右挨个放置，中间不会有空闲的节点。则我们称之为完全二叉树。 注：这棵树的根节点的值一定是1 输入 输入数字正整数n （1≤n≤201≤n≤20） 接下来n行，每行为两个数字(a,b)和一个字符c(L 或者 R)，如果字符c是L，...
东华大学oj二叉树查找双亲
最新发布
06-02
好的，关于东华大学OJ上二叉树查找双亲的问题，我可以给你一些提示。在二叉树中，每个节点都有一个左子节点和一个右子节点，除了根节点没有父节点以外，其他所有节点都有且仅有一个父节点。因此，查找某个节点的父...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值