【算法学习】剑指 Offer II 054. 所有大于等于节点的值之和|538|1038(java / c / c++ / python / go / rust)

简介: 给定一个二叉搜索树,请将它的每个节点的值替换成树中大于或者等于该节点值的所有节点值之和。提醒一下,二叉搜索树满足下列约束条件: 节点的左子树仅包含键 小于 节点键的节点。 节点的右子树仅包含键 大于 节点键的节点。 左右子树也必须是二叉搜索树。

剑指 Offer II 054. 所有大于等于节点的值之和|538. 把二叉搜索树转换为累加树|1038. 把二叉搜索树转换为累加树:

给定一个二叉搜索树,请将它的每个节点的值替换成树中大于或者等于该节点值的所有节点值之和。

提醒一下,二叉搜索树满足下列约束条件:

  • 节点的左子树仅包含键 小于 节点键的节点。
  • 节点的右子树仅包含键 大于 节点键的节点。
  • 左右子树也必须是二叉搜索树。

样例 1

在这里插入图片描述

输入:
    root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
    
输出:
    [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]

样例 2

输入:
    root = [0,null,1]
    
输出:
    [1,null,1]

样例 3

输入:
    root = [1,0,2]
    
输出:
    [3,3,2]

样例 4

输入:
    root = [3,2,4,1]
    
输出:
    [7,9,4,10]

提示

  • 树中的节点数介于 0104 之间。
  • 每个节点的值介于 -104104 之间。
  • 树中的所有值 互不相同
  • 给定的树为二叉搜索树。

分析

  • 这道算法题需要翻译一下,通俗易懂一点。
  • 二叉树,大家应该比较熟悉,一般就是正序遍历,中序遍历,后序遍历,然后遍历的过程中进行一些简单的逻辑。
  • 二叉搜索树是一种特殊的二叉树,题目已经做了解释。
  • 由于要把每个节点的值替换成树中大于或者等于该节点值的所有节点值之和,根据二叉搜索树的特点,其实就是将每个节点的值替换成自己的值累加右子树的值之和。
  • 首先这一样需要遍历每个节点,但是按照什么顺序是关键,你会发现常规正序遍历,中序遍历,后序遍历都不顺畅。
  • 按照题意来看,显然最好的顺序就是先遍历右子树,然后根节点,接着左子树这样是最顺畅的,仅需要一个变量不断累加节点值,遍历到哪个节点就累加哪个节点的值,然后赋值给这个节点,这正好和中序遍历是反正的,也就是逆中序遍历。
  • 遍历这种套娃结构,一般就是递归或者循环(利用栈数据结构),递归相对比较简单,但是受调用栈限制,循环其实就是用栈这样的数据结构模拟了调用栈,本质上差不多,但是调用次数可以更多,因为调用栈的空间一般比较有限,堆空间比起来要大的多,但是实现同样的功能,逻辑上也复杂一些。
  • 无论用递归还是用栈数据结构去做循环,都需要与树结构对应的额外内存空间,有一种非常巧妙的遍历方法叫做 Morris遍历 ,可以将非递归遍历中的空间复杂度降为O (1),具体的实现二当家的已经加了详细注释,大家也可以去百科一下,做深入了解。

题解

java

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode convertBST(TreeNode root) {
        int      sum = 0;
        TreeNode cur = root;

        while (cur != null) {
            if (cur.right == null) {
                // 没有比自己值大的孩子
                // 轮到处理自己
                sum += cur.val;
                cur.val = sum;
                // 自己也遍历完了,所以该遍历比自己小的
                cur = cur.left;
            } else {
                // 右孩子的最左边,比自己大的最小的孩子
                // 也就是自己前边最后一个遍历的节点,下一个就该是自己
                TreeNode leftmostOfRight = cur.right;
                while (leftmostOfRight.left != null
                    && leftmostOfRight.left != cur) {
                    leftmostOfRight = leftmostOfRight.left;
                }
                if (leftmostOfRight.left == null) {
                    // 没有做过关联,说明第一次到这里,关联当前节点,保证遍历完比自己大的最小节点之后可以轮到自己
                    leftmostOfRight.left = cur;
                    cur = cur.right;
                } else {
                    // 第二次遍历到这里,说明比自己大的都遍历完了
                    // 解除关系,还原树结构
                    leftmostOfRight.left = null;
                    // 轮到处理自己
                    sum += cur.val;
                    cur.val = sum;
                    // 自己也遍历完了,所以该遍历比自己小的
                    cur = cur.left;
                }
            }
        }

        return root;
    }
}

c

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


struct TreeNode* convertBST(struct TreeNode* root){
    int sum = 0;
    struct TreeNode *cur = root;

