6.二叉树.题目1

已于 2024-08-21 12:07:36 修改
阅读量834 收藏 14
点赞数 21
分类专栏： 数据结构 文章标签： 数据结构 c++
于 2024-06-25 13:55:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43831098/article/details/139801388
版权

6.二叉树.题目

题目

1.翻转二叉树

题目链接
直观的思路是就把每一个节点的左右孩子交换一下就可以了，
深度优先-递归法
前序，后序遍历方法都没有问题，但中序的递归法会存在问题。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==nullptr) return root;
        // 前序遍历
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

深度优先-迭代法
在迭代法-统一写法下，前序，后序遍历方法都没有问题，就是在while循环else接口处设置std::swap()函数交换左右子节点的位置。但是唯独中序遍历不方便，因为中序遍历会把某些节点的左右子节点翻转了两次。解释：因为中序遍历的特殊点：不同于前序，后序在遍历过程中在一开始，或结尾处交换左右子节点的位置，而中序在交换左，右子节点中间调换了左右子节点，所以第二个递归参数应该是现在的左子树才是原来的右子树。

    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
                st.push(node);                          // 中
                st.push(NULL);
            } else {
                st.pop();
                node = st.top();
                st.pop();
                swap(node->left, node->right);          // 节点处理逻辑
            }
        }
        return root;
    }

2.对称二叉树

题目链接
给定一个二叉树，检查它是否是镜像对称的。对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。
在这里插入图片描述
递归法
终止条件为：子树头节点L，R的节点数值不相等以及头节点出现节点为nullptr的情况
1.左节点为空，右节点不为空，不对称，return false
2.左节点不为空，右节点为空，不对称 return false
3.左右节点都为空，对称，返回true

然后就可以单层递归的逻辑，单层递归的逻辑就是处理左右子树头节点都不为空，且数值相同的情况
1.比较两子树外侧头节点：传入的是左节点的左节点，右节点的右节点。
2.比较两子树内侧头节点：传入左节点的右节点，右节点的左节点。
3.如果左右节点都对称就返回true ，有一侧不对称就返回false，使用与逻辑运算符 。

    bool compare(TreeNode* left, TreeNode* right){
    	// 处理不同左右节点的终止条件
        if(left == nullptr && right != nullptr) return false;
        else if(left != nullptr && right == nullptr) return false;
        else if(left == nullptr && right == nullptr) return true;
        else if(left->val != right->val) return false;

        bool outside = compare(left->left, right->right);
        bool intside = compare(left->right, right->left);
        bool isame = outside && intside;
        return isame;
    }

    bool isSymmetric(TreeNode* root) {
        if(root==nullptr) return true;
        return compare(root->left, root->right);
    }

深度优先-迭代法
迭代法，其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的，主要是比较的子节点的逻辑不错：left->left与right->right，left->right与right->left进行比较，使用队列queue，堆stack都能实现该功能。

    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);   // 将左子树头结点加入队列
        que.push(root->right);  // 将右子树头结点加入队列
        
        while (!que.empty()) {  // 接下来就要判断这两个树是否相互翻转
            TreeNode* leftNode = que.front(); que.pop();
            TreeNode* rightNode = que.front(); que.pop();
            if (!leftNode && !rightNode) {  // 左节点为空、右节点为空，此时说明是对称的
                continue;
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
                return false;
            }
            que.push(leftNode->left);   // 加入左节点左孩子
            que.push(rightNode->right); // 加入右节点右孩子
            que.push(leftNode->right);  // 加入左节点右孩子
            que.push(rightNode->left);  // 加入右节点左孩子
        }
        return true;
    }

3.二叉树的最大深度

题目链接
二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）

本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。
这题在二叉树的层序遍历的求二叉树最大深度里提及到了。

深度优先-递归法

// 使用了后序搜索
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        int left = maxDepth(root->left);
        int right = maxDepth(root->right);
        int depth = 1+max(left, right);
        return depth;
    }
};

// 使用了前序搜索
class Solution {
private:
    int depth;
    void coutdepth(TreeNode* root, int deep){
        if(root==nullptr) return;
        if(root->left == nullptr && root->right == nullptr) depth = max(deep, depth);
        if(root->left) coutdepth(root->left, deep+1);
        if(root->right) coutdepth(root->right, deep+1);
        return;
    }
public:

    int maxDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        coutdepth(root, 1);
        return depth;
    }
};

4.二叉树的最小深度

题目链接
这与求最大深度有点不同，最小深度是从根节点到最近叶子节点的最短路径上的节点数量。注意是叶子节点，叶子节点是没有子节点的节点。
在这里插入图片描述
递归法

