Carl2——二叉树

已于 2023-04-07 20:10:57 修改
阅读量198 收藏
点赞数
文章标签： c++ 算法 Powered by 金山文档
于 2023-02-27 20:48:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65199878/article/details/129230992
版权

一.定义

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

二.遍历

  1. 深度优先

1.1 迭代法

【1】前序遍历（144）

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*>st;
        vector<int>re;
        if (!root) return re;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            re.push_back(node->val);
            st.pop();
            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
        }
        return re;
    }
};

【2】后序遍历（145）

前序中左右->中右左->reverse为左右中

【3】中序遍历（94）

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*>st;
        vector<int>re;
        if (!root) return re;
        TreeNode* node = root;
        while (!st.empty()||node) {
            if (node) {
                st.push(node);
                node = node->left;
            }
            else {
                node = st.top();
                re.push_back(node->val);
                st.pop();
                node = node->right;
            }
        }
        return re;
    }
};

1.2 统一迭代

先序

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*>st;
        vector<int>re;
        if (!root) return re;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top(); 
            st.pop();
            if (node) {
                if (node->right) st.push(node->right);
                if (node->left) st.push(node->left);
                st.push(node);
                st.push(NULL);
            }
            else {
                node = st.top();
                re.push_back(node->val);
                st.pop();
            }
        }
        return re;
    }
};

1.3 递归

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (!cur) return;
        vec.push_back(cur->val);
        traversal(cur->left, vec);
        traversal(cur->right, vec);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int>re;
        traversal(root, re);
        return re;      
    }
};

2.广度优先

2.1 迭代

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> re;
        queue<TreeNode*>que;
        if (root) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int>vec;
            for (int i = 0; i < size; ++i) {
                TreeNode* tmp = que.front();
                vec.push_back(tmp->val);
                que.pop();
                if (tmp->left) que.push(tmp->left);
                if (tmp->right) que.push(tmp->right);
            }
            re.push_back(vec);
        }
        return re;
    }
};

2.2 递归

class Solution {
public:
    void traversal(TreeNode* cur, vector<vector<int>>& re, int depth) {
        if (!cur) return;
        if (re.size() == depth) re.push_back(vector<int>());
        re[depth].push_back(cur->val);
        traversal(cur->left, re, depth + 1);
        traversal(cur->right, re, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> re;
        int depth = 0;
        traversal(root, re, depth);
        return re;
    }
};

3.应用

【1】平衡二叉树（110）

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

后序统一迭代

class Solution {
public:
//求高度
    int getdepth(TreeNode* cur) {
        stack<TreeNode*>st;
        if (cur) st.push(cur);
        int depth = 0;
        int re = 0;
        //后序统一
        while (!st.empty()) {
            TreeNode* tmp = st.top();
            st.pop();
            if (tmp) {               
                st.push(tmp);
                st.push(NULL);
                if (tmp->right) st.push(tmp->right);
                if (tmp->left) st.push(tmp->left);
                depth++;
            }
            else {               
                tmp = st.top();
                st.pop();
                depth--;
            }
            re = re > depth ? re : depth;
        }
        return re;
    }

    bool isBalanced(TreeNode* root) {
        stack<TreeNode*>st;
        if (!root) return true;
        st.push(root);
        while (!st.empty()) {
            TreeNode* tmp = st.top();
            st.pop();
            if (abs(getdepth(tmp->left) - getdepth(tmp->right)) > 1)
                return false;
            if (tmp->right) st.push(tmp->right);
            if (tmp->left) st.push(tmp->left);
        }
        return true;
    }
};

【2】二叉树的所有路径（257）

迭代

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        stack<TreeNode*> treeSt;
        stack<string> pathSt;   
        vector<string> result; 
        if (root == NULL) return result;
        treeSt.push(root);
        pathSt.push(to_string(root->val));
        while (!treeSt.empty()) {
            TreeNode* node = treeSt.top(); treeSt.pop(); 
            string path = pathSt.top(); pathSt.pop();   
            if (node->left == NULL && node->right == NULL) { 
                result.push_back(path);
            }
            if (node->right) {
                treeSt.push(node->right);
                pathSt.push(path + "->" + to_string(node->right->val));
            }
            if (node->left) {
                treeSt.push(node->left);
                pathSt.push(path + "->" + to_string(node->left->val));
            }
        }
        return result;
    }
};

【3】从中序与后序遍历序列构造二叉树106

题目描述：

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

