我的leetcode学习之旅第二周——第一部分 二叉树中的分治法与遍历法 Divide Conquer & Traversal

最新推荐文章于 2023-01-07 19:53:38 发布
最新推荐文章于 2023-01-07 19:53:38 发布
阅读量178 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40741161/article/details/104146414
版权

1、学习大纲——二叉树

二叉树（ Binary Tree ）问题的考点剖析：
1、第一类考察形态：求值，求路径类二叉树问题
2、第二类考察形态：结构变化类二叉树问题
3、第三类考察形态：二叉查找树（ Binary Search Tree ）类问题：非递归（ Non recursion or Iteration ）版本的中序遍历 Inorder Traversal

2、典型题

1、求值：一般就是求最大、最小、平均、求和、路径等等。都是在树的路径上操作。

给一棵二叉树，找到有最大平均值的子树。返回子树的根结点。

/**
* 本参考程序来自九章算法，由 @九章算法 提供。版权所有，转发请注明出处。
/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right>;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right> = NULL;
 *     }
 * }
 */
 //定义一个类 ResultType 作为输出结果
class ResultType {
public:
    int sum, size;
    ResultType():sum(0), size(0) {}
    ResultType(int _sum, int _size): sum(_sum), size(_size) {}
};

class Solution {
public:
    /**
     * @param root the root of binary tree
     * @return the root of the maximum average of subtree 
     */
    TreeNode* findSubtree2(TreeNode* root) {
        // Write your code here
        helper(root);
        return node;
    }

    ResultType helper(TreeNode* root) {
        if (root == NULL) {
            return ResultType();
        }
        ResultType left = helper(root->left);
        ResultType right = helper(root->right);
        
        ResultType result = ResultType(left.sum + right.sum + root->val,
                                       left.size + right.size + 1);
		// 这里把除法转为了乘法，我猜是可以避免浮点数的计算
        if (node == NULL || result.sum * data.size >= data.sum * result.size) {
            data = result;
            node = root;
        }

        return result;
    }

private:
    TreeNode* node = NULL;   //存储当前最优节点
    ResultType data;         //存储当前最优结果
};

给一棵二叉树, 找到和为最小的子树, 返回其根节点。输入输出数据范围都在int内。
稍作修改即可！

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */
class ResultType {
public:
    int sum;
    ResultType():sum(0) {}
    ResultType(int _sum): sum(_sum) {}
};

class Solution {
public:
    /**
     * @param root: the root of binary tree
     * @return: the root of the minimum subtree
     */
    TreeNode * findSubtree(TreeNode * root) {
        helper(root);
        return node;
    }

    ResultType helper(TreeNode* root) {
        if (root == NULL) {
            return ResultType();
        }
        ResultType left = helper(root->left);
        ResultType right = helper(root->right);
        
        ResultType result = ResultType(left.sum + right.sum + root->val);
        if (node == NULL || result.sum < data.sum) {
            data = result;
            node = root;
        }

        return result;
    }

private:
    TreeNode* node = NULL;   //存储当前最优节点
    ResultType data;         //存储当前最优结果
};

给一棵二叉树，找出从根节点到叶子节点的所有路径。

输入：{1,2,3,#,5}
输出：[“1->2->5”,“1->3”]

可以用allpath记录所有路径。排名第一。。。但是再运行一次就倒数，；lintcode奇奇怪怪

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
private:
    vector<string> allpath;   //用于记录所有路径并输出
    string mid;     //用于记录根节点
public:
    /**
     * @param root: the root of the binary tree
     * @return: all root-to-leaf paths
     */
    string getroot(TreeNode* root){
        return to_string(root->val);
    }
    
    void dfs(TreeNode* root,vector<string> path){
        if(!root->left && !root->right){
            allpath.push_back(accumulate(path.begin(), path.end(),mid));
            return;
        }
        if(root->left){
            // 输入左子树内容并记录
            path.push_back("->");
            path.push_back(getroot(root->left));
            dfs(root->left,path);
            path.pop_back();path.pop_back();
        }
        if(root->right){
            path.push_back("->");
            path.push_back(getroot(root->right));
            dfs(root->right,path);
            path.pop_back();path.pop_back();
        }
    }
    
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> path;
        if(root == NULL)  return path;
        mid = to_string(root->val);
        dfs(root,path);
        return allpath;
    }
};

