力扣刷题之深度优先搜索

最新推荐文章于 2023-10-10 09:00:00 发布
最新推荐文章于 2023-10-10 09:00:00 发布
阅读量755 收藏
点赞数
分类专栏： 数据结构与算法 力扣 文章标签： 深度优先 leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41191468/article/details/121000780
版权

力扣刷题之深度优先搜索

98.验证二叉搜索树

在这里插入图片描述
在这里插入图片描述
法一：递归

class Solution {
public:
    bool helper(TreeNode* root, long long lower, long long upper) {
        if (root == nullptr) {
            return true;
        }
        if (root -> val <= lower || root -> val >= upper) {
            return false;
        }
        return helper(root -> left, lower, root -> val) && helper(root -> right, root -> val, upper);
    }
    bool isValidBST(TreeNode* root) {
        return helper(root, LONG_MIN, LONG_MAX);
    }
};

法二：中序遍历

class Solution {
    TreeNode* pre = NULL;
public:
    bool isValidBST(TreeNode* root) {
        if(root == NULL)    return true;

        if(!isValidBST(root->left)) return false;

        if(pre != NULL && root->val <= pre->val)    return false;

        pre = root; //记录中序遍历的上一个节点

        if(!isValidBST(root->right)) return false;

        return true;
    }
};

99.恢复二叉搜索树

在这里插入图片描述
在这里插入图片描述中序遍历过程中，记录错误两个错误排序节点，最后进行交换

class Solution {
    TreeNode t1, t2, pre;
    public void recoverTree(TreeNode root) {
        inorder(root);
        int temp = t1.val;
        t1.val = t2.val;
        t2.val = temp;
    }
    public void inorder(TreeNode root){
        if (root == null) return ;
        inorder(root.left);
        if (pre != null && pre.val > root.val) {
            if (t1 == null) t1 = pre;
            t2 = root;
        }
        pre = root;
        inorder(root.right);
    }
}

113.路径总和II

在这里插入图片描述
法一：回溯

