JAVA面试算法小记

今天去参加了一个公司的java后台面试，被问了几道算法题，感觉还是挺基础的，决定记下来，以后还能看看。

首先是一道很简单的矩阵变换：把一个矩阵按照对角线翻转使得matrix[i][j] = matrix[j][i].

public static int[][] changeMatrix(int [][]matrix) {
    Assert.assert(matrix != null && matrix[0] != null);
    int m = matrix.length;
    int n = matrix[0].length;
    for(int i=0; i<m; ++i) {
        for(int j=i+1; j<n; ++j) {
            swapMatrixEle(matrix, i, j);
        }
    }
    return matrix;
}

public static void swapMatrixEle(int[][] matrix, int i, int j) {
    if(i==j) return;
    matrix[i][j] ^= matrix[j][i];
    matrix[j][i] ^= matrix[i][j];
    matrix[i][j] ^= matrix[j][i];
}

然后让我手写一个排序，刚好前两天看到了一个快排，赶紧写下来，刚开始还有点记不清了，尼玛差点憋出汗，还好记得一个思路，慢慢写出来了，暗爽~~ 由于紧张居然先用js写了一个版本，现在想想，真佩服我自己/(ㄒoㄒ)/~~ 思路理清之后才改成了java版本。。。。

//为了突出java基础，我故意用了泛型
class Sort<T extends Comparable<T>> {

    public T[] quickSort(T[] arr, int start, int end) {
        if (start < end) {
            int index = adjust(arr, start, end);
            quickSort(arr, 0, index-1);
            quickSort(arr, index+1, end);
        }
        return arr;
    }

    private int adjust(T[] arr, int start, int end) {
        while (start < end) {
            while (start < end && arr[start].compareTo(arr[end]) < 0) { --end; }
            swap(arr, start, end);
            while (start < end && arr[start].compareTo(arr[end]) < 0) { ++start; }
            swap(arr, start, end);
        }
        return end;
    }

    private void swap(T[] arr, int i, int j) {
        T t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}

最后一个题感觉是故意挖了一个坑：一共有n级台阶，可以一次走一步，也可以一次走两步，现在问走完n级台阶共有多少种方案？
这个题呢，递推一下，就是一个简单的递归：

1. n = 1, f = 1;
   
2. n = 2, f = 2;
   
3. n > 2, f = f(n-1) + f(n-2);

刚开始的时候，写出来的版本是这样的：

public static int steps(int n) {
    if(n==1) return 1;
    else if(n==2) return 2;
    else {
        return steps(n-1)+steps(n-2);
    }
}

咋一看这挺清晰的，没什么问题，但是仔细分析一看却发现，本来step(n-1)就会先递归一次，当计算step(n-2)时还会重复递归一次，这完全没有必要，为什么不把递归的结果记录下来呢，所以我又改了一个版本。

class Steps {

    public static int[] log = new int[n]; // 这里为了简便，先这样写

    public static int steps(int n) {
        if(n==1) { log[0]=1;  return 1;}
        else if(n==2) { log[1]=2;  return 2;}
        else {
            if(log[n-2] == 0) {
                log[n-2] = steps(n-1);
            }
            if(log[n-2] == 0) {
                log[n-3] = steps(n-2);
            }
            return log[n-2]+log[n-3];
        }
    }

}

这样加一个日志就使得递归只进行一次，极大减少了系统消耗。

最后总算是写完啦，还好注意了一些坑，给面试官印象还不错，期待后续！

再想想，这上面都是很基础的题，但是面试时还是很紧张，说明自己基础掌握的不好，希望以后要抓紧了！！！