最近公共祖先
思路：分治的方式，对于中间节点有以下几种情况：
1、左子树或者右子树，其中一个有返回值，则返回有的那个节点值（保证另一个可能是它子节点）
2、都没有，返回NULL
3、都有，返回该节点

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */


class Solution {
public:
    /*
     * @param root: The root of the binary search tree.
     * @param A: A TreeNode in a Binary.
     * @param B: A TreeNode in a Binary.
     * @return: Return the least common ancestor(LCA) of the two nodes.
     */
    TreeNode * lowestCommonAncestor(TreeNode * root, TreeNode * A, TreeNode * B) {
        if (!root || root == A || root == B) {
            return root;
        }
        TreeNode *left = lowestCommonAncestor(root->left, A, B);
        TreeNode *right = lowestCommonAncestor(root->right, A, B);
        if (left && right) {
            return root;
        }
        return left ? left : right;
    }
};

2、结构变化
翻转一棵二叉树。左右子树交换。

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */
class Solution {
public:
    /**
     * @param root: a TreeNode, the root of the binary tree
     * @return: nothing
     */
    void invertBinaryTree(TreeNode *root) {
        TreeNode *temp = root->left;
        root->left = root->right;
        root->right = temp;
        if (root->left!=NULL) invertBinaryTree(root->left);
        if (root->right!=NULL) invertBinaryTree(root->right);
    }
};

将一棵二叉树按照前序遍历拆解成为一个 假链表。所谓的假链表是说，用二叉树的 right 指针，来表示链表中的 next 指针。
思路：标准in place 解法

/**
 * 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:
    void flatten(TreeNode* root) {
        while (root != nullptr) {
            if (root->left != nullptr) {
                auto most_right = root->left; // 如果左子树不为空, 那么就先找到左子树的最右节点
                while (most_right->right != nullptr) most_right = most_right->right; // 找最右节点
                most_right->right = root->right; // 然后将跟的右孩子放到最右节点的右子树上
                root->right = root->left; // 这时候跟的右孩子可以释放, 因此我令左孩子放到右孩子上
                root->left = nullptr; // 将左孩子置为空
            }
            root = root->right; // 继续下一个节点
        }
        return;
    }
};

作者：hellozhaozheng
链接：https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/solution/biao-biao-zhun-zhun-de-hou-xu-bian-li-dai-ma-jian-/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3、验证二叉查找树
给定一个二叉树，判断它是否是合法的二叉查找树(BST)
一棵BST定义为：

  • 节点的左子树中的值要严格小于该节点的值。
  • 节点的右子树中的值要严格大于该节点的值。
  • 左右子树也必须是二叉查找树。
  • 一个节点的树也是二叉查找树。
    Example
    样例 1:
    输入：{-1}
    输出：true
    解释：
    二叉树如下(仅有一个节点）:
    -1
    这是二叉查找树。
    样例 2:
    输入：{2,1,4,#,#,3,5}
    输出：true
/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: The root of binary tree.
     * @return: True if the binary tree is BST, or false
     */
    bool isValidBST(TreeNode * root) {
        return dfs4(root);
    }
    
    bool dfs4(TreeNode * root) {
        if (root == NULL) {
            return true;
        }
        
        // Judge the left tree.
        if (!dfs4(root->left)) {
            return false;
        }
        
        // judge the sequence.
        // 这里，遍历方法的每一次赋值的root都是从最低到高的，第一次赋值就是最左的子叶，所以每次递归只需要判断一次就可以
        if (pre != NULL && root->val <= pre->val) {
            return false;
        }
        pre = root;
        
        // Judge the right tree.
        if (!dfs4(root->right)) {
            return false;
        }
        
        return true;
    }

private:
    TreeNode* pre = NULL;
};

给一棵二叉搜索树，写一个 KthSmallest 函数来找到其中第 K 小的元素。
思路：如果k为0，返回x即可。如果–k为0，返回当前节点值，否则继续向右子树搜索(右子树的节点值小于当前节点的父亲节点)。
注意这里要用中间变量x,保证k多自减一次！k是这里的局部变量，思路有点绕。