class Solution {
private:
    TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0) return NULL;

        // 后序遍历数组最后一个元素，就是当前的中间节点
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        // 叶子节点
        if (postorder.size() == 1) return root;

        // 找到中序遍历的切割点
        int delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }

        // 切割中序数组
        // 左闭右开区间：[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        // [delimiterIndex + 1, end)
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );

        // postorder 舍弃末尾元素
        postorder.resize(postorder.size() - 1);

        // 切割后序数组
        // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
        // [0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // [leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        return traversal(inorder, postorder);
    }
};

省略vector，节省空间

class Solution {
private:
    // 中序区间[inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd)
    TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd) {
        if (postorderBegin == postorderEnd) return NULL;

        int rootValue = postorder[postorderEnd - 1];
        TreeNode* root = new TreeNode(rootValue);

        if (postorderEnd - postorderBegin == 1) return root;

        int delimiterIndex;
        for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }
        // 切割中序数组
        // 左中序区间，左闭右开[leftInorderBegin, leftInorderEnd)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        // 右中序区间，左闭右开[rightInorderBegin, rightInorderEnd)
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

        // 切割后序数组
        // 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd)
        int leftPostorderBegin =  postorderBegin;
        int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size
        // 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd)
//借助长度
        int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin);
        int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  postorder, leftPostorderBegin, leftPostorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        // 左闭右开的原则
        return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }
};

从前序与中序遍历序列构造二叉树

前序和中序可以唯一确定一颗二叉树。

后序和中序可以唯一确定一颗二叉树。

那么前序和后序可不可以唯一确定一颗二叉树呢？

前序和后序不能唯一确定一颗二叉树！，因为没有中序遍历无法确定左右部分，也就是无法分割。

【4】合并二叉树（617）

题目描述：

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

前序原树：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2; // 如果t1为空，合并之后就应该是t2
        if (t2 == NULL) return t1; // 如果t2为空，合并之后就应该是t1
        // 修改了t1的数值和结构
        t1->val += t2->val;                             // 中
        t1->left = mergeTrees(t1->left, t2->left);      // 左
        t1->right = mergeTrees(t1->right, t2->right);   // 右
        return t1;
    }
};

前序新树：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2;
        if (t2 == NULL) return t1;
        // 重新定义新的节点，不修改原有两个树的结构
        TreeNode* root = new TreeNode(0);
        root->val = t1->val + t2->val;
        root->left = mergeTrees(t1->left, t2->left);
        root->right = mergeTrees(t1->right, t2->right);
        return root;
    }
};

迭代：

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if (t1 == NULL) return t2;
        if (t2 == NULL) return t1;
        queue<TreeNode*> que;
        que.push(t1);
        que.push(t2);
        while(!que.empty()) {
            TreeNode* node1 = que.front(); que.pop();
            TreeNode* node2 = que.front(); que.pop();
            // 此时两个节点一定不为空，val相加
            node1->val += node2->val;

            // 如果两棵树左节点都不为空，加入队列
            if (node1->left != NULL && node2->left != NULL) {
                que.push(node1->left);
                que.push(node2->left);
            }
            // 如果两棵树右节点都不为空，加入队列
            if (node1->right != NULL && node2->right != NULL) {
                que.push(node1->right);
                que.push(node2->right);
            }

            // 当t1的左节点 为空 t2左节点不为空，就赋值过去
            if (node1->left == NULL && node2->left != NULL) {
                node1->left = node2->left;
            }
            // 当t1的右节点 为空 t2右节点不为空，就赋值过去
            if (node1->right == NULL && node2->right != NULL) {
                node1->right = node2->right;
            }
        }
        return t1;
    }
};

【5】验证二叉搜索树（98）

题目描述：

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。

节点的右子树只包含 大于 当前节点的数。

所有左子树和右子树自身必须也是二叉搜索树。

递归：

class Solution {
private:
    vector<int> vec;
    void traversal(TreeNode* root) {
        if (root == NULL) return;
        traversal(root->left);
        vec.push_back(root->val); // 将二叉搜索树转换为有序数组
        traversal(root->right);
    }
public:
    bool isValidBST(TreeNode* root) {
        vec.clear(); // 不加这句在leetcode上也可以过，但最好加上
        traversal(root);
        for (int i = 1; i < vec.size(); i++) {
            // 注意要小于等于，搜索树里不能有相同元素
            if (vec[i] <= vec[i - 1]) return false;
        }
        return true;
    }
};

简化递归：

class Solution {
public:
    TreeNode* pre = NULL; // 用来记录前一个节点
    bool isValidBST(TreeNode* root) {
        if (root == NULL) return true;
        bool left = isValidBST(root->left);

        if (pre != NULL && pre->val >= root->val) return false;
        pre = root; // 记录前一个节点

        bool right = isValidBST(root->right);
        return left && right;
    }
};

中序

