【算法篇】二叉树类（3）（笔记）

最新推荐文章于 2024-09-28 21:20:29 发布
最新推荐文章于 2024-09-28 21:20:29 发布
阅读量860 收藏 19
点赞数 21
分类专栏： 算法 文章标签： 笔记 leetcode 算法 二叉树 搜索二叉树 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CXDNW/article/details/142617197
版权

目录

一、Leetcode 题目

1. 二叉树的最近公共祖先

2. 二叉搜索树的最近公共祖先

（1）递归法

（2）迭代法

3. 二叉搜索树中的插入操作

（1）递归法

（2）迭代法

4. 删除二叉搜索树中的节点

（1）递归法

（2）迭代法

5. 修剪二叉搜索树

（1）递归法

（2）迭代法

6. 将有序数组转换为二叉搜索树

7. 把二叉搜索树转换为累加树

（1）迭代法

（2）递归法

二、二叉树类题目录友总结

一、Leetcode 题目

1. 二叉树的最近公共祖先

236. 二叉树的最近公共祖先 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree/description/

        给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

        百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 1：
输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。

示例 2：
输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出：5
解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。

示例 3：
输入：root = [1,2], p = 1, q = 2
输出：1
思路：

        遇到空的话，因为树都是空了，所以返回空。

        那么我们来说一说，如果 root == q，或者 root == p，说明找到 q p ，则将其返回，这个返回值，后面在中节点的处理过程中会用到

        在递归函数有返回值的情况下：如果要搜索一条边，递归函数返回值不为空的时候，立刻返回，如果搜索整个树，直接用一个变量 left、right 接住返回值，这个 left、right 后序还有逻辑处理的需要，也就是后序遍历中处理中间节点的逻辑（也是回溯）。

        就像图中一样直接返回 7。

        如果 left 和 right 都不为空，说明此时 root 就是最近公共节点。这个比较好理解

        如果 left为空，right 不为空，就返回 right，说明目标节点是通过 right 返回的，反之依然。

        图中节点 10 的左子树返回 null，右子树返回目标值 7，那么此时节点 10 的处理逻辑就是把右子树的返回值（最近 公共祖先 7）返回上去！

        完整流程图如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 后序遍历
        // 如果找到节点了，就将节点返回。返回为 NULL 的话表示为没有找到题目给出的节点
        if (root == p || root == q || root == NULL) return root;

        // 左右节点递归，以得到每一层的回溯结果
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);

        // 判断回溯到上一层什么节点
        if (left != NULL && right != NULL) return root;   
        // 左右节点都有返回值，表示为给出的节点在 root 节点的左右子树上。不是 NULL，表示现在的 root 是他们的根节点
        // 更新着返回 root，直到返回的 root 不变，表示为已找到 最近的祖先 
        else if (left == NULL && right != NULL) return right;
        // 这里返回 right，表示为给出的节点在都在 右子树上
        // 返回 left，表示为给出的节点在都在 左子树上
        return left;
    }
};

2. 二叉搜索树的最近公共祖先

235. 二叉搜索树的最近公共祖先 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/description/

        给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

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

        例如，给定如下二叉搜索树:  root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。
思路：

        因为是有序树，所以 如果 中间节点是 q 和 p 的公共祖先，那么 中节点的数组 一定是在 [p, q]区间的。即 中节点 > p && 中节点 < q 或者 中节点 > q && 中节点 < p。

        当我们从 上向下去递归遍历，第一次遇到 cur 节点是数值在 [q, p] 区间中，那么 cur 就是 q 和 p 的最近公共祖先。

（1）递归法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

// 写法一：
class Solution {
public:
    TreeNode* traversal(TreeNode* cur, TreeNode* p, TreeNode* q) {
        if (cur == NULL) return cur;

        if (cur->val > p->val && cur->val > q->val) {
            TreeNode* left = traversal(cur->left, p, q);
            if (left != NULL) {
                return left;
            }
        }

        if (cur->val < p->val && cur->val < q->val) {
            TreeNode* right = traversal(cur->right, p, q);
            if (right != NULL) {
                return right;
            }
        }

        return cur;
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return traversal(root, p, q);
    }
};


