前言
“实战面经”是本专栏的第二个部分，本篇博文是第十二篇博文，主要收集了面试中常考的手撸算法题，如有需要，可：
一、两个字符串的最长公共子序列（字符之间可以不连续）
以a = "helloworld"和b = "loop"为例：
1. 定义: dp[i][j]表示到a[i]和b[j]为止的最长公共子序列。
2. 递推方程:
① 当i = 0或j = 0时，dp[i][j] = 0;
② 当a[i] == b[j]时，dp[i][j] = dp[i - 1][j - 1] + 1;
③ 当a[i] != b[j]时，dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
3. 返回: 最后返回dp[a.length][b.length]就是所求的长度
4. 只求最长公共子序列长度的代码:
private static int solve(String a, String b, int[][] dp) {
for (int i = 1; i <= a.length(); i++) {
for (int j = 1; j <= b.length(); j++) {
if (a.charAt(i - 1) == b.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
}
}
}
return dp[a.length()][b.length()];
}
5. 求最长公共子序列的代码:
在dp数组中，找每个数字第一次出现时对应的a或者b的下标
private static String getSubsequence(String a, String b, int[][] dp, int count) {
int i = 1;
StringBuilder result = new StringBuilder();
for (int k = 1; k <= count; k++) {
flag:
for (;i <= a.length(); i++) {
for (int j = 1; j <= b.length(); j++) {
if (dp[i][j] == k) {
result.append(a.charAt(i - 1));
break flag;
}
}
}
}
return result.toString();
}
二、两个字符串的最长公共子串（字符之间必须连续）
1. 与子序列不同的是:
① 当a[i] != b[j]时，dp[i][j] = 0;
② 返回dp数组中最大的数。
2. 只求最长公共子串长度的代码:
private static int solve(String a, String b, int[][] dp) {
int result = 0;
for (int i = 1; i <= a.length(); i++) {
for (int j = 1; j <= b.length(); j++) {
if (a.charAt(i - 1) == b.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
dp[i][j] = 0;
}
result = dp[i][j] > result? dp[i][j]: result;
}
}
return result;
}
3. 求子串的代码:
在dp数组中，从最大的数开始，斜向左上找
private static String getSubstring(String a, String b, int[][] dp, int count){
for (int i = 1; i < a.length(); i++){
for (int j = 1; j < b.length(); j++){
if (dp[i][j] == count){
StringBuilder result = new StringBuilder();
while (i >= 0 && j >= 0 && dp[i][j] > 0){
result.insert(0, a.charAt(i - 1));
i--;
j--;
}
return result.toString();
}
}
}
return "";
}
三、用前序和中序序列重建二叉树
1. TreeNode定义
class TreeNode {
TreeNode left;
TreeNode right;
int value;
public TreeNode(int value) {
this.value = value;
}
}
2. 主方法
public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
if (pre == null || pre.length == 0) {
return null;
}
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < in.length; i++) {
map.put(in[i], i);
}
return traverse(pre, 0, pre.length - 1, in, 0, in.length - 1, map);
}
3. 递归构建树的方法
public TreeNode traverse(int[] pre, int preL, int preR, int[] in, int inL, int inR, HashMap<Integer, Integer> map) {
if (preL > preR)
return null;
TreeNode root = new TreeNode(pre[preL]);
int indexOfRoot = map.get(pre[preL]);
root.left = traverse(pre, preL + 1, preL + indexOfRoot - inL, in, inL, indexOfRoot - 1, map);
root.right = traverse(pre, preL + indexOfRoot - inL + 1, preR, in, indexOfRoot + 1, inR, map);
return root;
}
四、求一组字符的字典序全排列
private static void permutationList(char[] words) {
int fromIndex, endIndex, changeIndex;
Arrays.sort(words);
while (true) {
printList(words);
fromIndex = endIndex = words.length - 1;
while (fromIndex > 0 && words[fromIndex] < words[fromIndex - 1]) {
fromIndex--;
}
changeIndex = fromIndex;
if (fromIndex == 0) {
break;
}
// 向后查找最后一个大于words[fromIndex-1]的元素
while (changeIndex + 1 < words.length && words[changeIndex + 1] > words[fromIndex - 1]) {
++changeIndex;
}
// 交换两个值
swap(words, fromIndex - 1, changeIndex);
// 对后面的所有值进行反向处理
invertArray(words, fromIndex, endIndex);
}
}
private static void swap(char[] words, int i, int j) {
if (words[i] != words[j]) {
words[i] ^= words[j];
words[j] ^= words[i];
words[i] ^= words[j];
}
}
private static void invertArray(char[] words, int fromIndex, int endIndex) {
for (; fromIndex < endIndex; fromIndex++, endIndex--) {
swap(words, fromIndex, endIndex);
}
}
private static void printList(char[] words) {
if (words.length > 0) {
System.out.print(words[0]);
for (int i = 1; i < words.length; i++) {
System.out.print(" " + words[i]);
}
}
System.out.println("");
}
五、求一组数中前k小的数
1. 思路: 利用快速排序进行分片，需要修改原数组，时间复杂度为O(n)
2. 主方法
public ArrayList<Integer> getLeastKNumbers (int[] input, int k) {
ArrayList<Integer> result = new ArrayList<>();
if (input.length == 0 || k > input.length || k <= 0)
return result;
int start = 0, end = input.length - 1, index = getPartition(input, start, end);
while (index != (k - 1)) {
if (index > (k - 1)) {
end = index - 1;
index = getPartition(input, start, end);
} else {
start = index + 1;
index = getPartition(input, start, end);
}
}
for (int i = 0; i < k; i++)
result.add(input[i]);
return result;
}
3. 快速排序获取分片边界的方法
public int getPartition(int[] input, int start, int end) {
if (input.length == 0 || start > end)
return -1;
int temp = input[end], j = start - 1;
for (int i = start; i < end; i++) {
if (input[i] <= temp) {
j++;
if (i != j)
swap(input, i, j);
}
}
swap(input, j + 1, end);
return (j + 1);
}
4. 交换方法
public void swap(int[] input, int left, int right) {
int temp = input[left];
input[left] = input[right];
input[right] = temp;
}
后记
这几个是面试中常考的算法题，经常会被面试官要求线上或线下用纸手撸代码，需要数量掌握
1024
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
