LeetNode：BM29-BM34

最新推荐文章于 2024-08-03 21:43:16 发布

官人¡

最新推荐文章于 2024-08-03 21:43:16 发布

阅读量66

点赞数

分类专栏： LeetCode 文章标签：深度优先链表算法 leetcode 数据结构

本文链接：https://blog.csdn.net/qq_32173267/article/details/129259877

版权

LeetCode 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

LeetNode：BM29-BM34

BM29 ⼆叉树中和为某⼀值的路径(⼀)

解题思路：

首先想到的递归方法
深度遍历的回溯

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 * };
 */

//法一：递归
class Solution1 {
  public:
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */

    bool hasPathSum(TreeNode* root, int sum) {
        // write code here

        if (root == nullptr)return false;
        if (root->val == sum && !root->left && !root->right)return true;

        return hasPathSum(root->left, sum - root->val) ||
               hasPathSum(root->right, sum - root->val);
    }
};


//法二：回溯(深度优先遍历)
class Solution {
  public:
    /**
     *
     * @param root TreeNode类
     * @param sum int整型
     * @return bool布尔型
     */

    stack<TreeNode*> spath;  //记录符合要求的路径
    bool hasPathSum(TreeNode* root, int sum) {
        // write code here

        if (root == nullptr)return false;

        return dfs(root, 0, sum);
    }

    bool dfs(TreeNode* node, int sum, int target) {
        spath.push(node);
        sum += node->val;
        if (!node->left && !node->right && sum == target)return true;
        else if (node->left || node->right) {
            if (node->left) {
                if (dfs(node->left, sum, target))return true;
                spath.pop();
            }
            if (node->right) {
                if (dfs(node->right, sum, target))return true;
                spath.pop();
            }
        }
        return false;
    }
};

BM30 二叉搜索树与双向链表

解决思路：：

递归

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
#include <utility>


//法一：递归
class Solution {
  public:
    TreeNode* Convert(TreeNode* pRootOfTree) {
        if (pRootOfTree == nullptr)return nullptr;

        pair<TreeNode*, TreeNode*> ans = dfs(pRootOfTree);
		TreeNode* anst = ans.first;
        return anst;
    }

    pair<TreeNode*, TreeNode*> dfs(TreeNode* node) {
        TreeNode* l = node, * r = node;

        if (node->left) {
            pair<TreeNode*, TreeNode*> lans = dfs(node->left);
            node->left = lans.second;
            lans.second->right = node;
            l = lans.first;
        }
        if (node->right) {
            pair<TreeNode*, TreeNode*> rans = dfs(node->right);
            node->right = rans.first;
            rans.first->left = node;
            r = rans.second;
        }

        l->left = nullptr;
        r->right = nullptr;
        return make_pair(l, r);
    }
};

BM31 对称的二叉树

解决思路：

左右子树以相反的顺序分别进行层序遍历
递归：左节点的左子树与右节点的右子树比较，左节点的右子树与右节点的左子树比较。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
#include <queue>


//法一：双队列（q1:左子树左节点先入，q2:右子树右节点先入）
class Solution1 {
  public:
    bool isSymmetrical(TreeNode* pRoot) {
        if (pRoot == nullptr || (!pRoot->left && !pRoot->right))return true;

        if (!pRoot->left || !pRoot->right)return false;

        queue<TreeNode*> lq, rq;
        lq.push(pRoot->left);
        rq.push(pRoot->right);
        while (!lq.empty() && lq.size() == rq.size()) {
            TreeNode* lnode = lq.front();
            lq.pop();
            TreeNode* rnode = rq.front();
            rq.pop();
            if (lnode->val != rnode->val ||
                    ((lnode->left == nullptr) ^ (rnode->right == nullptr)) ||
                    ((lnode->right == nullptr) ^ (rnode->left == nullptr)))return false;
            if (lnode->left && rnode->right) {
                lq.emplace(lnode->left);
                rq.emplace(rnode->right);
            }
            if (lnode->right && rnode->left) {
                lq.emplace(lnode->right);
                rq.emplace(rnode->left);
            }
        }
        return true;
    }

};