// 写法二
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root->val > p->val && root->val > q->val) {
            return lowestCommonAncestor(root->left, p, q);
        }
        else if (root->val < p->val && root->val < q->val) {
            return lowestCommonAncestor(root->right, p, q);
        }
        else return root;
    }
};

（2）迭代法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        while(root) {
            if (root->val > p->val && root->val > q->val) {
                root = root->left;
            } else if (root->val < p->val && root->val < q->val) {
                root = root->right;
            } else return root;
        }
        return NULL;
    }
};

3. 二叉搜索树中的插入操作

701. 二叉搜索树中的插入操作 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/insert-into-a-binary-search-tree/description/

        给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。

        注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。

示例 1：
输入：root = [4,2,7,1,3], val = 5
输出：[4,2,7,1,3,5]
解释：另一个满足题目要求可以通过的树是：


示例 2：
输入：root = [40,20,60,10,30,50,70], val = 25
输出：[40,20,60,10,30,50,70,null,null,25]

示例 3：
输入：root = [4,2,7,1,3,null,null,null,null,null,null], val = 5
输出：[4,2,7,1,3,5]

（1）递归法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* parent;
    void traversal(TreeNode* cur, int val) {
        if (cur == nullptr) {
            TreeNode* node = new TreeNode(val);
            if (val < parent->val) parent->left = node;
            else parent->right = node;
            return;
        }
        parent = cur;
        if (val < cur->val) traversal(cur->left, val);
        if (val > cur->val) traversal(cur->right, val);
        return;
    }

    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == nullptr) {
            TreeNode* node = new TreeNode(val);
            return node;
        }
        traversal(root, val);
        return root;
    }
};

（2）迭代法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == nullptr) {
            TreeNode* node = new TreeNode(val);
            return node;
        }

        TreeNode* cur = root;
        TreeNode* parent = cur;
        // 找到对应的节点进行插入
        while (cur != nullptr) {
            parent = cur;
            if (val < cur->val) cur = cur->left;
            else cur = cur->right;
        }
        
        // 底层插入元素
        TreeNode* node = new TreeNode(val);
        if (val < parent->val) parent->left = node;
        else parent->right = node;

        return root;
    }
};

4. 删除二叉搜索树中的节点

450. 删除二叉搜索树中的节点 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/delete-node-in-a-bst/description/

        给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

        一般来说，删除节点可分为两个步骤：

  1. 首先找到需要删除的节点；
  2. 如果找到了，删除它。

示例 1:
输入：root = [5,3,6,2,4,null,7], key = 3
输出：[5,4,6,2,null,null,7]
解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
另一个正确答案是 [5,2,6,null,4,null,7]。

示例 2:
输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点

示例 3:
输入: root = [], key = 0
输出: []
思路：

        递归：单层递归的逻辑，有五种情况：

  • 第一种情况：没找到删除的节点，遍历到空节点直接返回了
  • 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
  • 第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
  • 第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
  • 第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点。

（1）递归法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return root; // 第一种情况：没找到删除的节点，遍历到空节点直接返回了
        if (root->val == key) {
            // 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
            if (root->left == nullptr && root->right == nullptr) {
                delete root;
                return nullptr;
            }
            // 第三种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
            else if (root->left == nullptr) {
                auto retNode = root->right;
                delete root;
                return retNode;
            }
            // 第四种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
            else if (root->right == nullptr) {
                auto retNode = root->left;
                delete root;
                return retNode;
            }
            // 第五种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左面节点的左孩子的位置
            // 并返回删除节点右孩子为新的根节点。
            else {
                TreeNode* cur = root->right; // 找右子树最左面的节点
                while(cur->left != nullptr) {
                    cur = cur->left;
                }
                cur->left = root->left; // 把要删除的节点（root）左子树放在cur的左孩子的位置
                TreeNode* tmp = root;   // 把root节点保存一下，下面来删除
                root = root->right;     // 返回旧root的右孩子作为新root
                delete tmp;             // 释放节点内存（这里不写也可以，但C++最好手动释放一下吧）
                return root;    // 交给上一层递归指向新 root
            }
        }
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};

