深度/广度优先遍历LeetCode题目整合

最新推荐文章于 2024-06-25 16:06:04 发布

薯饼__

最新推荐文章于 2024-06-25 16:06:04 发布

阅读量1.3k

点赞数 1

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_41956151/article/details/97959295

版权

这篇博客整理了LeetCode中涉及深度优先和广度优先遍历的题目，包括 Maximum Depth of Binary Tree、Convert Sorted Array to Binary Search Tree、Convert Sorted List to Binary Search Tree 和 Path Sum。通过递归和非递归方式实现，讲解了二叉树的遍历方法和平衡二叉树的构建。同时，强调了Java中Queue和List接口的使用注意事项。

摘要由CSDN通过智能技术生成

从简单到难开始写起

树部分

104. Maximum Depth of Binary Tree（深度优先）

Easy

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Note: A leaf is a node with no children.

Example:

Given binary tree [3,9,20,null,null,15,7],

return its depth = 3.

贴代码

这是递归版本的：

 // // 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 maxDepth(TreeNode* root) {
        int maxdepth=0;
        DFS(maxdepth,root,maxdepth);
        return maxdepth;
    }
    void DFS(int maxtemp,TreeNode* root,int& maxdepth){
        if(root==NULL) return;
        if(maxtemp+1>maxdepth) maxdepth=maxtemp+1;
        DFS(maxtemp+1,root->left,maxdepth);    
        DFS(maxtemp+1,root->right,maxdepth);
    }    
};

这是非递归版本的，使用了栈

/**
 * 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 isSameTree(TreeNode* p, TreeNode* q) {
        stack<TreeNode*> s1, s2;
        if (p) s1.push(p);
        if (q) s2.push(q);
        while (!s1.empty() && !s2.empty()) {
            TreeNode *t1 = s1.top(); s1.pop();
            TreeNode *t2 = s2.top(); s2.pop();
            if (t1->val != t2->val) return false;
            if (t1->left) s1.push(t1->left);//左或者右优先都可以，因为先序遍历的定义是先访问根节点，然后访问
// 叶子节点，这里应该是先访问了右孩子
            if (t2->left) s2.push(t2->left);
            if (s1.size() != s2.size()) return false;
            if (t1->right) s1.push(t1->right);
            if (t2->right) s2.push(t2->right);
            if (s1.size() != s2.size()) return false;
        }
        return s1.size() == s2.size();
    }
};

结果是非递归版本的比较快