LeetCode刷题——剑指offer深度优先搜索题目汇总

艾醒(AiXing-w)

已于 2022-02-03 13:18:43 修改

阅读量353

点赞数

分类专栏： LeetCode 文章标签： leetcode 深度优先算法

于 2022-02-02 11:21:52 首次发布

本文链接：https://blog.csdn.net/DuLNode/article/details/122768257

版权

LeetCode 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

剑指offer深度优先搜索题目汇总

剑指 Offer 12. 矩阵中的路径
剑指 Offer 34. 二叉树中和为某一值的路径
剑指 Offer 36. 二叉搜索树与双向链表
剑指 Offer 54. 二叉搜索树的第k大节点
剑指 Offer 55 - I. 二叉树的深度
剑指 Offer 55 - II. 平衡二叉树
剑指 Offer 68 - II. 二叉树的最近公共祖先

剑指 Offer 12. 矩阵中的路径

题目
给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

例如，在下面的 3×4 的矩阵中包含单词 “ABCCED”（单词中的字母已标出）。

在这里插入图片描述

示例 1：

输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]],word = “ABCCED”
输出：true

示例 2：

输入：board = [[“a”,“b”],[“c”,“d”]], word = “abcd”
输出：false

提示：

1 <= board.length <= 200 1 <= board[i].length <= 200 board 和 word
仅由大小写英文字母组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ju-zhen-zhong-de-lu-jing-lcof
代码

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        rows = board.size();
        cols = board[0].size();
        for(int i = 0; i < rows; i++) {
            for(int j = 0; j < cols; j++) {
                if(dfs(board, word, i, j, 0)) return true;
            }
        }
        return false;
    }
private:
    int rows, cols;
    bool dfs(vector<vector<char>>& board, string word, int i, int j, int k) {
        if(i >= rows || i < 0 || j >= cols || j < 0 || board[i][j] != word[k]) return false;
        if(k == word.size() - 1) return true;
        board[i][j] = '\0';
        bool res = dfs(board, word, i + 1, j, k + 1) || dfs(board, word, i - 1, j, k + 1) || 
                      dfs(board, word, i, j + 1, k + 1) || dfs(board, word, i , j - 1, k + 1);
        board[i][j] = word[k];
        return res;
    }
};

剑指 Offer 34. 二叉树中和为某一值的路径

题目
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。

叶子节点是指没有子节点的节点。

示例 1：
在这里插入图片描述

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：
在这里插入图片描述

输入：root = [1,2,3], targetSum = 5
输出：[]

示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

提示：

树中节点总数在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof
代码

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

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

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

剑指 Offer 36. 二叉搜索树与双向链表

题目
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。

为了让您更好地理解问题，以下面的二叉搜索树为例：

在这里插入图片描述

我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。

下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。

在这里插入图片描述

特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-yu-shuang-xiang-lian-biao-lcof
分析
由上面的例子可以看出，链表元素的排列是树按照左侧优先的中序遍历得到的，所以首先能够确定树的遍历要使用中序遍历。然后我们来观察双向链表的构成——每向后面新增一个结点只需要把他和最后一个结点相连，所以我们只需要在深度优先遍历的过程中记录上一个结点即可。最后我们要考虑如何连接，这里很显然要考虑双向链表的前结点和后结点，以及二叉树的左节点和右节点，我们不妨假设以及存在一个由二叉树遍历得到的部分的双向链表，最后一个结点为pre，那么pre的前结点已经连接上了，二叉树层序遍历的下一个结点应该与他相连。所以这时只需要确定二叉树的哪一个结点作为前结点即可确定后结点（因为只有两个结点，非前即后）。由于我们使用的是线序遍历，这就意味着当遍历到当前结点时，当前结点的所有子树全被遍历完了，即已经连接到双向链表之中了，这时当前结点的左节点所指向的结点已经在存在于双向链表，并且不会再被遍历到了，所有左节点为前结点。注意最后要将最后一个结点和首结点相连。
代码

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
public:
    Node* treeToDoublyList(Node* root) {
        if(root == nullptr) return nullptr;
        dfs(root);
        head->left = pre;
        pre->right = head;
        return head;
    }
private:
    Node *pre, *head;
    void dfs(Node* cur) {
        if(cur == nullptr) return;
        dfs(cur->left);
        if(pre != nullptr) pre->right = cur;
        else head = cur;
        cur->left = pre;
        pre = cur;
        dfs(cur->right);
    }
};

