友情提示:仅供参考;
a、题目内容:
1、一面选择题,类似国企的行测,题目不多25道选择题,时间很充裕;包含题型(
阅读理解:一小段话,让你选择一个符合这段话的选项
真假推算:类似 甲乙丙丁中只有一个人说了真话,让你找出谁说了真话;
找规律: 有图像找规律,还有数字找规律
)
2、二面: a、表述什么是双向链表,什么是满二叉树
b、先让写一个双向的链表,
c、然后链表修改成完全二叉树并增加泛型值属性和父节点,入参是一个int 表示二叉树层级
d、在创建二叉树的原有方法上修改,将按照规则填充 ,类型为int,填充顺序见下图(图2-1)
3、三面是在二面的代码基础上进行的
a、将value值改为 char类型,使用 A-Z 填充
b、将3个满二叉树的跟节点循环指向;然后根据指定的任意节点开始遍历,
要求不重复遍历任何节点,不使用集合,不另开劈空间, 不能改节点结构
二面数字填充顺序(图2-1)
b、总结:面试结束后重新思考了一下实现,将步骤拆分成两部,应该是满足要求的:
1、递归遍历指定节点的子节点
2、递归遍历节点的父节点,遍历父节点的时候还会再遍历父节点的子节点,这个时候,通过判断子节点是否为已经
遍历过的子节点来决定是否跳过(通过参数记录上次遍历的子节点引用来判断)
闲聊:网上搜索了一下朗致的风评,全是坏的,这个很难评价;
三面的递归,不知道是否满足题意,朋友们自行鉴别喔;
居然还有人卖答案,感觉像是自导自演,更让我怀疑了;
package lz;
/**
* 包含数据内容
* 前节点,后节点
*/
public class LinkNode<T> {
private T value;
private LinkNode<T> parentNode;
private LinkNode<T> leftNode;
private LinkNode<T> rightNode;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
public LinkNode<T> getParentNode() {
return parentNode;
}
public void setParentNode(LinkNode<T> parentNode) {
this.parentNode = parentNode;
}
public LinkNode<T> getLeftNode() {
return leftNode;
}
public void setLeftNode(LinkNode<T> leftNode) {
this.leftNode = leftNode;
}
public LinkNode<T> getRightNode() {
return rightNode;
}
public void setRightNode(LinkNode<T> rightNode) {
this.rightNode = rightNode;
}
public LinkNode<Character> genFullTree(int deep) {
if (deep < 1) {
return null;
}
LinkNode<Character> linkNode = new LinkNode<>();
int value = 1;
linkNode.setValue(numFormatChar(value));
setChildrenNode(linkNode, deep - 1, value);
return linkNode;
}
private void setChildrenNode(LinkNode<Character> linkNode, int deep, int parValue) {
if (deep < 1) return;
LinkNode<Character> leftNode = new LinkNode<>();
linkNode.setLeftNode(leftNode);
int leftChildrenValue = 2 * parValue;
leftNode.setValue(numFormatChar(leftChildrenValue));
setChildrenNode(leftNode, deep - 1, leftChildrenValue);
leftNode.setParentNode(linkNode);
LinkNode<Character> rightNode = new LinkNode<>();
linkNode.setRightNode(rightNode);
rightNode.setValue(numFormatChar(leftChildrenValue + 1));
setChildrenNode(rightNode, deep - 1, leftChildrenValue + 1);
rightNode.setParentNode(linkNode);
}
public char numFormatChar(int value) {
int aNum = 'A';
int zNum = 'Z';
char result = (char) ((value - 1) % (zNum - aNum + 1) + aNum);
return result;
}
public void traverseLinkNode(LinkNode linkNode) {
if (linkNode == null) return;
LinkNode firstRootNode = traverseChild(linkNode, null);
traverseParent(linkNode, linkNode.getParentNode(), firstRootNode);
}
public LinkNode traverseChild(LinkNode linkNode, LinkNode firstRootNode) {
if (linkNode == null) return null;
if(firstRootNode == null && linkNode.getValue().toString().equals("A")){
firstRootNode = linkNode;
}
System.out.println(linkNode.getValue());
traverseChild(linkNode.getLeftNode(), firstRootNode);
traverseChild(linkNode.getRightNode(), firstRootNode);
return firstRootNode;
}
public void traverseParent(LinkNode preLinkNode, LinkNode linkNode, LinkNode firstRootNode) {
if (linkNode == null) return;
if(linkNode.getValue().toString().equals("A")){
if(firstRootNode == null){
firstRootNode = linkNode;
}else if(firstRootNode == linkNode){
return;
}
}
System.out.println(linkNode.getValue());
if (preLinkNode == linkNode.getLeftNode()) {
traverseChild(linkNode.getRightNode(), firstRootNode);
} else if (preLinkNode == linkNode.getRightNode()) {
traverseChild(linkNode.getLeftNode(), firstRootNode);
} else {
traverseChild(linkNode.getRightNode(), firstRootNode);
traverseChild(linkNode.getLeftNode(), firstRootNode);
}
traverseParent(linkNode, linkNode.getParentNode(), firstRootNode);
}
public static void main(String[] args) {
LinkNode linkNode = new LinkNode<Character>();
LinkNode root1 = linkNode.genFullTree(4);
LinkNode root2 = linkNode.genFullTree(4);
LinkNode root3 = linkNode.genFullTree(4);
root1.setParentNode(root2);
root2.setParentNode(root3);
root3.setParentNode(root1);
linkNode.traverseLinkNode(root2.getLeftNode().getRightNode());
}
}