（2）迭代法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* deleteOneNode(TreeNode* cur) {
        if (cur == nullptr) return cur;
        if (cur->right == nullptr) return cur->left;

        // 两边都不为空
        TreeNode* target = cur->right;
        while (target->left) {
            target = target->left;
        }
        target->left = cur->left;
        return cur->right;
    }

    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return nullptr;
        
        TreeNode* cur = root;
        TreeNode* pre = nullptr;
        while (cur) {
            if (cur->val == key) break;
            pre = cur;
            if (key < cur->val) cur = cur->left;
            else cur = cur->right;
        }

        // 没找到节点
        if (pre == nullptr) { // 如果搜索树只有头结点
            return deleteOneNode(cur);
        }

        // 找到了需要判断
        if (pre->left && pre->left->val == key) {
            pre->left = deleteOneNode(cur);
        }
        if (pre->right && pre->right->val == key) {
            pre->right = deleteOneNode(cur);
        }

        return root;
    }
};

5. 修剪二叉搜索树

669. 修剪二叉搜索树 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/trim-a-binary-search-tree/description/

        给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即，如果没有被移除，原有的父代子代关系都应当保留)。 可以证明，存在 唯一的答案 。

        所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。

示例 1：
输入：root = [1,0,2], low = 1, high = 2
输出：[1,null,2]

示例 2：
输入：root = [3,0,4,null,2,null,null,1], low = 1, high = 3
输出：[3,2,null,1]

（1）递归法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if (root == nullptr) return nullptr;
        
        // 如果当前节点的值小于范围的最小值，就向当前节点的右孩子中寻找合适的值，并且返回，跳过的值直接被舍弃；
        // 如果当前节点的值大于范围的最大值，就向当前节点的左孩子中寻找合适的值，并且返回，跳过的值直接被舍弃；
        if (root->val < low) return trimBST(root->right, low, high);
        if (root->val > high) return trimBST(root->left, low, high);

        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);

        return root;
    }
};

（2）迭代法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        // 迭代法
        if (root == nullptr) return root;

        // 取一个范围，一定有一个搜索二叉树中的根节点在范围中间，而且左右子树都需要修剪
        // 首先找到这个根节点
        while (root != nullptr && (root->val < low || root->val > high)) {
            if (root->val < low) root = root->right;
            else if (root->val > high) root = root->left;
        }

        TreeNode* cur = root;

        // 处理左节点
        while (cur != nullptr) {
            while (cur->left && cur->left->val < low) {
                cur->left = cur->left->right;
            }
            cur = cur->left;    // 查找左子树，直到最小值
        }

        // 处理右节点
        cur = root;
        while (cur != nullptr) {
            while (cur->right && cur->right->val > high) {
                cur->right = cur->right->left;
            }
            cur = cur->right;    // 查找右子树，直到最大值
        }
        return root;
    }
};

6. 将有序数组转换为二叉搜索树

108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/description/

        给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树。

示例 1：
输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：
输入：nums = [1,3]
输出：[3,1]
解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

// 递归法
class Solution {
public:
    TreeNode* buildTree(vector<int>& nums, int left, int right) {   // [):左闭右开
        if (left == right) return nullptr;
        // 获取根节点
        int mid = (left + right) / 2;
        // int mid = left + ((right - left) / 2);
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = buildTree(nums, left, mid);
        root->right = buildTree(nums, mid + 1, right);
        return root;
    }

    TreeNode* sortedArrayToBST(vector<int>& nums) {
        return buildTree(nums, 0, nums.size());
    }
};

7. 把二叉搜索树转换为累加树

538. 把二叉搜索树转换为累加树 - 力扣（LeetCode）icon-default.png?t=O83Ahttps://leetcode.cn/problems/convert-bst-to-greater-tree/description/

        给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

提醒一下，二叉搜索树满足下列约束条件：

  • 节点的左子树仅包含键 小于 节点键的节点。
  • 节点的右子树仅包含键 大于 节点键的节点。
  • 左右子树也必须是二叉搜索树。

示例 1：
输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]

示例 2：
输入：root = [0,null,1]
输出：[1,null,1]

示例 3：
输入：root = [1,0,2]
输出：[3,3,2]

