朗致集团2024面试题（参考答案）

一朝入魔

已于 2024-09-02 18:01:26 修改

阅读量106

点赞数 1

文章标签： java 面试开发语言

于 2024-09-02 11:58:13 首次发布

本文链接：https://blog.csdn.net/qq_31816945/article/details/141815810

版权

友情提示：仅供参考；

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

    }

}