算法题整理（持续更新）

1.一个按升序排列好的数组int[] arry = {-5,-1,0,5,9,11,13,15,22,35,46},输入一个x，int x = 31，在数据中找出和为x的两个数，例如 9 + 22 = 31，要求算法的时间复杂度为O(n);

分析：该题不难，主要关注点应该为要求时间复杂度为O(n),因为数组是按升序排列，所以可以定义两个指针i、j，分别从数组的两端开始遍历，如果a[i]+a[j]大于31，则应该让尾指针j前移，如果a[i]+a[j]小于31，则应该让头指针i后移，直到找到a[i]+a[j]等于31，或遍历完成
示例代码如下:

public class Find {

    public static void main(String[] args) {

        int[] arr = {-5, -1, 0, 5, 9, 11, 13, 15, 22, 35, 46};
        int sum = 31;
        find(arr, sum);
    }

    private static void find(int[] arr, int sum) {

        if (arr.length <= 1) {
            System.out.println("arr wrong");
            return;
        }

        int i = 0;
        int j = arr.length - 1;

        while (i != j) {
            n++;
            int tmpSum = arr[i] + arr[j];

            if (tmpSum == sum) {
                System.out.println("a[" + i + "] = " + arr[i] + ", a[" + j + "] = " + arr[j]);
                return;
            }

            if (tmpSum < sum) {
                i++;
            }

            if (tmpSum > sum) {
                j--;
            }

        }

        System.out.println("not found");

    }


}

2.广度优先打印数，即横向打印树

如下图，横向打印下面的数：

利用队列queue先进先出的特点，首先将第一个节点8加入队列，然后循环遍历队列，拿出最先加进去的节点p并输入，接着判断p.left和p.right，不为空继续加入队列，简要代码如下：

void printTreeFromTopToBottom(TreeNode node) {

        if (node == null)
            return;

        queue.offer(node);

        while (queue.size() > 0) {
            TreeNode first = queue.poll();

            System.out.println(first.num);

            if (first.left != null) {
                queue.offer(first.left);
            }
            if (first.right != null) {
                queue.offer(first.right);
            }
        }

}

3.查找二叉树的深度
思路：运用递归的思想，找出左子树或右子树哪个深，然后把深度+1，示意代码如下：

int findDepth(TreeNode root) {

        if (root == null)
            return 0;

        int leftDepth = findDepth(root.left);
        int rightDepth = findDepth(root.right);

        return leftDepth > rightDepth ? (leftDepth + 1) : (rightDepth + 1);

    }

扩展：
思考三叉树问题

4.反转链表

思路1：

利用一个栈，将要翻转的链表按与按顺序压进栈，再出栈重新链接，设置next

思路2：

利用三个指针来完成，分别指向当前遍历到的节点，它的前一个节点和它的后一个节点
直到遍历到它的next等于null的时候，即遍历完成，代码如下