class Solution {
public:
    /**
     * @param root: the given BST
     * @param k: the given k
     * @return: the kth smallest element in BST
     */
    int kthSmallest(TreeNode * root, int k) {
        // write your code here
        return find(root, k);
    }
    int find(TreeNode* root, int& k) {
        if (root) {
            int x = find(root->left, k);
            return !k ? x : !--k ? root->val : find(root->right, k);  //如果k为0，返回x即可。如果--k为0，返回当前节点值，否则继续向右子树搜索。
        }
    }    
};

二叉查找树迭代器
经典题背诵！
leetcode上的解答更好一些。
初始化的时候先把root的所有左边的节点入栈
hasNext只要栈不空就是还有下一个元素
next，取出栈顶元素p(当前返回值)。把p的右子树的左节点全部入栈

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class BSTIterator {
private:
    stack<TreeNode*> stk;
public:
    BSTIterator(TreeNode* root) {
        TreeNode *p = root;
        while (p) {
            stk.push(p);
            p = p->left;
        }
    }
    
    /** @return the next smallest number */
    int next() {
        TreeNode *p = stk.top(); stk.pop();
        int res = p->val;
        p = p->right;
        while (p) {
            stk.push(p);
            p = p->left;
        }
        return res;
    }
    
    /** @return whether we have a next smallest number */
    bool hasNext() {
        return !stk.empty();
    }
};

/**
 * Your BSTIterator object will be instantiated and called as such:
 * BSTIterator* obj = new BSTIterator(root);
 * int param_1 = obj->next();
 * bool param_2 = obj->hasNext();
 */

给一棵非空二叉搜索树以及一个target值，找到在BST中最接近给定值的节点值。

中序遍历更新，时间复杂度O(n)。
其实找到相邻的大和小两个数，比一下就好了，时间复杂度O(logn)。

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: the given BST
     * @param target: the given target
     * @return: the value in the BST that is closest to the target
     */
    int closestValue(TreeNode * root, double target) {
        // write your code here
        int closest = root->val;
        while (root) {
            if (abs(closest - target) >= abs(root->val - target)) {
                closest = root->val;
            }
            root = target < root->val ? root->left : root->right;
        }
        return closest;        
    }
};

closest binary search tree value
给定一棵非空二叉搜索树以及一个target值，找到 BST 中最接近给定值的 k 个数。
报错！需要再修改！

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: the given BST
     * @param target: the given target
     * @param k: the given k
     * @return: k values in the BST that are closest to the target
     */
    stack<TreeNode* > findtarget(TreeNode * root,double target){
        stack<TreeNode* > bfvector;
        while(root){
            bfvector.push(root);
            if (root->val > target){
                root = root->left;
            }
            else{
                root = root ->right;
            }
        }
        return bfvector;
    }
    
    void bef(stack<TreeNode*> stack){
        TreeNode* node=stack.top();
        //右子树最左子叶
        if(node->left == NULL){
            node = stack.top(); stack.pop();
            while(stack.size()&&stack.top()->left==node){
                node = stack.top(); stack.pop();
            }
            return;
        }
        //左子树最右子叶
        else{
            node = node->left;
            while(node){
                stack.push(node);
                node = node->right;
            }
        }
        return;
    }

    void aft(stack<TreeNode*> stack){
        TreeNode* node = stack.top();
        if(node->right == NULL){
            node = stack.top(); stack.pop();
            while(stack.size()&&stack.top()->right==node){
                node = stack.top(); stack.pop();
            }
            return;
        }
        else{
            node = node->right;
            while(node){
                stack.push(node);
                node = node->left;
            }
        }
        return;
    }
    
    
    vector<int> closestKValues(TreeNode * root, double target, int k) {
        vector<int> output;
        if(!root||k==0) return output;
        stack<TreeNode*> bfvector = findtarget(root,target);
        stack<TreeNode*> afvector = findtarget(root,target);
        if(target < bfvector.top()->val){
            bef(bfvector); 
        }else{
            aft(afvector);
        }
        
        //找到最接近的root
        for(int i = 0;i<k;i++){
            if(bfvector.size()==0||afvector.size()!=0 && (target - bfvector.top()->val) > (afvector.top()->val-target)){
                output.push_back(afvector.top()->val);
                aft(afvector);
            }else{
                output.push_back(bfvector.top()->val);
                bef(bfvector);
            }
        }
        return output;
    }
};