/**
 * 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:
    vector<vector<int>> ans;
    vector<int> t;
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(!root)return ans;
        t.push_back(root->val);
        dfs(root,root->val,targetSum);
        return ans;
    }
    void dfs(TreeNode* root,int add,int targetSum){
        if(!root->left && !root->right && add==targetSum){
            ans.push_back(t);
            return;
        }
        if(root->left){
            t.push_back(root->left->val);
            dfs(root->left,add+root->left->val,targetSum);
            t.pop_back();
        }
        if(root->right){
            t.push_back(root->right->val);
            dfs(root->right,add+root->right->val,targetSum);
            t.pop_back();
        }
    }
};

法二：递归

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;

    void dfs(TreeNode* root, int targetSum) {
        if (root == nullptr) {
            return;
        }
        path.emplace_back(root->val);
        targetSum -= root->val;
        if (root->left == nullptr && root->right == nullptr && targetSum == 0) {
            ret.emplace_back(path);
        }
        dfs(root->left, targetSum);
        dfs(root->right, targetSum);
        path.pop_back();
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        dfs(root, targetSum);
        return ret;
    }
};

114.二叉树展开为链表

在这里插入图片描述
在这里插入图片描述
法一：前序遍历

在这里插入图片描述

class Solution {
public:
    void flatten(TreeNode* root) {
        vector<TreeNode*> l;
        preorderTraversal(root, l);
        int n = l.size();
        for (int i = 1; i < n; i++) {
            TreeNode *prev = l.at(i - 1), *curr = l.at(i);
            prev->left = nullptr;
            prev->right = curr;
        }
    }

    void preorderTraversal(TreeNode* root, vector<TreeNode*> &l) {
        if (root != NULL) {
            l.push_back(root);
            preorderTraversal(root->left, l);
            preorderTraversal(root->right, l);
        }
    }
};

116.填充每个节点的下一个右侧节点指针

在这里插入图片描述

class Solution {
public:
    Node* connect(Node* root) {
        if (root == nullptr) {
            return root;
        }
        
        // 从根节点开始
        Node* leftmost = root;
        
        while (leftmost->left != nullptr) {
            
            // 遍历这一层节点组织成的链表，为下一层的节点更新 next 指针
            Node* head = leftmost;
            
            while (head != nullptr) {
                
                // CONNECTION 1
                head->left->next = head->right;
                
                // CONNECTION 2
                if (head->next != nullptr) {
                    head->right->next = head->next->left;
                }
                
                // 指针向后移动
                head = head->next;
            }
            
            // 去下一层的最左的节点
            leftmost = leftmost->left;
        }
        
        return root;
    }
};

117.填充每个节点的下一个右侧节点指针II

在这里插入图片描述

class Solution {
public:
    Node* connect(Node* root) {
        if(!root){
            return nullptr;
        }
        queue<Node*>q;//按层存储树的结点
        Node* cur=root;
        q.push(root);
        int n=1;//指示当层结点尚未遍历的结点个数
        while(!q.empty()){
            q.pop();
            n--;
            if(cur->left){
                q.push(cur->left);
            }
            if(cur->right){
                q.push(cur->right);
            }
            if(n==0){//n=0时，表示该层遍历完毕
                cur->next=nullptr;
                n=q.size();
            }
            else{
                cur->next=q.front();
            }
            cur=q.front();
        }
        return root;
    }
};

129.求根节点到叶节点数字之和

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int dfs(TreeNode* root, int prevSum) {
        if (root == nullptr) {
            return 0;
        }
        int sum = prevSum * 10 + root->val;
        if (root->left == nullptr && root->right == nullptr) {
            return sum;
        } else {
            return dfs(root->left, sum) + dfs(root->right, sum);
        }
    }
    int sumNumbers(TreeNode* root) {
        return dfs(root, 0);
    }
};

199.二叉树的右视图

在这里插入图片描述
层序遍历 队列 取最右值

vector<int> rightSideView(TreeNode* root) {
	vector<int> res;
	if (!root) return res;
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty())
	{
		int size = q.size();
		res.push_back(q.front()->val);
		while (size--)
		{
			TreeNode* temp = q.front();
			q.pop();
			if (temp->right) q.push(temp->right);
			if (temp->left) q.push(temp->left);
		}
	}
	return res;
}

207.课程表

在这里插入图片描述
拓扑排序 判断是否存在有向环
在这里插入图片描述

class Solution {
private:
    vector<vector<int>> edges;
    vector<int> indeg;

public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        edges.resize(numCourses);
        indeg.resize(numCourses);
        for (const auto& info: prerequisites) {
            edges[info[1]].push_back(info[0]);
            ++indeg[info[0]];
        }

        queue<int> q;
        for (int i = 0; i < numCourses; ++i) {
            if (indeg[i] == 0) {
                q.push(i);
            }
        }

        int visited = 0;
        while (!q.empty()) {
            ++visited;
            int u = q.front();
            q.pop();
            for (int v: edges[u]) {
                --indeg[v];
                if (indeg[v] == 0) {
                    q.push(v);
                }
            }
        }

        return visited == numCourses;
    }
};

210.课程表II

在这里插入图片描述

class Solution {
private:
    // 存储有向图
    vector<vector<int>> edges;
    // 存储每个节点的入度
    vector<int> indeg;
    // 存储答案
    vector<int> result;

public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        edges.resize(numCourses);
        indeg.resize(numCourses);
        for (const auto& info: prerequisites) {
            edges[info[1]].push_back(info[0]);
            ++indeg[info[0]];
        }

        queue<int> q;
        // 将所有入度为 0 的节点放入队列中
        for (int i = 0; i < numCourses; ++i) {
            if (indeg[i] == 0) {
                q.push(i);
            }
        }

        while (!q.empty()) {
            // 从队首取出一个节点
            int u = q.front();
            q.pop();
            // 放入答案中
            result.push_back(u);
            for (int v: edges[u]) {
                --indeg[v];
                // 如果相邻节点 v 的入度为 0，就可以选 v 对应的课程了
                if (indeg[v] == 0) {
                    q.push(v);
                }
            }
        }

        if (result.size() != numCourses) {
            return {};
        }
        return result;
    }
};

211.添加与搜索单词-数据结构设计

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class TrieNode{
public:
    vector<TrieNode*> child;
    bool isWord;
    TrieNode() : child(26, nullptr), isWord(false) {};
    ~TrieNode() {
        for (auto c : child) delete c;
    }
};
class WordDictionary {
public:
    /** Initialize your data structure here. */
    WordDictionary() {
        root = new TrieNode();
    }
    ~WordDictionary() {
        delete root;
    }
    /** Adds a word into the data structure. */
    void addWord(string word) {
        TrieNode* p = root;
        for (char c : word) {
            int i = c - 'a';
            if (!p->child[i])
                p->child[i] = new TrieNode();
            p = p->child[i];
        }
        p->isWord = true;
    }
    
    /** Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. */
    bool search(string word) {
        return match(word, root, 0);
    }
    
    bool match(string& word, TrieNode* p, int start) {
        if (!p) return false;
        if (start == word.size()) return p->isWord;
        char c = word[start];
        if (c != '.') {
            return match(word, p->child[c - 'a'], start + 1);
        } else {
            for (const auto& child : p->child) {
                if (match(word, child, start + 1))
                    return true;
            }
        }
        return false;
    }