示例 4：
输入：root = [3,2,4,1]
输出：[7,9,4,10]

（1）迭代法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* convertBST(TreeNode* root) {
        // 反中序遍历
        stack<TreeNode*> record;
        if (root == nullptr) return root;
        record.push(root);
        int sum = INT_MAX;
        while (!record.empty()) {
            TreeNode* node = record.top();
            record.pop();
            if (node != nullptr) {
                if (node->left) record.push(node->left);
                record.push(node);
                record.push(nullptr);
                if (node->right) record.push(node->right);
            }
            else {
                node = record.top();
                record.pop();
                if (sum == INT_MAX) {
                    // 初始化 sum
                    sum = node->val;
                }
                else {
                    sum += node->val;
                    node->val = sum;
                }
            }
        }
        return root;
    }
};

（2）递归法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
    int pre = 0; // 记录前一个节点的数值
    void traversal(TreeNode* cur) { // 右中左遍历
        if (cur == NULL) return;
        traversal(cur->right);
        cur->val += pre;
        pre = cur->val;
        traversal(cur->left);
    }
public:
    TreeNode* convertBST(TreeNode* root) {
        pre = 0;
        traversal(root);
        return root;
    }
};

二、二叉树类题目录友总结

CXDNW
关注
专栏目录
数据结构与算法 -- 二叉树的总结笔记
weixin_44542089的博客
05-28 425
首先是二叉树的定义:它是树形结构中最典型也是最常用的结构，平常在对它进行处理时也比一般数简单，而且一般树也可以很容易地转换成二叉树，转换后的二叉树也能按一定的规则还原一般树。它的特点：每个结点至多有两棵子树，即不存在大于二的结点，它的子树有左右之分，并且其次序不能任意颠倒，因此它共有五种基本的形态，如下图： 下面让我们来了解一下二叉树的基本操作：1、初始化(InitTree)：将二叉树初始化为一棵空树。2、判断是否为空(TreeEmpty)：判断一棵二叉树的值是否为空，若为空则返回真，否则返回假。3、求根
《算法笔记》pdf版，欢迎下载学习~
10-10
《算法笔记》是一本专注于算法学习的书籍，其PDF版本为学习者提供了便捷的电子阅读体验。这本书特别针对想要提高CSP（计算机软件能力认证）分数的读者，无论是初学者还是有一定基础的学习者，都能从中受益。CSP是...
算法笔记：二叉树
qq_40206371的博客
09-03 833
除了最后一层外，每一层都是完全填满的，并且所有节点都尽量向左填充。创建线索二叉树通常需要。的从根节点开始，每层。
算法笔记|Day13二叉树III
m0_57632621的博客
07-31 780
算法笔记|Day13二叉树III
算法笔记|Day15二叉树V
m0_57632621的博客
08-03 738
算法笔记|Day15二叉树V
算法笔记|Day17二叉树VII
m0_57632621的博客
08-05 800
算法笔记|Day17二叉树VII
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
算法笔记|Day16二叉树VI
m0_57632621的博客
08-04 604
算法笔记|Day16二叉树VI
算法【二叉树】学习笔记 - 已知结点数计算可构建出多少种二叉树
灵台方寸山斜月三星洞
05-23 2373
算法【二叉树】学习笔记 - 已知结点数计算可构建出多少种二叉树卡特兰数排列组合公式排列公式组合公式 卡特兰数 C(2n, n) - C(2n, n-1) 排列组合公式 排列有序 ： 排列相当于排队，ABC站不同的位置，就是不同的排法。 组合无序 ： 组合相当于组队，ABC组一队，BCA组一队，都是他们三个，是同一只队伍。 排列公式 A(n, m) = n! / (n-m)! 从n个不相同元素中取出m个排成一列 n > m 规定 0! = 1! = 1 组合公式 公式 =分解
【算法笔记】反转二叉树
weiwai的博客
05-10 3328
反转二叉树问题 翻转一棵二叉树。 示例： 输入： 输出： 问题分析
【算法思想·二叉树】思路篇
Captain823Jack的博客
09-03 792
二叉树解题的思维模式分两类： 1、是否可以通过遍历一遍二叉树得到答案？如果可以，用一个traverse函数配合外部变量来实现，这叫「遍历」的思维模式。 2、是否可以定义一个递归函数，通过子问题（子树）的答案推导出原问题的答案？如果可以，写出这个递归函数的定义，并充分利用这个函数的返回值，这叫「分解问题」的思维模式。
算法笔记3_算法笔记_浙大_
09-30
《算法笔记3》是针对浙江大学计算机科学与技术专业学生及准备参加PAT（全国计算机等级考试——编程类）的考生编写的参考资料，主要采用C/C++语言进行讲解。这本书旨在帮助读者提升算法理解与编程能力，为机试和PAT...
算法笔记，二叉树的最大深度
03-19
在算法领域，求解二叉树的最大深度通常有深度优先搜索（DFS）和广度优先搜索（BFS）两种方法。 **深度优先搜索（DFS）** 深度优先搜索是一种递归策略，适用于解决树或图的遍历问题。对于二叉树的最大深度，我们...
算法笔记，二叉树的中序遍历
03-19
二叉树的中序遍历 二叉树的中序遍历是指按照访问左子树 ----> 根节点 ----> 右子树的方式遍历这棵树。在访问左子树或者右子树的时候叶修按照统一的方式进行遍历，直到遍历完整棵树。 递归方法 递归方法是解决...
算法笔记，二叉树的后序遍历
03-19
3. ** Morris遍历**：这是一种不使用额外数据结构的遍历方法，通过改变二叉树的链接来达到遍历的目的。在原始树的基础上创建临时指向，使得遍历过程中能够回溯。 然而，给定的文件内容主要讨论的是**二叉树的层序...
H.264学习笔记
zfenggo的博客
09-26 787
H.264凭借其出色的压缩效率、灵活的编码方式以及高质量的视频表现，成为了现代视频技术的核心标准之一。它不仅减少了存储需求，还提高了流媒体和实时视频传输的可行性。对于从高清到超高清视频，H.264的编码能力仍然广泛适用。H.264的帧结构设计（I帧、P帧和B帧）极大地提高了视频编码的压缩效率。I帧保存完整的图像信息，P帧通过参考之前的帧减少冗余数据，而B帧则通过双向参考提供进一步的压缩优势。这种帧间的协同工作大幅降低了带宽需求和存储成本，同时保持了视频的高质量。NALU头。
江科大笔记—LED闪烁& LED流水灯& 蜂鸣器
最新发布
m0_62005595的博客
09-28 382
LED闪烁& LED流水灯& 蜂鸣器
Maya学习笔记：项目设置和快捷键
吴梓穆的博客
09-24 392
快速空格：切换三视图，鼠标放到对应的视图上，在快速按空格，可以切到对应视图。在项目窗口里，选择要生成的子文件夹（保持默认即可），然后点下边的接受。文件/最下边选择最近的项目，在右侧展开菜单里选择刚创建的目录。只后场景会被默认保存在这个文件夹下的scenes里。F：先点击一个物体，在按F，选中的物体居中显示。主键盘5：平滑着色显示模型（默认的方式）选择一个文件夹，然后选择创建默认工作区。alt+滚路或右键拖动：缩放视角。alt+左键拖动：旋转视角。alt+中键拖动：移动视角。A：场景所有物体居中显示。
智能指针学习笔记
weixin_42130300的博客
09-24 308
1. 共享指针总体的使用来说是不线程安全的（构造和析构时才会改变引用计数，但是在访问资源时是不安全的）。可以对引用计数改变时加锁，或者将+或-操作改变为原子操作。3. 不可以将shared_ptr转换为unique_ptr。unique_ptr可以转换为shared_ptr，通过std::move。1. 关于int，成员变量的引用计数必须是int*。不可以直接是int，不然没有引用计数的作用。2. 关于是否可以声明为静态成员。不可以，否则每一个相同类型的对象都共享该计数。需要通过weak_ptr进行解决。
C++实现二叉树数据结构笔记与代码
这篇文档详细介绍了如何在C++中实现二叉树的数据结构，主要关注二叉链表的类定义以及相关操作。二叉树是一种非线性的数据结构，由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。 首先，文档...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值