算法 - 二叉树 / 图

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量569 收藏 7
点赞数 6
文章标签： 算法 数据结构
进击的小老虎丶
本文链接：https://blog.csdn.net/qq_39547794/article/details/135586993
版权

文章目录

🍺 二叉树

🍻 搜索树

🥂 96. 不同的二叉搜索树 [搜索树] [种类] (递归)

题解：

// 左子树有 left_num 种排列, 右子树有 right_num 种排列
// 以该节点为起点的排列种类共为 left_num * right_num
class Solution {
private:
    vector<vector<int>> dp;		// dp[i][j] 代表 nums[i...j] 可以构成的二叉搜索树类别数
public:
    int numTrees(int n) {
        dp.resize(n + 1, vector<int>(n + 1));
        return traverse(1, n);
    }
	// 递归, 先找 left_num, 再找 right_num, return left_num * right_num

    int traverse(int left, int right) {
        if (left >= right) return 1;
        if (dp[left][right] != 0) {		// 查询备忘录
            return dp[left][right];
        }
        int res = 0;					// 遍历计算种类, 轮流每个节点都当 root 节点
        for (int i = left; i <= right; ++i) {
            int left_num = traverse(left, i - 1);
            int right_num = traverse(i + 1, right);
            res += left_num * right_num;
        }
        dp[left][right] = res;			// 更新备忘录
        return res;
    }
};

🍻 栈

🥂 94. 二叉树的中序遍历 [二叉树] [遍历] (栈) (迭代)

class Solution {
private:
    stack<TreeNode*> stk;       // 存放已遍历节点
    vector<int> res;            // 存放结果
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if (root == nullptr) return {};
        // 把左边节点都放进去
        TreeNode* tmp = root;
        while (tmp != nullptr) {
            stk.push(tmp);
            tmp = tmp->left;
        }
        // 开始遍历
        while (!stk.empty()) {
            TreeNode* cur = stk.top();
            stk.pop();
            res.push_back(cur->val);
            // 把右节点的左节点方向全加进去
            if (cur->right != nullptr) {
                TreeNode* tmp = cur->right;
                while (tmp != nullptr) {
                    stk.push(tmp);
                    tmp = tmp->left;
                }
            }
        }
        return res;
    }
};

🥂 144. 二叉树的前序遍历 [二叉树] [遍历] (栈) (迭代)

class Solution {
private:
    stack<TreeNode*> stk;       // 存放已遍历节点
    vector<int> res;            // 存放结果
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (root == nullptr) return {};
        stk.push(root);
        // 开始遍历
        while (!stk.empty()) {
            TreeNode* cur = stk.top();
            stk.pop();
            res.push_back(cur->val);
            // 添加子节点, 先右再左
            if (cur->right != nullptr) stk.push(cur->right);
            if (cur->left != nullptr) stk.push(cur->left);
        }
        return res;
    }
};

🥂 145. 二叉树的后序遍历 [二叉树] [遍历] (栈) (迭代)

class Solution {
private:
    stack<TreeNode*> stk;       // 存放已遍历节点
    vector<int> res;            // 存放结果
public:
    vector<int> postorderTraversal(TreeNode* root) {
        if (root == nullptr) return {};
        stk.push(root);
        // 开始遍历
        while (!stk.empty()) {
            TreeNode* cur = stk.top();
            stk.pop();
            // 加入 res 中
            res.push_back(cur->val);
            // 开始加入子节点
            if (cur->left != nullptr) stk.push(cur->left);
            if (cur->right != nullptr) stk.push(cur->right);
        }
        // 将栈中元素反转就是答案
        reverse(res.begin(), res.end());
        return res;
    }
};

🍺 图

🍻 并查集

🥂 130. 被围绕的区域 [矩阵] [岛屿] (并查集)