// 后序搜索-递归
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        int left = minDepth(root->left);
        int right = minDepth(root->right);
        if(root->left==nullptr) return 1+right;
        else if(root->right==nullptr) return 1+left;
        else return 1+min(left,right);
    }
};

// 前序搜索-递归
class Solution {
private:
    int depth;
    void coutdepth(TreeNode* root, int deep){
        if(root==nullptr) return;
        if(root->left==nullptr && root->right==nullptr) depth=min(depth, deep);
        if(root->left) coutdepth(root->left, deep+1);
        if(root->right) coutdepth(root->right, deep+1);
        return;
    }
public:
    int minDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        depth = INT_MAX;
        coutdepth(root, 1);
        return depth;
    }
};

因此需要在求最大深度的代码种，除了将max改为min，还需要加入两个if的判断，以返回其单子节点的情况。

5.完全二叉树的节点个数

题目链接
对于普通的二叉树，我们使用任意遍历方法，统计二叉树中节点的数量即可。
递归法
求左子节点的数量，求右子节点的数量，最后把两者取和+1，就得到该节点（包含自己）的节点数量。

    int getNodesNum(TreeNode* cur) {
        if (cur == NULL) return 0;
        int leftNum = getNodesNum(cur->left);      // 左
        int rightNum = getNodesNum(cur->right);    // 右
        int treeNum = leftNum + rightNum + 1;      // 中
        return treeNum;
    }

此时时间复杂度是：O(n)，空间复杂度是O(log n)。
对于深度优先，广度优先-迭代法，只要在遍历到的节点时，令变量result+1即可。

对于完全二叉树
在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。并且完全二叉树只有两种情况，情况一：就是满二叉树；情况二：最后一层叶子节点没有满。

  1. 如何计算子节点的数量？可以通过判断其子树是不是满二叉树，如果是则利用==公式（2^depth-1）==计算这个子树（满二叉树）的节点数量，如果不是则继续下一层检查，直至找到满二叉树的子树，或者叶子节点。
  2. 如何判断是否是满二叉树？在完全二叉树的条件下，若向左遍历深度等于向右遍历深度，则该二叉树是满二叉树。
class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root==nullptr) return 0;
        TreeNode* left = root->left;
        TreeNode* right = root->right;
        int left_d = 0, right_d = 0;
        while(left){
            left = left->left;
            left_d++;
        }
        while(right){
            right = right->right;
            right_d++;
        }
		// 找到满二叉树，则计算返回
        if(left_d==right_d) return pow(2,left_d+1) -1;
		// 进入下一层遍历
        int leftnum = countNodes(root->left);
        int rightnum = countNodes(root->right);
        int res = leftnum + rightnum + 1;
        return res;
    }
};

此时时间复杂度是： O ( l o g n × l o g n ) O(log n × log n) O(logn×logn)，空间复杂度是 O ( l o g n ) O(log n) O(logn)。

6.平衡二叉树

题目链接
给定一个二叉树，判断它是否是高度平衡的二叉树：一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1。
注意高度和深度的区别。在维基上以边为一度，但leetcode上以节点为一度，笔记以leetcode为准。
在这里插入图片描述
前序遍历是求二叉树节点深度相关的问题，使用后序遍历符合求解二叉树节点的高度相关的问题（另外根节点的高度就是这棵树的最大深度）：
终止条件依然是节点是否为空；单层递归逻辑是，分别求左右子节点的高度，并判断两者高度差，若高度差小于等于1，返回该节点的最大高度，若高度差大于1则返回其高度为-1（正常而言节点的高度>0），这样就会使上层的节点高度返回值均大于1，最后返回-1，以-1为标志位。
递归法

    int geteHeight(TreeNode* root){
    	// 终止条件
        if(root==nullptr) return 0;
        // 单层递归逻辑
        int leftH = geteHeight(root->left);
        if(leftH==-1) return -1;
        int rihgtH = geteHeight(root->right);
        if(rihgtH==-1) return -1;
        return abs(leftH-rihgtH)>1? -1:1+max(leftH, rihgtH);
    }

    bool isBalanced(TreeNode* root) {
        return geteHeight(root) == -1? false : true;
    }

迭代法
需要预拟定一个函数-求节点高度（后序遍历）；然后在前序遍历中，找每一个节点的高度，对比左右子节点的高度差是否满足条件即可。

7.二叉树的所有路径

