斑马网络面试题整理

1、二叉树的遍历算法？

二叉树遍历有先序遍历（根左右）、中序遍历（左根右）、后序遍历（左右根）的代码实现。

package algorithm.Tree;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BinaryTreeIterator {
    static class TreeNode {
        int data;
        TreeNode leftNode;
        TreeNode rightNode;

        public TreeNode(int data, TreeNode leftNode, TreeNode rightNode) {
            this.data = data;
            this.leftNode = leftNode;
            this.rightNode = rightNode;
        }

        public TreeNode(int data) {
            this.data = data;
        }

        public int getData() {
            return data;
        }

        public void setData(int data) {
            this.data = data;
        }

        public TreeNode getLeftNode() {
            return leftNode;
        }

        public void setLeftNode(TreeNode leftNode) {
            this.leftNode = leftNode;
        }

        public TreeNode getRightNode() {
            return rightNode;
        }

        public void setRightNode(TreeNode rightNode) {
            this.rightNode = rightNode;
        }
    }

    //先序遍历——递归方法
    public static void preOrder(TreeNode root) {
        if (root != null) {
            System.out.print(root.data + "\t");
            preOrder(root.leftNode);
            preOrder(root.rightNode);
        }
    }

    //先序遍历——非递归方法
    public static void preOrderNonRecursive(TreeNode root) {
        //栈——先入后出
        Stack<TreeNode> stack = new Stack<>();
        while (true) {
            while (root != null) {
                System.out.print(root.data + "\t");
                stack.push(root);
                root = root.getLeftNode();
            }
            if (stack.isEmpty()) break;
            root = stack.pop();
            root = root.getRightNode();
        }
    }

    //中序遍历
    public static void inOrder(TreeNode root) {
        if (root != null) {
            inOrder(root.leftNode);
            System.out.print(root.data + "\t");
            inOrder(root.rightNode);
        }
    }

    //后序遍历
    public static void postOrder(TreeNode root) {
        if (root != null) {
            inOrder(root.leftNode);
            inOrder(root.rightNode);
            System.out.print(root.data + "\t");
        }
    }

    //中序遍历——非递归方法
    public static void inOrderNonRecursive(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        while (true) {
            while (root != null) {
                stack.push(root);
                root = root.getLeftNode();
            }
            if (stack.isEmpty()) break;
            root = stack.pop();
            System.out.print(root.data + "\t");
            root = root.getRightNode();
        }
    }

    //层序遍历（逐层打印）：层序遍历用到了队列，而先、中、后序需要用到栈。
    public static void levelOrder(TreeNode root) {
        TreeNode temp;
        Queue<TreeNode> queue = new LinkedList<>();
        //offer方法和add方法都是往队列尾部插入元素，但当超出队列界限时，offer方法返回false，add方法抛异常
        queue.offer(root);
        while (!queue.isEmpty()) {
            temp = queue.poll();
            System.out.print(temp.data + "\t");
            if (temp.getLeftNode() != null) {
                queue.offer(temp.getLeftNode());
            }
            if (temp.getRightNode() != null) {
                queue.offer(temp.getRightNode());
            }
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(57);
        root.leftNode = new TreeNode(48);
        root.leftNode.leftNode = new TreeNode(34);
        root.leftNode.rightNode = new TreeNode(49);
        root.rightNode = new TreeNode(77);
        //先序遍历
        System.out.println("先序遍历：");
        preOrder(root);
        System.out.println();
        //先序遍历——非递归
        preOrderNonRecursive(root);
        System.out.println();
        //层序遍历
        System.out.println("层序遍历：");
        levelOrder(root);
        System.out.println();
        //后序遍历
        System.out.println("后序遍历：");
        postOrder(root);
        System.out.println();
    }
}

2、链表的查询算法？

链表的经典算法题链接：链表算法经典十题总结 - 辰砂tj - 博客园

3、限流算法？令牌桶的不足？

在大型电商等系统中,我们回努力提升API的吞吐量和QPS(Query Per Second 每秒查询量)，但总归有上限.为了应对巨大流量的瞬间提交，我们会做对应的限流处理。常见的限流算法有：计数器，漏桶，令牌桶。

• 计数器算法：一次访问设置一次计数，在系统内设置每秒的访问量，超过访问量的访问直接丢弃。弊端是在开始的时间，访问量被使用完后，1S内会有长时间的真空期是处于接口不可用的状态的。
• 漏斗算法：大批量访问进入时，漏斗有容量，不超过容量(容量的设计=固定处理的访问量*可接受等待时长)的数据都可以排队等待处理，超过的才会丢弃。缺点无法应对短时间的突发流量。
• 令牌桶算法：按照一定的速率生成令牌放入令牌桶,访问要进入系统时,需要从令牌桶获取令牌,有令牌的可以进入,没有的被抛弃。由于令牌桶的令牌是源源不断生成的,当访问量小时,可以留存令牌达到令牌桶的上限,这样当短时间的突发访问量来时,积累的令牌数可以处理这个问题。当访问量持续大量流入时,由于生成令牌的速率是固定的,最后也就变成了类似漏斗算法的固定流量处理。

令牌桶的实现类似于漏斗，使用一个队列保存令牌，一个定时任务用等速率生成令牌放入队列，访问量进入系统时，从队列获取令牌再进入系统。

4、微博限定用户输入140字符，如果用户输入一个很长的字符串链接，怎么办？

把长链转成短链，当时我们通知租客填写管家的反馈单的短信里用的就是短链。网上有很多开源的方案，如百度短链生成服务百度短网址，新浪短链服务http://dwz.wailian.work。

短链和原始链接的对应关系我们可以通过 Redis 或者 MySQL 进行存储，短链和长链是一对一还是多对一这个需要根据具体的业务来确定。短链一般7位足够。

重定向有 301 和 302，301 和 302 的区别是 301 表示永久重定向，302 表示暂时性转移。一般都是采用302暂时性转移，设置一定的过期时间。

短链生成算法：1、Hash 摘要算法；2、自增 ID（分布式 ID）

Hash 摘要算法的实现方式是首先将长链进行 Hash 运算得到一个 64 位的整数，再将这个整数转换为 62 进制，取低 7 位即可。Hash 算法虽然简单，但是容易冲突，如果说在大量生成短链的时候会增加冲突，还需要想办法解决冲突的问题。

自增 ID 方式不会出现冲突的情况，而且如果是采用的关系型数据库存储，那本身就会自动生成 ID，只需要进行 62 位进制转换就可以了。采用这种方案我们需要注意几个问题，第一个是如果是分布式环境下可能需要分布式 ID 生成器，就不能简单的用一台数据库去生成 ID 了，另外一个是需要加一个缓存，针对同一个长链我们不需要多次生成短链（特殊情况除外），这样就可以防止同一个长链被生成了多个短链，如果不小心被攻击了，就会导致短时间 ID 申请过多的问题。
当时有个自增式ID通过雪花算法SnowFlake，雪花算法生成的ID一共64bit（41bit时间戳+10bit工作机器id+12bit序列号——序列号用来记录毫秒内产生的不同id），利用雪花算法生成17位的工单编号信息，但是到达某个时间点后17位变成18位导致数据库字段超长插入失败，后扩大字段长度。

比如生成一个long类型的数字id（long型有符号，第一位0为正数，1为负数）