算法基础7(1)，HR的话扎心了

最新推荐文章于 2024-07-19 22:36:19 发布

2401_83944328

最新推荐文章于 2024-07-19 22:36:19 发布

阅读量534

点赞数 12

分类专栏： 2024年程序员学习文章标签：算法 java 开发语言

本文链接：https://blog.csdn.net/2401_83944328/article/details/137203323

版权

2024年程序员学习专栏收录该内容

281 篇文章 0 订阅

订阅专栏

}

// 左右中 -> stack(中右左)

Stack stack = new Stack<>();

while (!poslist.isEmpty()) {

stack.push(poslist.poll());

}

return posb(stack);

}

public static Node posb(Stack posstack) {

String value = posstack.pop();

if (value == null) {

return null;

}

Node head = new Node(Integer.valueOf(value));

head.right = posb(posstack);

head.left = posb(posstack);

return head;

}

public static Queue levelSerial(Node head) {

Queue ans = new LinkedList<>();

if (head == null) {

ans.add(null);

} else {

ans.add(String.valueOf(head.value));

Queue queue = new LinkedList();

queue.add(head);

while (!queue.isEmpty()) {

head = queue.poll();

if (head.left != null) {

ans.add(String.valueOf(head.left.value));

queue.add(head.left);

} else {

ans.add(null);

}

if (head.right != null) {

ans.add(String.valueOf(head.right.value));

queue.add(head.right);

} else {

ans.add(null);

}

return ans;

}

public static Node buildByLevelQueue(Queue levelList) {

if (levelList == null || levelList.size() == 0) {

return null;

}

Node head = generateNode(levelList.poll());

Queue queue = new LinkedList();

if (head != null) {

queue.add(head);

}

Node node = null;

while (!queue.isEmpty()) {

node = queue.poll();

node.left = generateNode(levelList.poll());

node.right = generateNode(levelList.poll());

if (node.left != null) {

queue.add(node.left);

}

if (node.right != null) {

queue.add(node.right);

}

return head;

}

public static Node generateNode(String val) {

if (val == null) {

return null;

}

return new Node(Integer.valueOf(val));

}

// for test

public static Node generateRandomBST(int maxLevel, int maxValue) {

return generate(1, maxLevel, maxValue);

}

// for test

public static Node generate(int level, int maxLevel, int maxValue) {

if (level > maxLevel || Math.random() < 0.5) {

return null;

}

Node head = new Node((int) (Math.random() * maxValue));

head.left = generate(level + 1, maxLevel, maxValue);

head.right = generate(level + 1, maxLevel, maxValue);

return head;

}

// for test

public static boolean isSameValueStructure(Node head1, Node head2) {

if (head1 == null && head2 != null) {

return false;

}

if (head1 != null && head2 == null) {

return false;

}

if (head1 == null && head2 == null) {

return true;

}

if (head1.value != head2.value) {

return false;

}

return isSameValueStructure(head1.left, head2.left) && isSameValueStructure(head1.right, head2.right);

}

// for test

public static void printTree(Node head) {

System.out.println(“Binary Tree:”);

printInOrder(head, 0, “H”, 17);

System.out.println();

}

public static void printInOrder(Node head, int height, String to, int len) {

if (head == null) {

return;

}

printInOrder(head.right, height + 1, “v”, len);

String val = to + head.value + to;

int lenM = val.length();

int lenL = (len - lenM) / 2;

int lenR = len - lenM - lenL;

val = getSpace(lenL) + val + getSpace(lenR);

System.out.println(getSpace(height * len) + val);

printInOrder(head.left, height + 1, “^”, len);

}

public static String getSpace(int num) {

String space = " ";

StringBuffer buf = new StringBuffer(“”);

for (int i = 0; i < num; i++) {

buf.append(space);

}

return buf.toString();

}

public static void main(String[] args) {

int maxLevel = 5;

int maxValue = 100;

int testTimes = 1000000;

System.out.println(“test begin”);

for (int i = 0; i < testTimes; i++) {

Node head = generateRandomBST(maxLevel, maxValue);

Queue pre = preSerial(head);

Queue pos = posSerial(head);

Queue level = levelSerial(head);

Node preBuild = buildByPreQueue(pre);

Node posBuild = buildByPosQueue(pos);

Node levelBuild = buildByLevelQueue(level);

if (!isSameValueStructure(preBuild, posBuild) || !isSameValueStructure(posBuild, levelBuild)) {

System.out.println(“Oops!”);

}

System.out.println(“test finish!”);

}

7.二叉树宽度

package class07;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.Queue;

public class Code06_TreeMaxWidth {

public static class Node {

public int value;

public Node left;

public Node right;

public Node(int data) {

this.value = data;

}

public static int maxWidthUseMap(Node head) {

if (head == null) {

return 0;

}

Queue queue = new LinkedList<>();

queue.add(head);

// key 在哪一层，value

HashMap<Node, Integer> levelMap = new HashMap<>();

levelMap.put(head, 1);

int curLevel = 1; // 当前你正在统计哪一层的宽度

int curLevelNodes = 0; // 当前层curLevel层，宽度目前是多少

int max = 0;

while (!queue.isEmpty()) {

Node cur = queue.poll();

int curNodeLevel = levelMap.get(cur);

if (cur.left != null) {

levelMap.put(cur.left, curNodeLevel + 1);

queue.add(cur.left);

}

if (cur.right != null) {

levelMap.put(cur.right, curNodeLevel + 1);

queue.add(cur.right);

}

if (curNodeLevel == curLevel) {

curLevelNodes++;

} else {

max = Math.max(max, curLevelNodes);

curLevel++;

curLevelNodes = 1;

}

max = Math.max(max, curLevelNodes);

return max;

}

public static int maxWidthNoMap(Node head) {

if (head == null) {

return 0;

}

Queue queue = new LinkedList<>();

queue.add(head);

Node curEnd = head; // 当前层，最右节点是谁

Node nextEnd = null; // 下一层，最右节点是谁

int max = 0;

int curLevelNodes = 0; // 当前层的节点数

while (!queue.isEmpty()) {

Node cur = queue.poll();

if (cur.left != null) {

queue.add(cur.left);

nextEnd = cur.left;

}

if (cur.right != null) {

queue.add(cur.right);

nextEnd = cur.right;

}

curLevelNodes++;

if (cur == curEnd) {

max = Math.max(max, curLevelNodes);

curLevelNodes = 0;

curEnd = nextEnd;

}

return max;

}

// for test

public static Node generateRandomBST(int maxLevel, int maxValue) {

return generate(1, maxLevel, maxValue);

}

// for test

public static Node generate(int level, int maxLevel, int maxValue) {

if (level > maxLevel || Math.random() < 0.5) {

return null;

}

Node head = new Node((int) (Math.random() * maxValue));

head.left = generate(level + 1, maxLevel, maxValue);

head.right = generate(level + 1, maxLevel, maxValue);

return head;

}

public static void main(String[] args) {

int maxLevel = 10;

int maxValue = 100;

int testTimes = 1000000;

for (int i = 0; i < testTimes; i++) {

Node head = generateRandomBST(maxLevel, maxValue);

if (maxWidthUseMap(head) != maxWidthNoMap(head)) {

System.out.println(“Oops!”);

}

System.out.println(“finish!”);

}

二、面试题

1.如何设计一个打印整棵树的打印函数

package class07;

public class Code05_PrintBinaryTree {

public static class Node {

public int value;

public Node left;

public Node right;

public Node(int data) {

this.value = data;

}

public static void printTree(Node head) {

System.out.println(“Binary Tree:”);

printInOrder(head, 0, “H”, 17);

System.out.println();

}

public static void printInOrder(Node head, int height, String to, int len) {

if (head == null) {

return;

}

printInOrder(head.right, height + 1, “v”, len);

String val = to + head.value + to;

int lenM = val.length();

int lenL = (len - lenM) / 2;

int lenR = len - lenM - lenL;

val = getSpace(lenL) + val + getSpace(lenR);

System.out.println(getSpace(height * len) + val);

printInOrder(head.left, height + 1, “^”, len);

}

public static String getSpace(int num) {

String space = " ";

StringBuffer buf = new StringBuffer(“”);

for (int i = 0; i < num; i++) {

buf.append(space);

}

return buf.toString();

}

public static void main(String[] args) {

Node head = new Node(1);

head.left = new Node(-222222222);

head.right = new Node(3);

head.left.left = new Node(Integer.MIN_VALUE);

head.right.left = new Node(55555555);

head.right.right = new Node(66);

head.left.left.right = new Node(777);

printTree(head);

head = new Node(1);

head.left = new Node(2);

head.right = new Node(3);

head.left.left = new Node(4);

head.right.left = new Node(5);

head.right.right = new Node(6);

head.left.left.right = new Node(7);

printTree(head);

head = new Node(1);

head.left = new Node(1);

head.right = new Node(1);

head.left.left = new Node(1);

head.right.left = new Node(1);

head.right.right = new Node(1);

head.left.left.right = new Node(1);

printTree(head);

}

2.题目2

二叉树结构如下定义:

Class Node {

V value;

Node left;

Node right;

Node parent;

}

给你二叉树中的某个节点，返回该节点的后继节点

package class07;

public class Code07_SuccessorNode {

public static class Node {

public int value;

public Node left;

public Node right;

public Node parent;

public Node(int data) {

this.value = data;

}

public static Node getSuccessorNode(Node node) {

if (node == null) {

return node;

}

if (node.right != null) {

return getLeftMost(node.right);

} else { // 无右子树

Node parent = node.parent;

while (parent != null && parent.right == node) { // 当前节点是其父亲节点右孩子

node = parent;

parent = node.parent;

}

return parent;

}

public static Node getLeftMost(Node node) {

if (node == null) {

return node;

}

while (node.left != null) {

node = node.left;

}

return node;

}

public static void main(String[] args) {

Node head = new Node(6);

head.parent = null;

head.left = new Node(3);

head.left.parent = head;

head.left.left = new Node(1);

head.left.left.parent = head.left;

head.left.left.right = new Node(2);

head.left.left.right.parent = head.left.left;

head.left.right = new Node(4);

head.left.right.parent = head.left;

head.left.right.right = new Node(5);

head.left.right.right.parent = head.left.right;

head.right = new Node(9);

head.right.parent = head;

head.right.left = new Node(8);

head.right.left.parent = head.right;

head.right.left.left = new Node(7);

head.right.left.left.parent = head.right.left;

head.right.right = new Node(10);

head.right.right.parent = head.right;

Node test = head.left.left;

System.out.println(test.value + " next: " + getSuccessorNode(test).value);

test = head.left.left.right;

System.out.println(test.value + " next: " + getSuccessorNode(test).value);

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

总结

蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。

经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。

蚂蚁金服5面，总结了49个面试题，遇到的面试官都是P7级别以上

己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-XuKDL99T-1711874302485)]
[外链图片转存中…(img-56tW7DJx-1711874302486)]
[外链图片转存中…(img-M51mvwAS-1711874302487)]
[外链图片转存中…(img-iLPWlwor-1711874302487)]
[外链图片转存中…(img-2SLYRcjy-1711874302488)]
[外链图片转存中…(img-IawNFCge-1711874302488)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-NNUO5EcZ-1711874302489)]

总结

[外链图片转存中…(img-Y7Cz65uB-1711874302489)]

2401_83944328

关注

12
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
算法基础7(1)，HR的话扎心了

蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。
复制链接

扫一扫