2024年【算法】剑指 Offer II 054，这些年我所经历的所有面试

最新推荐文章于 2024-05-23 11:51:48 发布

2401_84520026

最新推荐文章于 2024-05-23 11:51:48 发布

阅读量575

点赞数 8

分类专栏：程序员文章标签：算法面试网络

本文链接：https://blog.csdn.net/2401_84520026/article/details/138466722

版权

程序员专栏收录该内容

190 篇文章 0 订阅

订阅专栏

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！

王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。

对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！

【完整版领取方式在文末！！】

93道网络安全面试题

内容实在太多，不一一截图了

黑客学习资源推荐

最后给大家分享一份全套的网络安全学习资料，给那些想学习网络安全的小伙伴们一点帮助！

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

😝朋友们如果有需要的话，可以联系领取~

1️⃣零基础入门

① 学习路线

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

② 路线对应学习视频

同时每个成长路线对应的板块都有配套的视频提供：

2️⃣视频配套工具&国内外网安书籍、文档

① 工具

② 视频

③ 书籍

资源较为敏感，未展示全面，需要的最下面获取

在这里插入图片描述

② 简历模板

在这里插入图片描述

因篇幅有限，资料较为敏感仅展示部分资料，添加上方即可获取👆

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

需要这份系统化资料的朋友，可以点击这里获取

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

遍历这种套娃结构，一般就是递归或者循环（利用栈数据结构），递归相对比较简单，但是受调用栈限制，循环其实就是用栈这样的数据结构模拟了调用栈，本质上差不多，但是调用次数可以更多，因为调用栈的空间一般比较有限，堆空间比起来要大的多，但是实现同样的功能，逻辑上也复杂一些。
无论用递归还是用栈数据结构去做循环，都需要与树结构对应的额外内存空间，有一种非常巧妙的遍历方法叫做 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,


## 写在最后

**在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。**


需要完整版PDF学习资源私我



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

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

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

2401_84520026

关注

8
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
2024年【算法】剑指 Offer II 054，这些年我所经历的所有面试

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！【完整版领取方式在文末！！内容实在太多，不一一截图了。
复制链接

扫一扫