2024年最全【算法】剑指 Offer II 054

最新推荐文章于 2024-10-01 04:50:10 发布

2401_84281655

最新推荐文章于 2024-10-01 04:50:10 发布

阅读量52

点赞数 1

分类专栏：程序员文章标签：算法数据结构 leetcode

本文链接：https://blog.csdn.net/2401_84281655/article/details/138364643

版权

程序员专栏收录该内容

167 篇文章 2 订阅

订阅专栏

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();



### 一、网安学习成长路线图


网安所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/aa7be04dc8684d7ea43acc0151aebbf1.png)


### 二、网安视频合集


观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/f0aeee2eec7a48f4ad7d083932cb095d.png)


### 三、精品网安学习书籍


当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/078ea1d4cda342f496f9276a4cda5fcf.png)


### 四、网络安全源码合集+工具包


光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/e54c0bac8f3049928b488dc1e5080fc5.png)


### 五、网络安全面试题


最后就是大家最关心的网络安全面试题板块  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/15c1192cad414044b4dd41f3df44433d.png)![在这里插入图片描述](https://img-blog.csdnimg.cn/b07abbfab1fd4edc800d7db3eabb956e.png)  



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以点击这里获取](https://bbs.csdn.net/topics/618540462)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**