题目链接
给定一个二叉树，返回所有从根节点到叶子节点的路径。因此这类似根节点深度的求法，只是终止条件改变为了该节点的左右子节点是否为空，题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。
递归法
在使用递归法的时候，切记回溯和递归是一一对应的，有一个递归，就要有一个回溯。

	// path作为引用传入，在递归回溯时需要pop_back
    void traversal(TreeNode* root, std::vector<int>& path, std::vector<std::string>& result){
        path.push_back(root->val); //path添加当前节点值
        if(root->left==nullptr && root->right==nullptr){
            std::string sPath;
            for(int i=0; i<path.size()-1; i++){
                sPath += to_string(path[i]);
                sPath += "->";
            }
            sPath += to_string(path[path.size()-1]);
            result.push_back(sPath);
            return;
        }
        // 单层递归逻辑
        if(root->left){
            traversal(root->left, path, result);
            path.pop_back(); //回溯
        }
        if(root->right){
            traversal(root->right, path, result);
            path.pop_back(); //回溯
        }
    }

    vector<string> binaryTreePaths(TreeNode* root) {
        std::vector<std::string> result;
        std::vector<int> path;
        if(root==nullptr) return result;
        traversal(root, path, result);
        return result;
    }

// 简化版
class Solution {
private:
    void traversal(TreeNode* root, string path, vector<string>& res){
        path += to_string(root->val);
        if(root->left==nullptr && root->right==nullptr){
            res.push_back(path);
            return;
        }
        if(root->left) traversal(root->left, path+"->", res);
        if(root->right) traversal(root->right, path+"->", res);
    }

public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> res;
        string path;
        traversal(root, path, res);
        return res;
    }
};

8.左叶子之和

题目链接
这道题目要求左叶子之和，其实是比较绕的，因为不能判断本节点是不是左叶子节点，需要通过通过节点的父节点判断本节点的属性。因此需使用后序遍历的方法。

因此递归的终止条件应该是 判断到达叶子节点
单层递归逻辑是 求该子树的左叶子节点的和
递归法

    int sumOfLeftLeaves(TreeNode* root) {
        if(root == nullptr) return 0;
        if(root->left==nullptr && root->right==nullptr) return 0;
        int leftvalue = sumOfLeftLeaves(root->left);
        int rightval = sumOfLeftLeaves(root->right);
        if(root->left && !root->left->left && !root->left->right){
            leftvalue = root->left->val;
        }
        int sum = leftvalue + rightval;
        return sum;
    }

迭代法

    int sumOfLeftLeaves(TreeNode* root) {
        stack<TreeNode*> st;
        if (root == NULL) return 0;
        st.push(root);
        int result = 0;
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
                result += node->left->val;
            }
            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
        }
        return result;
    }

总结

  1. 递归函数什么时候需要返回值？什么时候不需要返回值？以下总结三点：

    • 如果需要搜索二叉树且不用处理递归返回值，递归函数就不要返回值
    • 如果需要搜索二叉树且需要处理递归返回值，递归函数就需要返回值。
    • 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径就要及时返回。

  2. 思考如何根据两个顺序构造唯一一个二叉树

    • 以后序数组的最后一个元素为切割点，先切中序数组，根据所切割的左中序数组大小作为切割点，反过来再切后序数组
    • 一层一层地切下去，每次后序数组最后一个元素就是节点元素
      因为后序数组的最后一个元素必为最深的父节点，而中序数组中相邻的元素会被父节点所切割
      在这里插入图片描述

  3. 构造树一般采用前序遍历，因为先构造中间节点，再构造左，右子节点。

