阿里三轮面试，三道机试题

最近参加了某厂的三轮面试，每轮面试面试官均会发送链接，进行在线编程。
题目并不要求完整实现，只要写出大概过程，并阐述解题思路以及注意点即可。
在我极有限的面试经历中我，委实显得有趣。

第一轮:转换字符串为int

题目很简单，将给定的字符串转换成int。
拿到题目的时候我很错愕，这基本是校招生都会觉得简单的题目。
那么此题唯一需要考虑的就是corner case。

首先，确定在解析失败的情况下，返回特定数值还是抛出异常（最后约定返回-1）。
此外，需要考虑如下情况：

• 字符串有效性；
• 字符串正负符号；
• 字符串解析溢出。

    public int myAtoi(String str) {
        if (str == null || str.length() == 0) {
            return -1;
        }

        str = str.trim();
        if (str.length() == 0) {
            return -1;
        }

        int res = 0, len = str.length();
        boolean flag = false;
        if (str.charAt(0) == '+') {
            flag = true;
            if (len == 1) {
                return -1;
            }
        } else if (str.charAt(0) == '-') {
            if (len == 1) {
                return -1;
            }
        } else if (str.charAt(0) <= '9' && str.charAt(0) >= '0') {
            res = str.charAt(0) - '0';
        } else {
            return -1;
        }

        for (int i = 1; i < str.length(); i++) {
            if (str.charAt(i) >= '0' && str.charAt(i) <= '9') {
                if (res > Integer.MAX_VALUE / 10) {
                    return -1;
                }
                res = res * 10 + (str.charAt(i) - '0');
            } else {
                return -1;
            }
        }

        return (!flag) ? -1 * res : res;
    }

第二轮:高并发接口设计

关于此题，无法理解自己的理解是否正确.
我需要一个支持高并发的插入和获取接口，存放数据为链路监控的Trace数据.

关于Trace数据，可参考OpenTracing相关规范。

代码此处就不进行详细展示。
具体思路就是将数据统一存放至ConcurrentHashMap，插入和查询较为简单，Trace数据更新时需要注意加锁。
因为数据限定存放在内存中，那么最简单提高并发的方式就是入参进行哈希操作，存放在若干个ConcurrentHashMap中。

第三轮:矩阵乘法以及后续优化

题目比较简单，设计一个矩阵乘法以及相应的测试用例(概要描述即可)。

    public class Matrix {

        public int[][] plus(int[][] a, int[][] b) {
            // 校验
            if (a.length == 0 || a[0].length == 0 || b.length == 0 || b[0].length == 0) {
                throw new Exception("xx1");
            }
            if (a.length != b[0].length || a[0].length != b.length) {
                throw new Exception("xx2");
            }

            // 计算
            int c[][] = new int[a.length][b[0].length];

            int x, i, j;
            for (i = 0; i < a.length; i++) {
                for (j = 0; j < b[0].length; j++) {
                    int tmp = 0;
                    for (x = 0; x < b.length; x++) {
                        tmp += a[i][x] * b[x][j];
                        // 需要处理数据溢出
                    }
                    c[i][j] = tmp;
                }
            }

            return c;
        }
    }

    //test1: 传入空数据（数组为空）
    //test2：传入不规整数据（矩阵长度不一致）
    //test3：传入乘积累加后溢出的数据
    //test4: 传入矩阵维数为1的数据
    //test5: 传入较小维度矩阵
    //test6: 传入维度巨大矩阵

代码比较简单，但是在面试官的提示下，漏掉了1*m矩阵和m*1矩阵相乘的情况。
因为面试时间有限，就没有设计类存放矩阵数据，从而避免1*m矩阵和m*1矩阵相乘的特例。
追加问题：

（1） 上述代码，如何更改能够提升性能？

上述代码在排除双重循环的问题后，联想到b矩阵的数据是按列获取的。
这也意味着每轮获取b[i][j]的数据，都无法利用到cpu的缓存，因此可以将乘法进行优化，尽量按照行去读取数据。

（2）高维稀疏矩阵如何进行优化呢？

仅保留不为0的数据，此时需要设计数据结构，保存数据的三要素：行号，列号以及数值；
此外建立数组存放三元组数据，格式如下所示：

typedef struct NODE{    //定义稀疏矩阵结点
 int j;                 //列
 int data;              //值
} Node;

typedef struct MATRIX{  //定义稀疏矩阵（可以快速访问）
 int mu, nu, tu;        // mu为矩阵行数，nu为矩阵列数，tu为矩阵中非零元素的个数
 Node matrix[MAXSIZE+1];
 int rpos[MAXR+1];
} Matrix;

// 摘抄网上代码，当时只提出了想法

针对三元组表示的矩阵乘法，在网上有较多的示例，大家可自行查阅。

说实话，三次面试的机试题都很有趣，题目难度不大，但是面试官会层层递进的询问，不断发掘疏忽的细节。

PS:
如果您觉得我的文章对您有帮助，请关注我的微信公众号，谢谢!