剑指 Offer 54. 二叉搜索树的第k大节点

题目
给定一棵二叉搜索树，请找出其中第 k 大的节点的值。

示例 1:

输入: root = [3,1,4,null,2], k = 1
   3
  / \
 1   4
  \
   2
输出: 4

示例 2:

输入: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \
   2   4
  /
 1
输出: 4

限制：

1 ≤ k ≤ 二叉搜索树元素个数

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof
分析
因为这是一棵搜索树，所以根结点比左节点大，比右节点小，根据这一性质使用中序遍历即可，注意根据k进行剪枝
代码

/**
 * 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:
    int ans;
    void dfs(TreeNode* root, int k, int & cnt, int & ans){
        if(cnt > k){
            return;
        }
        if(root->right)
        dfs(root->right, k, cnt, ans);
        cnt++;
        if(cnt==k){
            ans=root->val;
            return;
        }
        if(root->left)
        dfs(root->left, k, cnt, ans);
    }
    int kthLargest(TreeNode* root, int k) {
        int cnt=0;
        if(root->right)
        dfs(root->right, k, cnt, ans);
        cnt++;
        if(cnt==k){
            ans=root->val;
            return ans;
        }
        if(root->left)
        dfs(root->left, k, cnt, ans);
        return ans;
    }
};

剑指 Offer 55 - I. 二叉树的深度

题目
输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

例如：

给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof
代码

/**
 * 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:
    int n=0; 
    void dfs(TreeNode* root, int cur){
        n = max(n, cur);
        if(root->left != NULL){
            dfs(root->left, cur+1);
        }
        if(root->right != NULL){
            dfs(root->right, cur+1);
        }
    }
    int maxDepth(TreeNode* root) {
        if(root == NULL){
            return 0;
        }
        dfs(root, 1);
        return n;
    }
};

剑指 Offer 55 - II. 平衡二叉树

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

返回 false 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ping-heng-er-cha-shu-lcof
代码

/**
 * 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:
    bool dfs(TreeNode* root, int &cur){
        if(root == NULL){
            return true;
        }
        cur++;
        int a, b;
        a = b = cur;
        bool flag1, flag2;
        flag1 = dfs(root->left, a);
        flag2 = dfs(root->right, b);
        cur = max(a, b);
        return flag1 && flag2 && abs(a-b) <= 1;
    } 
    bool isBalanced(TreeNode* root) {
        int cur=0;
        return dfs(root, cur);
    }
};

剑指 Offer 68 - II. 二叉树的最近公共祖先

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

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

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

示例 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。因为根据定义最近公共祖先节点可以为节点本身。

说明:

所有节点的值都是唯一的。 p、q 为不同节点且均存在于给定的二叉树中。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof
分析
通过深度优先搜索找到p和q的路径，再按照路径比较即可，同时要注意当两个路径都找出来之后可以直接退出，用这个进行剪枝可以加快搜索。
代码

/**
 * 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:
    vector<TreeNode*> path_p, path_q;
    void dfs(TreeNode* root, TreeNode* p, TreeNode* q, vector<TreeNode*> &v){
        if(path_p.size() && path_q.size()){
            return;
        }
        if(p == root){
            path_p = v;
        }
        if(q == root){
            path_q = v;        
        }
        if(root->left != NULL){
            v.push_back(root->left);
            dfs(root->left, p, q, v);
            v.pop_back();
        }
        if(root->right != NULL){
            v.push_back(root->right);
            dfs(root->right, p, q, v);
            v.pop_back();
        }
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        vector<TreeNode*> v;
        if(root){
            v.push_back(root);
            dfs(root, p, q, v);
        }
        TreeNode* ans;
        for(int i=0; i < path_p.size() && i < path_q.size(); i++){
            if(path_p[i] == path_q[i]){
                ans=path_p[i];
            }else{
                break;
            }
        }
        return ans;
    }
};

艾醒(AiXing-w)

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
LeetCode刷题——剑指offer深度优先搜索题目汇总

剑指 Offer 12. 矩阵中的路径剑指 Offer 34. 二叉树中和为某一值的路径剑指 Offer 36. 二叉搜索树与双向链表剑指 Offer 54. 二叉搜索树的第k大节点剑指 Offer 55 - I. 二叉树的深度剑指 Offer 55 - II. 平衡二叉树剑指 Offer 68 - II. 二叉树的最近公共祖先
复制链接

扫一扫