    while (cur != NULL) {
        if (cur->right == NULL) {
            // 没有比自己值大的孩子
            // 轮到处理自己
            sum += cur->val;
            cur->val = sum;
            // 自己也遍历完了,所以该遍历比自己小的
            cur = cur->left;
        } else {
            // 右孩子的最左边,比自己大的最小的孩子
            // 也就是自己前边最后一个遍历的节点,下一个就该是自己
            struct TreeNode *leftmostOfRight = cur->right;
            while (leftmostOfRight->left != NULL
                   && leftmostOfRight->left != cur) {
                leftmostOfRight = leftmostOfRight->left;
            }
            if (leftmostOfRight->left == NULL) {
                // 没有做过关联,说明第一次到这里,关联当前节点,保证遍历完比自己大的最小节点之后可以轮到自己
                leftmostOfRight->left = cur;
                cur = cur->right;
            } else {
                // 第二次遍历到这里,说明比自己大的都遍历完了
                // 解除关系,还原树结构
                leftmostOfRight->left = NULL;
                // 轮到处理自己
                sum += cur->val;
                cur->val = sum;
                // 自己也遍历完了,所以该遍历比自己小的
                cur = cur->left;
            }
        }
    }

    return root;
}

c++

/**
 * 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:
    TreeNode* convertBST(TreeNode* root) {
        int sum = 0;
        TreeNode *cur = root;

        while (cur != nullptr) {
            if (cur->right == nullptr) {
                // 没有比自己值大的孩子
                // 轮到处理自己
                sum += cur->val;
                cur->val = sum;
                // 自己也遍历完了,所以该遍历比自己小的
                cur = cur->left;
            } else {
                // 右孩子的最左边,比自己大的最小的孩子
                // 也就是自己前边最后一个遍历的节点,下一个就该是自己
                TreeNode *leftmostOfRight = cur->right;
                while (leftmostOfRight->left != nullptr
                       && leftmostOfRight->left != cur) {
                    leftmostOfRight = leftmostOfRight->left;
                }
                if (leftmostOfRight->left == nullptr) {
                    // 没有做过关联,说明第一次到这里,关联当前节点,保证遍历完比自己大的最小节点之后可以轮到自己
                    leftmostOfRight->left = cur;
                    cur = cur->right;
                } else {
                    // 第二次遍历到这里,说明比自己大的都遍历完了
                    // 解除关系,还原树结构
                    leftmostOfRight->left = nullptr;
                    // 轮到处理自己
                    sum += cur->val;
                    cur->val = sum;
                    // 自己也遍历完了,所以该遍历比自己小的
                    cur = cur->left;
                }
            }
        }

        return root;
    }
};

python

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def convertBST(self, root: TreeNode) -> TreeNode:
        total = 0
        cur = root

        while cur:
            if not cur.right:
                # 没有比自己值大的孩子
                # 轮到处理自己
                total += cur.val
                cur.val = total
                # 自己也遍历完了,所以该遍历比自己小的
                cur = cur.left
            else:
                # 右孩子的最左边,比自己大的最小的孩子
                # 也就是自己前边最后一个遍历的节点,下一个就该是自己
                leftmostOfRight = cur.right
                while leftmostOfRight.left and leftmostOfRight.left != cur:
                    leftmostOfRight = leftmostOfRight.left

                if not leftmostOfRight.left:
                    # 没有做过关联,说明第一次到这里,关联当前节点,保证遍历完比自己大的最小节点之后可以轮到自己
                    leftmostOfRight.left = cur
                    cur = cur.right
                else:
                    # 第二次遍历到这里,说明比自己大的都遍历完了
                    # 解除关系,还原树结构
                    leftmostOfRight.left = None
                    # 轮到处理自己
                    total += cur.val
                    cur.val = total
                    # 自己也遍历完了,所以该遍历比自己小的
                    cur = cur.left

        return root
        

go

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func convertBST(root *TreeNode) *TreeNode {
    sum := 0
    cur := root

    for cur != nil {
        if cur.Right == nil {
            // 没有比自己值大的孩子
            // 轮到处理自己
            sum += cur.Val
            cur.Val = sum
            // 自己也遍历完了,所以该遍历比自己小的
            cur = cur.Left
        } else {
            // 右孩子的最左边,比自己大的最小的孩子
            // 也就是自己前边最后一个遍历的节点,下一个就该是自己
            leftmostOfRight := cur.Right
            for leftmostOfRight.Left != nil && leftmostOfRight.Left != cur {
                leftmostOfRight = leftmostOfRight.Left
            }
            if leftmostOfRight.Left == nil {
                // 没有做过关联,说明第一次到这里,关联当前节点,保证遍历完比自己大的最小节点之后可以轮到自己
                leftmostOfRight.Left = cur
                cur = cur.Right
            } else {
                // 第二次遍历到这里,说明比自己大的都遍历完了
                // 解除关系,还原树结构
                leftmostOfRight.Left = nil
                // 轮到处理自己
                sum += cur.Val
                cur.Val = sum
                // 自己也遍历完了,所以该遍历比自己小的
                cur = cur.Left
            }
        }
    }

    return root
}

rust

// Definition for a binary tree node.
// #[derive(Debug, PartialEq, Eq)]
// pub struct TreeNode {
//   pub val: i32,
//   pub left: Option<Rc<RefCell<TreeNode>>>,
//   pub right: Option<Rc<RefCell<TreeNode>>>,
// }
//
// impl TreeNode {
//   #[inline]
//   pub fn new(val: i32) -> Self {
//     TreeNode {
//       val,
//       left: None,
//       right: None
//     }
//   }
// }
use std::rc::Rc;
use std::cell::RefCell;
impl Solution {
    pub fn convert_bst(root: Option<Rc<RefCell<TreeNode>>>) -> Option<Rc<RefCell<TreeNode>>> {
        let mut sum = 0;
        let mut cur = root.clone();

        while cur.is_some() {
            if cur.as_ref().unwrap().borrow().right.is_none() {
                // 没有比自己值大的孩子
                // 轮到处理自己
                sum += cur.as_ref().unwrap().borrow().val;
                cur.as_ref().unwrap().borrow_mut().val = sum;
                // 自己也遍历完了,所以该遍历比自己小的
                cur = cur.unwrap().borrow().left.clone();
            } else {
                // 右孩子的最左边,比自己大的最小的孩子
                // 也就是自己前边最后一个遍历的节点,下一个就该是自己
                let mut leftmostOfRight = cur.as_ref().unwrap().borrow().right.clone();
                while leftmostOfRight.as_ref().unwrap().borrow().left.is_some()
                    && leftmostOfRight.as_ref().unwrap().borrow().left != cur {
                    leftmostOfRight = leftmostOfRight.unwrap().borrow().left.clone();
                }
                if leftmostOfRight.as_ref().unwrap().borrow().left.is_none() {
                    // 没有做过关联,说明第一次到这里,关联当前节点,保证遍历完比自己大的最小节点之后可以轮到自己
                    leftmostOfRight.unwrap().borrow_mut().left = cur.clone();
                    cur = cur.unwrap().borrow().right.clone();
                } else {
                    // 第二次遍历到这里,说明比自己大的都遍历完了
                    // 解除关系,还原树结构
                    leftmostOfRight.unwrap().borrow_mut().left = Option::None;
                    // 轮到处理自己
                    sum += cur.as_ref().unwrap().borrow().val;
                    cur.as_ref().unwrap().borrow_mut().val = sum;
                    // 自己也遍历完了,所以该遍历比自己小的
                    cur = cur.unwrap().borrow().left.clone();
                }
            }
        }

        root
    }
}

在这里插入图片描述


原题传送门:https://leetcode-cn.com/problems/w6cpku/

原题传送门:https://leetcode-cn.com/problems/convert-bst-to-greater-tree/

原题传送门:https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/


非常感谢你阅读本文~
放弃不难,但坚持一定很酷~
希望我们大家都能每天进步一点点~
本文由 二当家的白帽子:https://developer.aliyun.com/profile/sqd6avc7qgj7y 博客原创~

相关文章
|
17小时前
|
Java Go C#
编程语言C#、C++、Java、Python、go 选择哪个好?
我想说的是,不论选择哪种编程语言,决定选择的都是你最终的目的,做选择之前,先充分调研每一个选择项,再做选择思路就会非常清晰了。
8 3
|
1天前
|
存储 编译器 程序员
【C++高阶】C++继承学习手册:全面解析继承的各个方面
【C++高阶】C++继承学习手册:全面解析继承的各个方面
|
1天前
|
Java C++
java和C++的标志符可以是中文(虽然不提倡)
java和C++的标志符可以是中文(虽然不提倡)
|
2天前
|
Java C++
Java和C++的一些区别
Java和C++的一些区别
|
2天前
|
编译器 C语言 C++
c++primer plus 6 读书笔记 第二章 开始学习C++
c++primer plus 6 读书笔记 第二章 开始学习C++
|
2天前
|
编译器 C++
C++学习笔记(二开始学习C++)
C++学习笔记(二开始学习C++)
|
6天前
|
存储 SQL 算法
|
6天前
|
SQL 算法 数据挖掘
力扣题目 19:删除链表的倒数第N个节点 【python】
力扣题目 19:删除链表的倒数第N个节点 【python】
|
8天前
|
Java API C++
Java JNI开发时常用数据类型与C++中数据类型转换
Java JNI开发时常用数据类型与C++中数据类型转换
13 0
|
8天前
|
Java API Android开发
Java通过JNI调用C++的DLL库
Java通过JNI调用C++的DLL库
7 0