class Solution {
public:
    bool isValidBST(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        TreeNode* pre = NULL; 
        while (!st.empty() || cur) {
            if (cur) {
                st.push(cur);
                cur = cur->left;
            }
            else {
                cur = st.top();
                st.pop();
                if (pre && cur->val <= pre->val) return false;
                pre = cur;
                cur = cur->right;
            }
        }
        return true;
    }
};

【6】二叉搜索树中的插入操作（701）

递归：

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        if (root == NULL) {
            TreeNode* node = new TreeNode(val);
            return node;
        }
        if (root->val > val) root->left = insertIntoBST(root->left, val);
        if (root->val < val) root->right = insertIntoBST(root->right, val);
        return root;
    }
};

递归：

class Solution {
private:
    TreeNode* parent;
    void traversal(TreeNode* cur, int val) {
        if (cur == NULL) {
            TreeNode* node = new TreeNode(val);
            if (val > parent->val) parent->right = node;
            else parent->left = node;
            return;
        }
        parent = cur;
        if (cur->val > val) traversal(cur->left, val);
        if (cur->val < val) traversal(cur->right, val);
        return;
    }

public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        parent = new TreeNode(0);
        if (root == NULL) {
            root = new TreeNode(val);
        }
        traversal(root, val);
        return root;
    }
};

迭代：

class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        TreeNode* node = new TreeNode(val);
        if (!root) return node;
        TreeNode* cur = root;
        TreeNode* pre = root;
        while (cur) {
            pre = cur;
            if (cur->val > val) cur = cur->left;
            else cur = cur->right;
        }
        if (pre->val > val) pre->left = node;
        else pre->right = node;
        return root;
    }
};

【7】删除二叉搜索树中的节点（450）

题目描述：

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

【1】递归：

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;
            }
        }
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};

【2】迭代：

class Solution {
public:
    TreeNode* deleteOneNode(TreeNode* target) {
        if (!target) return target;
        if (!target->right) return target->left;
        TreeNode* tmp = target->right;
        while (tmp->left) tmp = tmp->left;
        tmp->left = target->left;
        return target->right;
    }
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (!root) return root;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        while (cur) {
            if (cur->val == key) break;
            pre = cur;
            if (cur->val > key) cur = cur->left;
            else cur = cur->right;
        }
        if (!pre) 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;
    }
};

将目标节点（删除节点）的左子树放到 目标节点的右子树的最左面节点的左孩子位置上，并返回目标节点右孩子为新的根节点

【3】普通二叉树：

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return root;
        if (root->val == key) {
            if (root->right == nullptr) { // 这里第二次操作目标值：最终删除的作用
                return root->left;
            }
            TreeNode *cur = root->right;
            while (cur->left) {
                cur = cur->left;
            }
            swap(root->val, cur->val); // 这里第一次操作目标值：交换目标值其右子树最左面节点。
        }
        root->left = deleteNode(root->left, key);
        root->right = deleteNode(root->right, key);
        return root;
    }
};

【8】将有序数组转换为二叉搜索树（108）

题目描述：

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

高度平衡 二叉树是一棵满足每个节点的左右两个子树的高度差的绝对值不超过 1 的二叉树。

【1】递归：

class Solution {
private:
    TreeNode* traversal(vector<int>& nums, int left, int right) {
        if (left > right) return nullptr;
        int mid = left + ((right - left) / 2);
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = traversal(nums, left, mid - 1);
        root->right = traversal(nums, mid + 1, right);
        return root;
    }
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        TreeNode* root = traversal(nums, 0, nums.size() - 1);
        return root;
    }
};

【2】迭代：

class Solution {
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if (nums.size() == 0) return nullptr;

        TreeNode* root = new TreeNode(0);   
        queue<TreeNode*> nodeQue;           // 放遍历的节点
        nodeQue.push(root);
        queue<int> leftQue;                 // 保存左区间下标
        leftQue.push(0);                    // 左区间下标初始位置
        queue<int> rightQue;                // 保存右区间下标                    
        rightQue.push(nums.size() - 1);     // 右区间下标初始位置

        while (!nodeQue.empty()) {
            int left = leftQue.front(); leftQue.pop();
            int right = rightQue.front(); rightQue.pop();
            int mid = left + ((right - left) / 2);

            TreeNode* curNode = nodeQue.front();
            nodeQue.pop();
            curNode->val = nums[mid];      

            if (left <= mid - 1) {          
                curNode->left = new TreeNode(0);
                nodeQue.push(curNode->left);
                leftQue.push(left);
                rightQue.push(mid - 1);
            }
            if (right >= mid + 1) {        
                curNode->right = new TreeNode(0);
                nodeQue.push(curNode->right);
                leftQue.push(mid + 1);
                rightQue.push(right);
            }
        }
        return root;
    }
};