janedipan
关注
专栏目录
第6章二叉树答案.
06-19
- **知识点**：题目中描述的是二叉排序树的性质，而非所有二叉树的性质。 - **解析**：二叉排序树的特性之一是每个节点的关键字大于其左子树中所有节点的关键字，小于其右子树中所有节点的关键字。这并不适用于...
二叉树基础（二）
YiYeZhiNian的博客
01-15 598
关于二叉树的特性很多，这里只是做了一个很简单的总结。二叉树的基本操作主要可以分为以下几类： 1、前序遍历、中序遍历、后序遍历 关于二叉树的前序遍历、中序遍历、后序遍历参看上一篇二叉树基础。 具体的求解方式主要通过递归的方式求解该问题。递归的思想在求解很多问题上都是非常实用的。这里给出一个中序遍历的例子： 对于上述这个二叉树，我们可以通过下面的代码进行递归。 void traversal(TreeNode* cur, vector<int>& vec) { if
题目整理(二叉树).pdf
08-26
1. 建立二叉树的二叉链表： - 通过完全二叉树的先序序列建立二叉链表时，使用#代表空结点。 - 已知先序遍历序列和中序遍历序列建立二叉树。 - 已知中序遍历序列和后序遍历序列建立二叉树。 2. 遍历二叉树： - ...
leetcode-4.28[107. 二叉树的层次遍历 II、101. 对称二叉树、104. 二叉树的最大深度]（python解法）
01-20
题目1 原创文章 81获赞 40访问量 3万+ 关注 私信 展开阅读全文 作者：Leadingme
leetcode 104. 二叉树的最大深度（C++）
12-22
python版——>leetcode 104：二叉树的最大深度(python) 文章目录题目层次遍历法递归法 题目 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有...
[力扣]144. 二叉树的前序遍历java
12-21
对于给定的题目，我们需要编写一个Java程序来实现二叉树的前序遍历，并返回一个包含所有节点值的列表。 在Java中，我们可以定义一个`TreeNode`类来表示二叉树的节点，如下所示： ```java public class TreeNode { ...
通用型函数——冒泡排序
2401_84654619的博客
10-29 417
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
数据结构和算法-动态规划(3)-经典问题
qq_36115196的博客
10-30 841
动态规划(Dynamic Programming): 计算并存储小问题的解， 并将这些解组合成大问题的解。
java-数据结构
2301_80708315的博客
10-30 1005
如果使用 left < right 作为条件，那么在最后一次迭代中，当 left 和 right 相邻时（即 left = right - 1），循环就会提前终止，从而可能错过目标元素（如果它正好位于 left 或 right 指向的位置）。left ==right 意味着它们指向的元素也会参与比较，left < right 只意味着middle指向的元素参与比较。l为总循环次数，当元素在最右边与最左边时的循环次数不一致。eg 当我的数组为{1，23，45，77，123}时我查找12时就会返回。
【数据结构篇】探索堆的算法的巧妙
braveact的博客
11-02 569
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
数据结构，问题 F: 括弧匹配检验
nick_912912的博客
11-02 211
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
数据结构初识及顺序表详解
chuxinweihui的博客
11-01 960
我们在写程序的时候，会出现许多的数据，如果我们想要修改某一个值或者删除和添加一个数据的时候就会非常困难，尤其是数据量庞大的时候，这时候数据结构就出来了。
[数据结构]插入排序(全)
2401_83816455的博客
10-30 233
因为直接插入排序时间复杂度最好是O(n),最坏是O(n^2），最坏情况是排序对象是降序排列的，希尔通过把排列对象划分成若干部分，这些部分内部进行直接插入排序，粗略把排序对象排列成升序，从而优化排序过程，也即是希尔把直接插入排序的最坏情况避免了。插入排序分为直接插入排序和希尔排序，希尔排序是在直接插入排序的基础上做出的优化版本(原因后面解释)。
python的数据结构列表方法及扩展（栈和队列）
闲来垂钓碧溪上的博客
10-30 532
! 使用示例： 使用示例 使用示例： 练习题目1： 练习题目2： collections.deque()队列 列表推导式 从序列中创建新的列表的简单途径，将操作应用于每一个元素，获得新的列表。示例1： 示例： 使用示例： 不仅如此，元组、序列、字典、集合都属于python的数据结构具体使用示例:
C语言_数据结构_顺序表
最新发布
m0_74445256的博客
11-02 271
本章重点在于对顺序表的增删查改操作~
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 305
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
java常用数据结构及其接口
weixin_48485132的博客
10-29 458
**LinkedList（作为 Queue 和 Deque）**：同时支持队列和双端队列操作。- **ArrayList**：动态数组，支持快速随机访问，但在插入和删除操作时可能较慢。- **PriorityQueue**：基于优先级的队列，元素根据自然排序或比较器排序。- **LinkedList**：双向链表，适合频繁插入和删除操作。- **TreeSet**：有序集合，使用红黑树实现。- **HashMap**：键值对存储，允许快速查找。- **HashSet**：不允许重复元素，无序。
代码随想录：从中后/中前遍历序列构造二叉树
qq_74924951的博客
10-30 299
两种遍历生成二叉树
【数据结构】堆的实现
2302_81312180的博客
11-02 917
基本思想： 向堆尾插入新元素时，维护堆的性质，需要对该元素向上调整，从新插入的节点开始，与其父节点比较，若新节点的值比其父节点的值小，则交换它们，并将新节点的父节点当作目标节点继续向上调整，若目标结点的值比其父结点的值大，就停止向上调整，此时该树已成堆。（以小堆调整为例） 若想将此二叉树调整为小堆，左右子树都必须是一个小堆，才能调整。 若想将此二叉树调整为大堆，左右子树都必须是一个大堆，才能调整。
题目：二叉树的基本操作 实验要求：使用二叉链表存储结构建立一棵二叉树，完成如下功能： 1.创建二叉树 2.先序遍历二叉树 3.中序遍历二叉树 4.后序遍历二叉树 5.求二叉树深度（高度） 6.求二叉树叶子结点个数
04-27
具体而言，这个题目要求你使用二叉链表存储结构建立一棵二叉树，并实现以下操作： 1. 创建二叉树：按照输入序列构造一棵二叉树 2. 先序遍历二叉树：按照"根-左-右"的顺序遍历二叉树 3. 中序遍历二叉树：按照"左-根-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值