//法二：递归
class Solution {
  public:
    bool isSymmetrical(TreeNode* pRoot) {
        if (pRoot == nullptr || (!pRoot->left && !pRoot->right))return true;

        return process(pRoot->left, pRoot->right);
    }

    bool process(TreeNode* lnode, TreeNode* rnode) {
        if (lnode == nullptr && rnode == nullptr)return true;

        if (lnode == nullptr || rnode == nullptr)return false;
        if (lnode->val != rnode->val)return false;

        return process(lnode->left, rnode->right) && process(lnode->right, rnode->left);
    }

};

BM32 合并二叉树

解题思路：

遍历（前序）合并
队列

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */


//法一：递归
class Solution {
public:
    /**
     * 
     * @param t1 TreeNode类 
     * @param t2 TreeNode类 
     * @return TreeNode类
     */
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        // write code here
        if(t1 == nullptr || t2 == nullptr)return t1 == nullptr ? t2 : t1;

        t1->val += t2->val;
        t1->left = mergeTrees(t1->left, t2->left);
        t1->right = mergeTrees(t1->right, t2->right);

        return t1;
    }
};

//法二：队列

BM33 二叉树的镜像

解题思路：

递归
栈：层序遍历—左节点先入

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

 //法一：递归
class Solution1 {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    TreeNode* Mirror(TreeNode* pRoot) {
        // write code here
        if(pRoot == nullptr || (pRoot->left == nullptr && pRoot->right == nullptr))return pRoot;

        TreeNode* lroot = Mirror(pRoot->left);
        TreeNode* rroot = Mirror(pRoot->right);
        pRoot->right = lroot;
        pRoot->left = rroot;
        return pRoot;
    }
};


//法二：栈
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    TreeNode* Mirror(TreeNode* pRoot) {
        // write code here
        if(pRoot == nullptr || (pRoot->left == nullptr && pRoot->right == nullptr))return pRoot;

        stack<TreeNode*> sTN;
        sTN.push(pRoot);
        while(!sTN.empty()){
            TreeNode* node = sTN.top();
            sTN.pop();
            if(node->left)sTN.push(node->left);
            if(node->right)sTN.push(node->right);
            TreeNode* tmp = node->left;
            node->left = node->right;
            node->right = tmp;
        }
        return pRoot;
    }
};

BM34 判断是不是二叉搜索树

解题思路：

递归
中序遍历（栈或递归）

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
#include <climits>
#include <queue>
#include <utility>


//法一：递归一
class Solution1 {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return bool布尔型
     */


    bool flag = true;  // == false时，程序结束

    bool isValidBST(TreeNode* root) {
        // write code here
        if (root->left == nullptr && root->right == nullptr)return true;

        process(root);
        return flag ? true : false;

    }

    pair<int, int> process(TreeNode* node) {
        int l = node->val, r = node->val;
        if (node->left != nullptr && flag) {
            pair<int, int> lval = process(node->left);
            if (lval.second >= node->val) flag = false;
            l = lval.first;
        }
        if (node->right != nullptr && flag) {
            pair<int, int> rval = process(node->right);
            if (rval.first <= node->val)flag = false;
            r = rval.second;
        }

        return make_pair(l, r);
    }
};


//法二：中序遍历(栈或递归)
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @return bool布尔型
     */
    bool isValidBST(TreeNode* root) {
        // write code here
        if (root->left == nullptr && root->right == nullptr)return true;

        stack<TreeNode*> q;
        int lval = INT_MIN;
        TreeNode* tmp = root;

        while (tmp || !q.empty()) {
            if (tmp) {
                q.push(tmp);
                tmp = tmp->left;
            } else {
                tmp = q.top();
                q.pop();
                if (tmp->val <= lval)return false;
                lval = tmp->val;
                tmp = tmp->right;
            }
        }

        // while (tmp) {
        //     q.push(tmp);
        //     tmp = tmp->left;
        // }

        // while (!q.empty()) {
        //     tmp = q.top();
        //     q.pop();
        //     if (lval >= tmp->val)return false;
        //     lval = tmp->val;
        //     if (tmp->right) {
        //         tmp = tmp->right;
        //         while (tmp) {
        //             q.push(tmp);
        //             tmp = tmp->left;
        //         }
        //     }
        // }
        return true;
    }
};