【9】把二叉搜索树转换为累加树（538）

题目描述：

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

【1】递归：

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;
    }
};

【2】迭代：

class Solution {
private:
    int pre; // 记录前一个节点的数值
    void traversal(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur || !st.empty()) {
            if (cur) {
                st.push(cur);
                cur = cur->right;   // 右
            } else {
                cur = st.top();     // 中
                st.pop();
                cur->val += pre;
                pre = cur->val;
                cur = cur->left;    // 左
            }
        }
    }
public:
    TreeNode* convertBST(TreeNode* root) {
        pre = 0;
        traversal(root);
        return root;
    }
};
B.D.S.
关注
专栏目录
TypeScript算法题实战——二叉树篇
白洞，白色的明天在等着我们
11-22 2346
二叉树是树形结构的一个重要类型。二叉树是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树，经常在算法中有灵活而巧妙的应用，是算法面试中的常客，也是众多数据结构的基石。 本系列博文将通过一些力扣算法题目学习TypeScirpt，这篇将以二叉树为主题边学习TypeScipt边实战算法。（部分算法思想参考于程序员Carl:代码随想录）
Leetcode刷题记录——二叉树篇
shineber的博客
06-20 829
本文介绍了一些自己关于二叉树的刷题记录，写的不专业，部分思路参考了代码随想录Carl大佬，希望能给大家带来一些思路的启发。
leetcode 算法 二叉树java总结——完结
qq_41810415的博客
11-01 1312
提前要了解二叉树的分类 二叉树的两种存储方式 二叉树的两大种遍历方式以及深度遍历中的三种遍历方式 常常与dfs bfs混合使用本文只介绍二叉树相关的leetcode习题 对基础的语法知识点不做过多赘述。
Carl2—递归+回溯算法
BDS的朝圣路
03-01 174
Carl2——递归+回溯算法
二叉树 | 最近公共祖先 | leecode刷题笔记
qq_44250700的博客
08-12 223
跟随carl代码随想录刷题 语言：python。
二叉树 | 平衡二叉树 | leecode刷题笔记
qq_44250700的博客
08-11 188
跟随carl代码随想录刷题 语言：python。
二叉树 | 二叉搜索树 | 二叉树的有序性 | leecode刷题笔记
qq_44250700的博客
08-12 363
跟随carl代码随想录刷题 语言：python。
二叉树 | 构造二叉树 | 中序&后序、前序&中序遍历序列、最大二叉树 | leecode刷题笔记
qq_44250700的博客
08-11 223
跟随carl代码随想录刷题 语言：python。
二叉树 | 指针pre | 最值、众数、累加树 | leecode刷题笔记
qq_44250700的博客
08-12 337
跟随carl代码随想录刷题 语言：python。
实验5——二叉树.docx
06-13
### 实验5——二叉树知识点详解 #### 一、实验背景及目标 本次实验的主要目的是让学生们深入了解二叉树这种数据结构，并掌握其基本操作方法。通过具体实践，不仅能够增强理论知识的理解，还能提高编程技能。 **...
北航计算机软件技术基础实验报告计软实验报告2——二叉树.pdf
11-19
【实验报告】——二叉树 实验名称：二叉树 实验目的及要求： 本实验旨在帮助学生深入理解二叉树的存储结构，并通过实际编程操作掌握二叉树的相关运算，包括链式存储结构的实现、按层次输出所有结点、输出所有叶子...
数据结构实验——二叉树的建立和遍历.zip
12-13
2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问结点的操作修改为叶结点计数，统计度为0的；度为1...
DS二叉树——二叉树之父子结点
weixin_52247921的博客
10-19 529
#include <bits/stdc++.h> using namespace std; queue<char> father;//开一个爸爸队列放爸爸 class BiTreeNode{ public: char date; //节点数据 BiTreeNode *leftchild; BiTreeNode *rightchild; BiTreeNode() :leftchild(NULL),rightchild(NUL...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
pyqt瀑布流布局
weixin_54217201的博客
09-21 501
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 443
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1084
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
求n的阶乘的相反数（c语言）
最新发布
scy2429828663的博客
09-26 392
【代码】求n的阶乘的相反数（c语言）
数据结构：从线性到树形——二叉树解析
"二叉树是数据结构中的一个重要概念，它是树形结构的一种特殊形式。在二叉树中，每个节点最多有两个子节点，分别被称为左子节点和右子节点。这种结构广泛应用于计算机科学的各个领域，如编译器设计、文件系统、算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

B.D.S.

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

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

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

打赏作者

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

抵扣说明：

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

余额充值