private:
    TrieNode* root;
};

/**
 * Your WordDictionary object will be instantiated and called as such:
 * WordDictionary obj = new WordDictionary();
 * obj.addWord(word);
 * bool param_2 = obj.search(word);
 */

在这里插入图片描述

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

在这里插入图片描述
二分+位运算

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        int level = 0;
        TreeNode* node = root;
        while (node->left != nullptr) {
            level++;
            node = node->left;
        }
        int low = 1 << level, high = (1 << (level + 1)) - 1;
        while (low < high) {
            int mid = (high - low + 1) / 2 + low;
            if (exists(root, level, mid)) {
                low = mid;
            } else {
                high = mid - 1;
            }
        }
        return low;
    }

    bool exists(TreeNode* root, int level, int k) {
        int bits = 1 << (level - 1);
        TreeNode* node = root;
        while (node != nullptr && bits > 0) {
            if (!(bits & k)) {
                node = node->left;
            } else {
                node = node->right;
            }
            bits >>= 1;
        }
        return node != nullptr;
    }
};

在这里插入图片描述

230.二叉搜索树中第K小的元素

在这里插入图片描述
在这里插入图片描述
中序遍历

class Solution {
public:
    int kthSmallest(TreeNode* root, int k) {
        stack<TreeNode *> stack;
        while (root != nullptr || stack.size() > 0) {
            while (root != nullptr) {
                stack.push(root);
                root = root->left;
            }
            root = stack.top();
            stack.pop();
            --k;
            if (k == 0) {
                break;
            }
            root = root->right;
        }
        return root->val;
    }
};

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

在这里插入图片描述
在这里插入图片描述
深度优先搜索+哈希表
在这里插入图片描述

class Solution {
public:
    unordered_map<int, TreeNode*> fa;
    unordered_map<int, bool> vis;
    void dfs(TreeNode* root){
        if (root->left != nullptr) {
            fa[root->left->val] = root;
            dfs(root->left);
        }
        if (root->right != nullptr) {
            fa[root->right->val] = root;
            dfs(root->right);
        }
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        fa[root->val] = nullptr;
        dfs(root);
        while (p != nullptr) {
            vis[p->val] = true;
            p = fa[p->val];
        }
        while (q != nullptr) {
            if (vis[q->val]) return q;
            q = fa[q->val];
        }
        return nullptr;
    }
};

297.二叉树的序列化与反序列化

在这里插入图片描述
在这里插入图片描述

class Codec {
public:
    void rserialize(TreeNode* root, string& str) {
        if (root == nullptr) {
            str += "None,";
        } else {
            str += to_string(root->val) + ",";
            rserialize(root->left, str);
            rserialize(root->right, str);
        }
    }

    string serialize(TreeNode* root) {
        string ret;
        rserialize(root, ret);
        return ret;
    }

    TreeNode* rdeserialize(list<string>& dataArray) {
        if (dataArray.front() == "None") {
            dataArray.erase(dataArray.begin());
            return nullptr;
        }

        TreeNode* root = new TreeNode(stoi(dataArray.front()));
        dataArray.erase(dataArray.begin());
        root->left = rdeserialize(dataArray);
        root->right = rdeserialize(dataArray);
        return root;
    }