在这里插入图片描述
补充学习二叉查找树的增删查改！

ZDD_HUST
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HamletXiaoyu#leetcode#671二叉树中第二小的节点1
07-25
671. 二叉树中第二小的节点给定一个非空特殊的二叉树，每个节点都是正数，并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话，那么这个节点
算法（1）常用遍历算法
ls3614140的博客
08-24 274
一.常用遍历算法 1.for_each 2.transfrom for_each //1.使用函数进行遍历 for_each(v.begin(), v.end(), print1); cout <<endl; //2.使用仿函数进行遍历 for_each(v.begin(), v.end(), print2()); cout <<endl; transfrom：搬运：把一个容器的元素搬运到目标容器 注意：目标容器需要提前开辟空间——vTaregt.r..
数组遍历的方法
m0_58861443的博客
08-04 600
数组的遍历方法 reduce 常用于求和 array.reduce(function(sum,item){ sum// 第一次取的值数组中第一个值，后面取的值都是最后返回的值 item // 数组中第二个值，每次都依次取值 //数组的时候可以不给初始值,初始值一般为0 //数组包对象时要给初始值0 }，初始值) 例子 求下面数组的和 let arr=[1,2,3,4] arr.reduce(function(sum,item){ return s
遍历算法
莱尼的博客
01-17 5019
1.DFS（Depth-First Search） 部分和问题 Lake Counting 2.BFS(Breadth-First Search) Maze问题
常用数据遍历的方法
m0_52933282的博客
08-20 2828
常用数据遍历方法，刷题必备
存入二叉树的算术表达式的遍历求值
m0_60939437的博客
11-21 445
思路是后续遍历二叉树（也就是后最表达式）遍历到一个元素时存入到栈里一个，如果遇到符号就弹出当前的两个栈顶元素和符号运算，求出值再插入栈中，知道最后一个元素就是算数表达式的值。 #include<stdio.h> #include<stdlib.h> #define MaxSize 50 typedef struct{ char data[MaxSize]; int top; }Sqstack; void InitStack(Sqstack &s){ s.top=-
MangoDowner#clear-leetcode#671.二叉树中第二小的节点1
07-25
671. 二叉树中第二小的节点解题思路由题意可得，最小的数，肯定是根节点的值rootVal那么我们只要找到仅比根节点大的数就好了深度遍历root节点，初始化第二
java-leetcode题解之第387题字符串中的第一个唯一字符.zip
最新发布
05-29
java java_leetcode题解之第387题字符串中的第一个唯一字符
java面试题-leetcode题解之第28题找出字符串中第一个匹配项的下标.zip
05-24
java面试题 java面试题_leetcode题解之第28题找出字符串中第一个匹配项的下标
C#-Leetcode编程题解之第28题找出字符串中第一个匹配项的下标.zip
04-30
c# C#_Leetcode编程题解之第28题找出字符串中第一个匹配项的下标
数据结构与算法(Python版)四十九：树的遍历
神薯片
06-30 1290
树的遍历Tree Traversals 对一个数据集中的所有数据项进行访问的操作称为“遍历Traversal” 线性数据结构中， 对其所有数据项的访问比较简单直接 按照顺序依次进行即可 树的非线性特点， 使得遍历操作较为复杂 我们按照对节点访问次序的不同来区分3种遍历 前序遍历（preorder）：先访问根节点，再递归地前序访问左子树、最后前序访问右子树； 中序遍历（inorder）：先递归地中序访问左子树，再访问根节点，最后中序访问右子树； 后序遍历（postorder）：先递归地后序访问左子树，再后序
使用递归遍历对象获得value值的实现方法
weixin_44263292的博客
10-12 478
使用递归遍历对象获得value值的实现方法 下面小编就为大家带来一篇使用递归遍历对象获得value值的实现方法。小编觉得挺不错的，现在就分享给大 家，也给大家做个参考。一起跟随小编过来看看吧 一般要用到递归，就要判断对象是否和父类型是否一样 这里演示简单的对象递归，还有数组递归类似。 var obj = { a:{w:1,y:2,x:3}, b:{s:4,j:5,x:6}, c:{car:7,cat:8,mao:9} } function f(s){ for(var i in s){ if(typeof s
list遍历的三种方法
weixin_68107783的博客
01-07 1071
List集合遍历三种方法 第一种、最基础的遍历方式：for循环，指定下标长度，使用List集合的size()方法，进行for循环遍历 第二种、较为简洁的遍历方式：使用foreach遍历List，但不能对某一个元素进行操作（这种方法在遍历数组和Map集合的时候同样适用） 第三种、适用迭代器Iterator遍历：直接根据List集合的自动遍历
数组遍历的几个方法
weixin_37150764的博客
02-27 1964
1、forEach：遍历开始以后无法停止，如果要遍历整个数组，那就使用这个方法； 2、map：根据当前数组映射出一个新的数组； 3、some：遍历整个数组，返回值true就停止循环（返回false继续循环） 返回值：如果数组中的有一项回调函数返回true，那么结果为true，否则为false；（或者这样理解：数组别遍历完，那么结果为false，否则为true） 4、every：与some相反，返回false就停止循环（返回true就继续循环） 5、filter：过滤数组，返回一个新的数组 6、reduce：
遍历数组的方法和数组的遍历方法(3+10种)（上）
weixin_49602426的博客
11-01 300
总所周知，遍历的方法有很多种，有遍历对象遍历字符串遍历数组，那么数组当然也有非常多种方法，但是一般面试的时候就会有一个坑，遍历数组的方法和数组的遍历方法其实是不一样的，那么区别在哪里呢？从标记上面也可以看出来，后者是偏重数组的，所以数组的遍历方法指的是数组众多方法里面自带遍历功能的方法，比如说：那遍历数组的方法又是只什么呢？指的就是在一般常用方法里面带有遍历并且是可以遍历数组的方法，比如说：for循环、for in、for of。
遍历数组的常用方法
热门推荐
qq_36846234的博客
12-27 5万+
1.最传统方法 for循环 var arr = ["first","second","third","fourth",3,5,8]; for(var i = 0; i < arr.length;i++){ console.log(arr[i]); } //输出： first second third fourth
表达式求值问题
Second to none的博客
10-11 630
表达式求值问题 1.中缀表达式和后缀表达式介绍 ​ 在双目运算中，我们平常写的表达式类似于x*y的这种形式，其运算符在两个操作符之间，我们称这种表达式为中缀表达式。在对该表达式求值时，必须注意运算符的优先级，有时为了正确表示运算顺序，还需要借用括号，也就是说运算符的实际次序往往同它们在表达式的先后次序不一致时，这种形式的表达式对于我们来说是很容易理解，但是要用计算机去计算中缀表达式的值比较复杂。因此人们提出了后缀表达式，即逆波兰式。 ​ 什么是逆波兰式？所谓的逆波兰式是一种数学表达
4种循环遍历的方法
weixin_45846980的博客
07-26 3342
JS中4种风格的For循环有什么异同？   在学习任何开发语言时候，for循环是必不可少的一种语法，每个开发语言都至少包括一种关于循环的语法版本。不过，在JavaScript种包含了四种不同的循环语法 l 经典的For循环语法 l For….of 及 For…in l entries(); l 炫技一点的版本：.forEach 经典的For循环 语法 for([计数器定义];[中断条件];[步进策略]){ //... TODO } 最为普通的遍历方法 for(let counter
C++ 学习之常用遍历算法
阿乐的博客
11-02 382
1、 for_each 实现遍历容器 for_each(iterator beg, iterator end, _func); // 遍历算法 遍历容器元素 // beg 开始迭代器 // end 结束迭代器 // _func 函数或者函数对象 2、 transform 搬运容器到另一个容器中 transform(iterator beg1, iterator end1, iterator beg2, _func); //beg1 源容器开始迭代器 //end1 源容器结束迭代器 /
leetcode 二叉树
09-16
二叉树是一种特殊的数据结构，它由节点组成，每个节点最多有两个子节点。在LeetCode上，二叉树问题是常见的算法题型，我们需要实现各种操作，如合并树、找出深度、遍历等。 在引用中，给出了一个合并二叉树的解法。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值