面试的比较少，但是碰到两次都要求手写算法，写出来以后面试官喜笑颜开，一直点头说不错不错。没写出来就是，‘我们的时间好像面的差不多了，你还有什么想问的吗’。。。。

所以说，一些简单的算法还是需要眼到手到，能够闭着眼睛快速写出来。
整理下常见的很简单，但是面试常常会提笔忘字的算法吧

算法书第一页的算法：二分查找

相信这个基本没啥说的，可能你碰上那种很久不碰代码，专注于业务的面试官会让你写一写
闭着眼睛写出来

public static int rank(int k, int[] a){
    int lo = 0;
    int hi = a.length-i;
    while(lo < hi){
        int mid = lo + (hi-lo)/2;
        if(k < a[mid]){
            hi = mid -1;
        }else if(k > a[mid]){
            lo = mid +1;
        }else{
            return mid;
        }
    }
    return -1;
}

单链表的反转

我们定义一个指向前一个节点的指针，和一个指向自己的指针，然后进行反转移动

public Node reverseNode(Node head){
    if(head == null || head.next == null){
        return head;
    }
    Node preNode = null;
    Node curNode = head;
    Node nextNode = null;
    while(curNode != null){
        nextNode = curNode.next;//翻转
        curNode.next = preNode;
        preNode = curNode;//指针向后移动
        curNode = nextNode;
    }
return 
}

对称的二叉树

这个也是常考的一个算法
可以采用两种思路进行解决，一个是递归一个是层级遍历
采用递归的方法解决，递归的思路非常清晰

boolean isSymmetrical(TreeNode pRoot) {
        if(pRoot == null){
            return true;
        }
       return isSame(pRoot.left, pRoot.right);
    }
     
    boolean isSame(TreeNode left, TreeNode right){
        if(left == null && right == null){
            return true;
        }else if(left == null || right == null){
            return false;
        }
        if(left.val == right.val){
            return isSame(left.left, right.right)
                && isSame(left.right, right.left);
        }
        return false;
    }

有些面试官不喜欢递归，我们可以采用层级遍历的方法
层级遍历，我们可以牢记这个公式

while queue 不空：
    cur = queue.pop();
    for 节点 in cur的所有相邻节点：
        if 该节点有效且未被访问过
            标记访问
            queue.push(该节点)

实现

public class TreeNodeSymmeterial {

    boolean isSymmetrical(TreeNode pRoot) {
         if(pRoot == null){
            return true;
         }
        Queue<TreeNode>  queue = new LinkedList<>();
        queue.add(pRoot);
        while (!queue.isEmpty()){
            List<Integer> list = new ArrayList<>();
            int size = queue.size();
            while(size-- > 0){
                TreeNode cur = queue.poll();
                if(cur != null && cur.val != 0x7fffffff){
                    queue.add(cur.left != null ? cur.left : new TreeNode(0x7fffffff));// 空节点我们可以设置一个最大值
                    queue.add(cur.right != null ? cur.right : new TreeNode(0x7fffffff));
                }
                list.add(cur.val);
            }
            if(!check(list)) return false;
        }
        return true;
    }
    public boolean check(List<Integer> list){
        int lo = 0;
        int hi = list.size()-1;
        while (lo < hi){
            if(!list.get(lo++).equals(list.get(hi--))) {
                return false;
            }
        }
        return true;
    }
}

持续更新中