    TreeNode* deserialize(string data) {
        list<string> dataArray;
        string str;
        for (auto& ch : data) {
            if (ch == ',') {
                dataArray.push_back(str);
                str.clear();
            } else {
                str.push_back(ch);
            }
        }
        if (!str.empty()) {
            dataArray.push_back(str);
            str.clear();
        }
        return rdeserialize(dataArray);
    }
};
南不喃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
力扣刷题力扣刷题力扣刷题力扣刷题
07-16
力扣刷题力扣刷题力扣刷题
LeetCode力扣刷题——一切皆可搜索
指北针_N的博客
10-12 726
搜索、深度优先搜索dfs、广度优先搜索bfs、回溯法、n皇后问题、岛屿问题。因为栈与递归的调用原理相同，而递归相对便于实现，因此刷题时笔者推荐使用递归式写法，同时也方便进行回溯（见下节）。我们从 1 号节点开始遍历，假如遍历顺序是从左子节点到右子节点，那么按照优先向着“广”的方向前进的策略，队列顶端的元素变化过程为 [1]->[2->3]->[4]，图的表示方法是，每个位置代表一个节点，每个节点与上下左右四个节点相邻。
力扣75——深度优先搜索
weixin_45034895的博客
07-31 318
深度优先搜索
力扣第113题 路径总和 || 树 深度优先搜索 回溯 二叉树
lenyan~的博客
10-10 69
给你二叉树的根节点root和一个整数目标和targetSum，找出所有路径总和等于给定目标和的路径。是指没有子节点的节点。
【力扣“图论基础”学习计划】之好题分享与知识点总结
weixin_51368613的博客
03-07 663
前言 把力扣学习计划之图论基础写完了，萌生出挑出几道我觉得好的题目出来的想法。 在“图论基础”学习计划中搜索占主体。本篇博客也将围绕搜索展开。 搜索中抓住：方向 + 去重 知识点：（循循渐进） 邻接矩阵 在矩阵中的搜索，这里更偏向 bfs 搜索，但是和 dfs 差不多，都是向四周拓展 邻接链表和在图中的搜索 计数搜索、起点到终点的最小步数搜索 二分图 题目 点击蓝色的文字跳转链接 一、岛屿数量（好经典的一道题） 解法：bfs、dfs、并查集。 这道题的评论区有很多优质解法，不再赘述。 写完这道题后你
力扣每日一题(五十五——广（深）度优先遍历算法（关二维平面搜索问题））
touxing777的博客
04-15 2756
仅以此纪录每日LeetCode所刷题目。 题目描述： 示例： 思路： 关于树的问题，我们很容易区分深度优先和广度优先，但是面对这种平面二维数组的问题。我们一般同时使用深度优先和广度优先搜索。在进行搜索遍历的时候，最重要的是我们要对已经搜索过的地方进行标记，防止重复搜索陷入循环导致程序无法正常运行。这道题我们定义一个深度优先搜索的函数，当找到一个坐标为”1“时，就开始对这个坐标的四周进行搜索，相当于遍历整个”岛屿“，深度优先搜索函数编写的时候要注意边界值和结束条件（1、越界要结束 2、根据
Leetcode:记录力扣刷题之路
03-15
Leetcode 记录力扣刷题之路
使用力扣刷题的经验.pdf
04-21
本文主要是讲如何使用力扣进行刷题，此文是我根据自己的刷题经验进行编写的，主要针对的用户包括刚刚接触编程的小伙伴，还有就是有一些算法基础想提升自己的算法能力的小伙伴。
力扣刷题算法截图汇总2021
04-02
力扣刷题算法截图汇总2021
力扣刷题精选11111
03-23
力扣刷题精选11111
leetcode316-leetcode:力扣解决方案
06-30
leetcode 316 leetcode 力扣解决方案 问题 标签（数据结构和算法） 解决方案 注释 数组和哈希表 简单的 链表 中等的 字符串和哈希表和滑动窗口 中等的 数组&哈希表&&两个指针 中等的 链表 & 分治 & 堆 难的 数组 & 两个指针 & 堆栈 难的 数组和贪婪 难的 哈希表和字符串 中等的 数组和动态规划 简单的 阵列和格雷迪 中等的 动态规划 简单的 哈希表&&两个指针&字符串&滑动窗口 去做 难的 链表 中等的 数组和堆栈 难的 数组 & 哈希表 & 动态规划 & 堆栈 难的 字符串和动态规划 中等的 哈希表 & 堆栈 & 树 中等的 动态规划和树 中等的 动态规划和树 中等的 树和深度 Frist 搜索 中等的 树和深度 Frist 搜索 难的 树和深度优先搜索 简单的 树和呼吸优先搜索 中等的 Stack & Tree & Breath-First-Search 中等的 数组&树&深度优先搜索 中等的 数组&树&深度优先搜索 中等的 树和深度优先搜索 中等的 树和深度优先搜索 去做 中等的 数组和动态规划 中等的 呼吸优先搜索 中等的 树和深度优先搜索
C++力扣刷题记录——深度优先搜索·DFS（递归前中后序）&&广度优先（队列）（持续更新）
m0_37668446的博客
07-28 352
1 海岛数量 给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。 岛屿总是被水包围，并且每座岛屿只能由水平方向或竖直方向上相邻的陆地连接形成。 此外，你可以假设该网格的四条边均被水包围 思路 我们可以将二维网格看成一个无向图，竖直或水平相邻的 11 之间有边相连。 为了求出岛屿的数量，我们可以扫描整个二维网格。如果一个位置为 11，则以其为起始节点开始进行深度优先搜索。在深度优先搜索的过程中，每个搜索到的 11 都会被重新标记为 00。 最终岛屿的数量就是我们进行深度优
力扣经典深度优先+递归算法
cout_s的博客
09-05 2007
深度优先算法 1.有一个二维矩阵 grid ，每个位置要么是陆地（记号为 0 ）要么是水域（记号为 1 ）。 我们从一块陆地出发，每次可以往上下左右 4 个方向相邻区域走，能走到的所有陆地区域，我们将其称为一座「岛屿」。 如果一座岛屿 完全 由水域包围，即陆地边缘上下左右所有相邻区域都是水域，那么我们将其称为 「封闭岛屿」。 请返回封闭岛屿的数目。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/number-of-closed-islands 代
珍宝鸭的力扣练习（5）：深度优先搜索递归法（DFS）
qq_38138689的博客
03-23 395
题目：给定一个 N 叉树，找到其最大深度。最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。 例如，给定一个 3叉树 : DFS深度优先搜索——类似于树的先根遍历，是树的先根遍历的推广 简述算法过程 1、任选一顶点作始点 v ，访问该顶点 2、沿深度方向，依次遍历 v 的未访问邻接点——直到本次遍历结束 3、一次遍历完时，若有未访问顶点：任选一个未访问顶点作起始点，GOTO第2步 算法伪...
力扣总结之回溯算法+深度优先+广度优先
young_man2的博客
07-19 1127
力扣总结之回溯法
深度优先搜索（二）：验证二叉搜索树（力扣）
wujianrenn的博客
04-23 489
一、题目描述 给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。 有效 二叉搜索树定义如下： 节点的左子树只包含 小于 当前节点的数。 节点的右子树只包含 大于 当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例 1： 输入：root = [2,1,3] 输出：true 示例 2： 输入：root = [5,1,4,null,null,3,6] 输出：false 解释：根节点的值是 5 ，但是右子节点的值是 4 。 提示： 树
LeetCode77.组合
Ember_Sky
05-23 563
力扣（leetcode）77.组合——深搜（DFS） 原题传送门 题解： 排列组合+dfs：从n个不同的数字中找出k个不同的数字，一共有C(n，k)中情况；这道题需要全排列，用深度优先搜索（dfs）就能搞定。 上代码。 class Solution { public: int n,k; vector <vector <int>>ans; vector...
力扣刷题-深搜01
g759780748的博客
10-02 146
一、简单题 1 二叉树的中序遍历 【中序遍历】 二叉树的中序遍历：按照访问左子树——根节点——右子树的方式遍历这棵树 在访问左子树或者右子树的时候我们按照同样的方式遍历，直到遍历完整棵树 /** * 递归 * * @param root 表示当前遍历到root节点的答案 * @return {@link List<Integer>} */ public List<Integer> inorderTrav
关于深度优先搜索
weixin_34352449的博客
01-31 92
嗯... 今天就来学习一下什么是深搜？？？ 首先深搜是一个骗分神器.... ——如果有什么一遍DFS解决不了的问题，那就DFS两遍... 但....DFS是一种时间消耗极大的算法 所以，要学会估计自己是否会超时， 把题中数据带入式子，得出的值 <10^7 基本稳过 ∈[10^7,10^8] 看出题人的姿势水平 ∈[10^8,10^9] 看脸 &...
力扣刷题C++常用操作
最新发布
10-18
好的，关于力扣刷题C++常用操作，我可以给你一些常见的操作和技巧： 1. 使用 STL 容器和算法库：STL（Standard Template Library）是 C++ 标准库中的一个重要组成部分，包含了许多常用的容器和算法。在力扣刷题中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值