class UF {
private:
    vector<int> parent;     // 某个节点的父节点
public:
    UF(int n) {
        parent.resize(n);
        for (int i = 0; i < n; ++i) parent[i] = i;
    }
    int find(int x) {
        if (parent[x] != x) parent[x] = find(parent[x]);
        return parent[x];
    }
    void union_(int p, int q) {
        int rootp = find(p), rootq = find(q);
        if (rootp != rootq) {
            parent[rootp] = rootq;
        }
    }
    bool connected(int p, int q) {
        return find(p) == find(q);
    }
};

class Solution {
private:
    vector<vector<int>> dirts = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};  // dfs 常用的上下左右
public:
    void solve(vector<vector<char>>& board) {
        if (board.empty()) return;
        int m = board.size();
        int n = board[0].size();
        // 定义并查集
        UF uf(m * n + 1);
        int dummy = m * n;
        // 左右两列
        for (int i = 0; i < m; ++i) {
            if (board[i][0] == 'O') {
                uf.union_(i * n, dummy);
            }
            if (board[i][n - 1] == 'O') {
                uf.union_((i + 1) * n - 1, dummy);
            }
        }
        // 上下两列
        for (int i = 0; i < n; ++i) {
            if (board[0][i] == 'O') {
                uf.union_(i, dummy);
            }
            if (board[m - 1][i] == 'O') {
                uf.union_(n * (m - 1) + i, dummy);
            }
        }
        // 将节点归类
        for (int i = 1; i < m - 1; ++i) {
            for (int j = 1; j < n - 1; ++j) {
                if (board[i][j] == 'O') {
                    for (auto dirt : dirts) {
                        int x = i + dirt[0];
                        int y = j + dirt[1];
                        if (board[x][y] == 'O') {
                            uf.union_(i * n + j, x * n + y);
                        }
                    }
                }
            }
        }
        // 将所有不与 dummy 相邻的节点都2置为 'X'
        for (int i = 1; i < m - 1; ++i) {
            for (int j = 1; j < n - 1; ++j) {
                if (!uf.connected(dummy, i * n + j)) {
                    board[i][j] = 'X';
                }
            }
        }
    }
};

🥂 261. 以图判树 [图] [树] [环] (并查集)

class UF {
private:
    vector<int> parent;
    int count;
public:
    UF (int n) {
        count = n;
        for (int i = 0; i < n; ++i) parent.push_back(i);
    }
    int find(int x) {
        if (parent[x] != x) parent[x] = find(parent[x]);
        return parent[x];
    }
    void union_(int p, int q) {
        int rootp = find(p), rootq = find(q);
        if (rootp != rootq) {
            parent[rootp] = rootq;
            count--;
        }
    }
    bool connected(int p, int q) {
        return find(p) == find(q);
    }
    int count_() {
        return count;
    }
};

class Solution {
public:
    bool validTree(int n, vector<vector<int>>& edges) {
        UF uf(n);
        for (auto edge : edges) {
            int p = edge[0];
            int q = edge[1];
            // 如果新加入的边的两端, 处于同一个连通分量, 则会构成环
            if (uf.connected(p, q)) {
                return false;
            }
            uf.union_(p, q);
        }
        return uf.count_() == 1;
    }
};

🥂 305. 岛屿数量Ⅱ [矩阵] [岛屿] (并查集) (从0增加count)

class UF {
private:
    int count = 0;          // 连通分量
    vector<int> parent; // 元素 i 对应的父节点
public:
    UF(int n) {
        for (int i = 0; i < n; ++i) {
            parent.push_back(i);
        }
    }
    int find(int x) {
        if (parent[x] != x) parent[x] = find(parent[x]);
        return parent[x];
    }
    void union_(int p, int q) {
        int rootp = find(p), rootq = find(q);
        if (rootp != rootq) {
            parent[rootp] = rootq;
            count--;
        }
    }
    bool isConnect(int p, int q) {
        return find(p) == find(q);
    }
    int count_() {
        return count;
    }
    void addCount() {
        count++;
    }
};

