面试场上默认必会的数据结构与算法

一、排序算法：

归并

class Solution{

	// 递归方法实现
	public static void mergeSort1(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		process(arr, 0, arr.length - 1);
	}

	// 请把arr[L..R]排有序（分而治之的思想）
	// l...r N
	// T(N) = 2 * T(N / 2) + O(N)
	// O(N * logN)
	public static void process(int[] arr, int L, int R) {
		if (L == R) { // base case
			return;
		}
		int mid = L + ((R - L) >> 1);
		process(arr, L, mid);
		process(arr, mid + 1, R);
		merge(arr, L, mid, R);
	}

	public static void merge(int[] arr, int L, int M, int R) {
		int[] help = new int[R - L + 1];
		int i = 0;
		int p1 = L;
		int p2 = M + 1;

		// 往里装的过程
		while (p1 <= M && p2 <= R) {
			help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
		}
		// 要么p1越界了，要么p2越界了
		while (p1 <= M) {
			help[i++] = arr[p1++];
		}
		while (p2 <= R) {
			help[i++] = arr[p2++];
		}

		// 往出倒的过程
		for (i = 0; i < help.length; i++) {
			arr[L + i] = help[i];
		}
	}

}

快排

class QuickSolution {
	// 快排递归版本
	public static void quickSort1(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		process(arr, 0, arr.length - 1);
	}

	public static void process(int[] arr, int L, int R) {
		if (L >= R) {
			return;
		}
		swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
		int[] equalArea = netherlandsFlag(arr, L, R);
		process(arr, L, equalArea[0] - 1);
		process(arr, equalArea[1] + 1, R);
	}

	// 荷兰国旗问题
	public static int[] netherlandsFlag(int[] arr, int L, int R) {
		// 越界
		if (L > R) return new int[] { -1, -1 };
		if (L == R) return new int[] { L, R };

		int less = L - 1;
		int more = R;
		int index = L;
		while (index < more) {
			if (arr[index] == arr[R]) {
				index++;
			} else if (arr[index] < arr[R]) {
				swap(arr, index++, ++less);
			} else {
				swap(arr, index, --more);
			}
		}
		swap(arr, more, R);
		return new int[] { less + 1, more };
	}
}

稳定性问题：

二、树

根据遍历结果恢复树，递归
二叉搜索树第k大
树的和为k的路径：回溯
层次遍历：借助queue来回倒
根据层次遍历和后序遍历恢复树
镜像树
树的深度：递归
是不是平衡二叉树：递归

三、链表

反转链表
链表环的入口
交叉链表的交点
复杂链表的复制
二叉搜索树变成双向链表

四、回溯算法

void backtracking(参数) {
    这里也可以控制层数，到哪一层开始收集结果
    if (终止条件) {
        存放结果;
        return;
    }

    在这里进行剪枝。
    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

走迷宫
游戏通关

五、递推算法

走台阶
断钢筋

六、背包问题

装最多的东西

七、贪心算法

覆盖问题
时间问题