class Solution {
private:
    vector<int> res;        // 每一步添加后, 一共有多少个岛屿
    vector<int> grid;       // 岛屿
    vector<vector<int>> dirts = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};     // 方向
public:
    vector<int> numIslands2(int m, int n, vector<vector<int>>& positions) {
        int size = positions.size();
        grid = vector<int>(m * n, 0);
        // 初始化并查集
        UF uf (m * n);
        // 开始一个个遍历节点
        for (auto& pos : positions) {
            int idx = pos[0] * n + pos[1];
            // 将水改为陆地
            if (grid[idx] == 0) {
                grid[idx] = 1;
                uf.addCount();
                // 开始和相邻节点合并
                for (auto& dirt : dirts) {
                    int newX = pos[0] + dirt[0];
                    int newY = pos[1] + dirt[1];
                    int newIdx = newX * n + newY;
                    // 和相邻节点没有连通, 那就连通, count--(函数内)
                    if (isArea(newX, newY, m, n) && grid[newIdx] == 1 && !uf.isConnect(idx, newIdx)) {
                        uf.union_(idx, newIdx);
                    }
                }
            }
            res.push_back(uf.count_());
        }
        return res;
    }
    // 是否越界
    bool isArea(int x, int y, int m, int n) {
        return (x >= 0 && y >= 0 && x < m && y < n);
    }
};

🥂 323. 无向图中连通分量的数目 [图] [连通分量] (并查集)

class UF {
private:
    int count = 0;      // 连通分量
    vector<int> parent; // 存储每个节点的父节点
public:
    UF(int n) {
        // 初始化父节点数组
        count = n;
        for (int i = 0; i < n; ++i) parent.push_back(i);
    }
    void union_(int p, int q) {
        int rootp = find(p);
        int rootq = find(q);
        if (rootp != rootq) {
            parent[rootq] = parent[rootp];
            count--;
        }
    }
    int find(int x) {
        if (parent[x] != x) parent[x] = find(parent[x]);
        return parent[x];
    }
    bool connectd(int p, int q) {
        return find(p) == find(q);
    }
    int count_() {
        return count;
    }
};

class Solution {
public:
    int countComponents(int n, vector<vector<int>>& edges) {
        UF uf(n);
        for (auto edge : edges) {
            uf.union_(edge[0], edge[1]);
        }
        return uf.count_();
    }
};

🥂 990. 等式方程的可满足性 [等式] (并查集)

class UF {
private:
    vector<int> parent;     // 某个节点的父节点
public:
    UF(int n) {
        for (int i = 0; i < n; ++i) parent.push_back(i);
    }
    int find(int x) {
        if (parent[x] != x) parent[x] = find(parent[x]);
        return parent[x];
    }
    void union_(int p, int q) {
        int rootp = find(p), rootq = find(q);
        if (rootp != rootq) {
            parent[rootp] = rootq;
        }
    }
    bool connected(int p, int q) {
        return find(p) == find(q);
    }
};

class Solution {
public:
    bool equationsPossible(vector<string>& equations) {
        UF uf(26);
        for (auto e : equations) {
            if (e[1] == '=') {
                uf.union_(e[0] - 'a', e[3] - 'a');
            }
        }
        // 判断不相等的数在一个连通集不
        for (auto e : equations) {
            if (e[1] == '!') {
                if (uf.connected(e[0] - 'a', e[3] - 'a')) {
                    return false;
                }
            }
        }
        return true;
    }
};

🥂 1135. 最低成本连通所有城市 [图] [权重和] (并查集) (贪心)

class UF {
private:
    int count = 0;          // 连通分量
    vector<int> parent;     // 父节点数组
public:
    UF (int n) {
        count = n;
        for (int i = 0; i < n; ++i) parent.push_back(i);
    }
    int find(int x) {
        if (parent[x] != x) parent[x] = find(parent[x]);
        return parent[x];
    }
    void union_(int p, int q) {
        int rootp = find(p), rootq = find(q);
        if (rootp != rootq) {
            parent[rootp] = rootq;
        }
        count--;
    }
    bool connected(int p, int q) {
        return find(p) == find(q);
    }
    int count_() {
        return count;
    }
};

class Solution {
public:
    int minimumCost(int n, vector<vector<int>>& connections) {
        UF uf(n + 1);
        int res = 0;
        sort(connections.begin(), connections.end(), [](vector<int>& a, vector<int>& b) {
            return a[2] < b[2];
        });
        for (auto edge : connections) {
            int p = edge[0], q = edge[1], weight = edge[2];
            if (uf.connected(p, q)) {
                continue;
            }
            res += weight;
            uf.union_(p, q);
        }
        return uf.count_() == 2 ? res : -1;
    }
};
进击的小老虎丶
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
头歌（C语言）-数据结构与算法-二叉树-先序遍历/中序遍历
weixin_59436900的博客
05-04 2207
为使实验程序简洁直观，下面的部分实验程序中的一些功能实现仍以调用库函数程序"btrechar.h"中的函数的形式给出，并假设该库函数中定义了二叉树指针和结点类型分别为bitre和bnode，以及部分常用运算，例如构建二叉树、以某种方式显示二叉树等。：为使实验程序简洁直观，下面的部分实验程序中的一些功能实现仍以调用库函数程序"btrechar.h"中的函数的形式给出，并假设该库函数中定义了二叉树指针和结点类型分别为bitre和bnode，以及部分常用运算，例如构建二叉树、以某种方式显示二叉树等。
算法-二叉树：二叉树的最小深度
weixin_60952096的博客
02-07 1453
算法-二叉树：二叉树的最小深度 求一颗二叉树的最小深度，根节点的深度为1。最小深度：从根节点到最近叶子节点的最短路径上的节点数量。 //方法一：递归 int height(TreeNode* root){ if(root == NULL) return 0; //如果左子树为空，那么最小深度按照右子树计算 if(!root->left && root->right){ return 1+height(root->right)
算法 - 二叉树的基本算法
weixin_40459875的博客
09-28 6184
目录 一、二叉树 二、二叉树的先序、中序、后序遍历 （一）、递归遍历 （二）、非递归遍历 （1）先序：头左右 （2）中序：左头右 （3）后序：左右头 三、实现二叉树的按层遍历 （一）、遍历-队列 （二）、求最大层的宽度 四、二叉树的序列化和反序列化 （一）、递归 （二）、按层 一、二叉树 图示： 结构： public class BtreeNode { public int value; public BtreeNode left; pub..
算法-二叉树：反转二叉树
weixin_60952096的博客
02-07 420
算法-二叉树：反转二叉树 思路解析：只要把每个节点的左右孩子反转一下就可以了，注意不要采用中序遍历，因为可能会把某些节点的左右孩子反转两次。以下方法采用前序遍历，方法一采用递归，方法二采用迭代。 //方法一：前序遍历递归实现 TreeNode* traversal(TreeNode* root){ if(root == NULL) return root; swap(root->left,root->right); traversal(root->left);
算法-二叉树：二叉树的最大深度
weixin_60952096的博客
02-07 386
算法-二叉树：二叉树的最大深度 求一颗二叉树的最大深度，根节点的深度为1。 思路解析： 构造二叉树时，一般选择前序遍历； 求普通二叉树的属性，一般选择后序遍历； 求二叉搜索树的属性，一般选择中序遍历。 注意：对于普通二叉树单纯求深度使用前序遍历就行。 //方法一：递归 int height(TreeNode* root){ if(root == NULL) return 0; int left = height(root->left); int right = height
算法-二叉树：平衡二叉树
weixin_60952096的博客
02-07 628
算法-二叉树：平衡二叉树 判断一棵树是不是平衡二叉树。平衡二叉树：每一个节点的左子树和右子树的高度差的绝对值不超过1。 思路解析：求二叉树的高度，只能从下到上去查找，所以需要后序遍历。和求深度不同。 //方法一：递归 int height(TreeNode* root){ if(root == NULL) return 0; int leftHeight = height(root->left); if(-1 == leftHeight) return -1; int
数据结构与算法----详解二叉树的遍历(迭代、递归)
小鱼干儿的博客
11-03 3310
数据结构与算法----二叉树的遍历，文章使用递归和迭代两种方法详细的解释的二叉树的遍历的四种方式，前序遍历，中序遍历，后序遍历，层次遍历，不仅有常见的递归解题，还有使用迭代方式实现，迭代的部分每一步的操作流程都标注了出来，帮助大家理解。
算法-二叉树：合并两颗二叉树
weixin_60952096的博客
02-09 1406
算法-二叉树：合并两颗二叉树 思路解析： 使用t1和t2节点同时遍历两棵树，将两颗树的每个根节点相加； 如果t1为空，那么合并之后就是t2； 如果t2为空，那么合并之后就是t1。 方法一：采用递归，下面程序使用前序遍历（前中后都可）。 TreeNode* plusTree(TreeNode* t1,TreeNode* t2){ if(t1 == NULL) return t2; if(t2 == NULL) return t1; //重新定义了一棵树，也可以不定义而是直接加到t1
算法-二叉树：验证二叉搜索树
weixin_60952096的博客
02-10 874
算法-二叉树：验证二叉搜索树 题目描述： 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值。 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值。 它的左右子树也分别是二叉搜索树。 方法一：使用中序遍历将二叉搜索树存入数组，判断数组是不是有序的即可。 void traversal(TreeNode* root,vector<int>& nums){ if(root == NULL ) return ; traversal(root->lef
递归算法--二叉树宽度
07-23 1535
思路：实际上是在先序遍历二叉树。递归一次，说明深入了一层。所以，在每次进入递归之时该层节点数++。 int count[MaxSize];//全局数组 int max = -1;全局变量 void width(BitNode T, int k){ if(T==null) return; count[k]++;//该层节点数++ if(max<count[k]) ma...
数据结构与算法-二叉树的排序
05-08
用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树； 2．输出二叉树的中序遍历结果； 3．输出二叉树的前序遍历结果； 4．输出二叉树的后序遍历结果； 5．计算二叉树的深度； 6．统计二叉树的结点...
二维矩形装箱算法--二叉树--java实现
03-22
二维矩形装箱算法是一种优化资源分配的问题，常用于物流、包装设计等领域。在这个问题中，我们有多个矩形（代表箱子）需要装入一个更大的矩形（代表车子）内，目标是最大化装载效率，即尽可能减少空间浪费。二叉树在...
数据结构域算法-二叉树的查找
05-08
用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树； 2．输出二叉树的中序遍历结果； 3．输出二叉树的前序遍历结果； 4．输出二叉树的后序遍历结果； 5．计算二叉树的深度； 6．统计二叉树的结点...
数据结构：实现平衡二叉树的各种算法-C/C++代码类资源
12-23
在C/C++代码资源中，你可能找到了实现这些平衡二叉树算法的示例代码，包括节点结构定义、插入、删除和查找操作的函数实现，以及相应的平衡调整逻辑。通过学习和理解这些代码，你可以深入掌握平衡二叉树的工作原理，...
qingq0825#Javabook-Interview#算法-二叉树-递归-二叉树反转1
07-25
原二叉树：反转后的二叉树：TreeNode temp = root.left;欢迎光临我的博客，发现更多技术资源~
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 947
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 238
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 253
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 310
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
计算机软件技术基础-二叉树前序遍历
"二叉树前序遍历递归算法-软件技术基础学习课件" 在计算机科学中，二叉树是一种重要的数据结构，用于表示数据的层次关系。前序遍历是访问二叉树节点的一种方法，它遵循以下顺序：先访问根节点，然后递归地遍历左...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

进击的小老虎丶

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

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

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

打赏作者

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

抵扣说明：

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

余额充值