网易、美团2018技术招聘编程题--java实现

美团点评2018实习生研发工程师编程题

寻找二叉树两个节点的最低公共祖先(LCA)

public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;

public TreeNode(int val) {
this.val = val;
}
}

如果是一个二分查找树

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null || q == null || p == null)
return null;
// 如果root.val 比左右子树大，说明在root的左子树
if (root.val > Math.max(q.val, p.val))
return lowestCommonAncestor(root.left, p, q);
// 如果root.val 比左右子树小，说明在root的右子树
if (root.val < Math.min(q.val, p.val))
return lowestCommonAncestor(root.right, p, q);
return root;

如果是一个普通的二叉树

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null || q == null || p == null)
return null;
// 注意：如果 一个节点是另一个祖先，则返回的是祖先节点
if (q == root || p == root)
return root;
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p, q);
// 如果都返回非空指针, 则说明两个节点分别出现了在两个子树中
// 则当前节点肯定为LCA
if (left != null && right != null)
return root;
// 如果一个为空，在说明LCA在另一个子树
return (left == null) ? right : left;
}

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null || q == null || p == null)
return null;
List<TreeNode> listP = new ArrayList<>();
boolean isFindPathToP = findPathFromRoot(root, listP, p);
List<TreeNode> listQ = new ArrayList<>();
boolean isFindPathToQ = findPathFromRoot(root, listQ, q);
if (isFindPathToP && isFindPathToQ) {
TreeNode ans = null;
for (int i = 0; i < Math.min(listP.size(), listQ.size()); i++) {
if (listP.get(i) != listQ.get(i))
continue;
ans = listP.get(i);
}
return ans;
}
return null;
}

private boolean findPathFromRoot(TreeNode root, List<TreeNode> list, TreeNode node) {
if (root == null)
return false;
list.add(root);
// 注意不是root.val==node.val！！！！
if (root == node)
return true;
//左子树或右子树 是否找到,找到的话当前节点就在路径中了
boolean find = findPathFromRoot(root.left, list, node) || findPathFromRoot(root.right, list, node);
if (find)
return true;
// 该节点下未找到就弹出,并返回false
list.remove(list.size() - 1);
return false;
}

计算超大数的阶乘

import java.util.Arrays;
public class BigInteger {
/**
* 计算进位
*
* @param bit
*            数组
* @param pos
*            用于判断是否是数组的最高位
*/
private void carry(int[] bit, int pos) {
int i, carray = 0;
for (i = 0; i <= pos; i++)// 从0到pos逐位检查是否需要进位
{
bit[i] += carray;// 累加进位
if (bit[i] <= 9) // 小于9不进位
{
carray = 0;
} else if (bit[i] > 9 && i < pos)// 大于9，但不是最高位
{
carray = bit[i] / 10;// 保存进位值
bit[i] = bit[i] % 10;// 得到该位的一位数
} else if (bit[i] > 9 && i >= pos)// 大于9，且是最高位
{
while (bit[i] > 9)// 循环向前进位
{
carray = bit[i] / 10;// 计算进位值
bit[i] = bit[i] % 10;// 当前的第一位数
i++;
bit[i] = carray;// 在下一位保存进位值
}
}
}
}
/**
* 大整数阶乘
*
* @param bigInteger
*            所计算的大整数
*/
private void bigFactorial(int bigInteger) {
int pos = 0;//
int digit;// 数据长度
int a, b;
int m = 0;// 统计输出位数
int n = 0;// 统计输出行数
double sum = 0;// 阶乘位数
for (a = 1; a <= bigInteger; a++)// 计算阶乘位数
{
sum += Math.log10(a);
}
digit = (int) sum + 1;// 数据长度

int[] fact = new int[digit];// 初始化一个数组
fact[0] = 1;// 设个位为 1，也是1 的阶乘

for (a = 2; a <= bigInteger; a++)// 将2~bigInteger逐个与原来的积相乘
{
for (b = digit - 1; b >= 0; b--)// 查找最高位{}
{
// fact[0]存储的是个位
if (fact != 0) {
pos = b;// 记录最高位
break;
}
}

for (b = 0; b <= pos; b++) {
fact[b] *= a;// 每一位与a乘,不明白可以想像一下小学乘法公式
}
carry(fact, pos);
}
for (b = digit - 1; b >= 0; b--) {
if (fact[b] != 0) {
pos = b;// 记录最高位
break;
}
}
System.out.println(bigInteger + "阶乘结果为：");
for (a = pos; a >= 0; a--)// 输出计算结果
{
System.out.print(fact[a]);
m++;
if (m % 5 == 0) {
System.out.print(" ");
}
if (40 == m) {
System.out.println("");
m = 0;
n++;
if (10 == n) {
System.out.print("\n");
n = 0;
}
}
}
System.out.println("\n" + "阶乘共有: " + (pos + 1) + " 位");

}

public void doBigFactorial(int bigInteger) {
int timeBegin = (int) System.currentTimeMillis();
this.bigFactorial(bigInteger);
int timeFinishi = (int) System.currentTimeMillis();
int time = timeFinishi - timeBegin;
System.out.println("计算耗时: " + time + "毫秒");
}

public static void main(String[] args) {
BigInteger bi = new BigInteger();
bi.doBigFactorial(10);
}
}

//使用这个集合构建一个有向图，比如 [1,2]表示成一条边1->2,同时，
//弧尾表示较大的一个数；
//然后，我们在这个图中寻找2,3之间有没有通路，
//注意这里，因为是有向图，路径可能为2到3，或者3到2，或者不存在。

//采用邻接矩阵+传递性实现
public int cmp(int g1, int g2, int[][] records, int n) {
{
int maxNum = Integer.MIN_VALUE;
// 使用最大值构造一个map
for (int i = 0; i < n; i++) {
maxNum = Math.max(maxNum, records[i][0]);
maxNum = Math.max(maxNum, records[i][1]);
}
// 构造有向图，map存储从1 开始(map[i][0]或者map[0][j])不存储，所以maxNum+1;
int[][] map = new int[maxNum + 1][maxNum + 1];
// 初始化对角线为1，其他为0
for (int i = 1; i <= maxNum; i++) {
for (int j = 1; j <= maxNum; j++) {
if (i == j)
map[i][j] = 1;
else
map[i][j] = 0;
}
}
// 把二维数组中出现的存储为1，如果map从0开始，此处计算需要与1做运算
for (int i = 0; i < n; i++) {
map[records[i][0]][records[i][1]] = 1;
}
// 传递性，如果(i,k),(k,j)为1，那么(i,j)设为1
for (int k = 1; k <= maxNum; k++) {
for (int i = 1; i <= maxNum; i++) {
for (int j = 1; j <= maxNum; j++) {
if (map[i][k] == 1 && map[k][j] == 1) {
map[i][j] = 1;
}
}
}
}
// 如果map值为1 ，则g1大
if (map[g1][g2] == 1)
return 1;
else if (map[g2][g1] == 1)
return -1;
else
return 0;
}
}

public int cmp(int g1, int g2, int[][] records, int n) {
{
int maxNum = Integer.MIN_VALUE;
// 使用最大值构造一个map
for (int i = 0; i < n; i++) {
maxNum = Math.max(maxNum, records[i][0]);
maxNum = Math.max(maxNum, records[i][1]);
}
// 构造有向图，map存储从1 开始(map[i][0]或者map[0][j])不存储，所以maxNum+1;
boolean[][] map = new boolean[maxNum + 1][maxNum + 1];

// 把二维数组中出现的存储为1，如果map从0开始，此处计算需要与1做运算
for (int i = 0; i < n; i++) {
map[records[i][0]][records[i][1]] = true;
}
// 构造结点是否访问的集合
boolean[] isVisited = new boolean[maxNum + 1];
if (dfs(isVisited, g1, g2, map))
return 1;
if (dfs(isVisited, g2, g1, map))
return -1;
return 0;
}
}

// 采用深度优先遍历
private boolean dfs(boolean[] isVisited, int g1, int g2, boolean[][] map) {
if (map[g1][g2])
return true;
for (int i = 1; i < isVisited.length; i++) {
if (map[g1][i] && !isVisited[i]) {
isVisited[i] = true;
// 继续遍历以i为开始结点的深度遍历
if (dfs(isVisited, i, g2, map))
return true;
}
}
return false;
}

public boolean isRechable = false;

public static void main(String[] args) {
int re[][] = { { 1, 2 }, { 2, 4 }, { 1, 3 }, { 4, 3 } };
System.out.println(new Cmp().cmp(3, 2, re, 4));
}

public int cmp(int g1, int g2, int[][] records, int n) {
// 产生一个邻接表，map+list
Map<Integer, List<Integer>> map = new HashMap<>();
for (int i = 0; i < n; i++) {
int key = records[i][0];
int value = records[i][1];
if (map.containsKey(key)) {
map.get(key).add(value);
} else {
List<Integer> list = new ArrayList<>();
list.add(value);
map.put(key, list);
}

}
if (map.isEmpty()) {
return 0;
}
DFS(map, g1, g2);
if (isRechable)
return 1;
DFS(map, g2, g1);
if (isRechable)
return -1;
return 0;
}

// 深度优先遍历
private void DFS(Map<Integer, List<Integer>> map, int g1, int g2) {
if (!map.containsKey(g1))
isRechable = false;
// 获取key为g1的value
else {
List<Integer> values = map.get(g1);
for (Integer value : values) {
if (value == g2) {
isRechable = true;
return;
} else
DFS(map, value, g2);
}
}
}

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int n = scanner.nextInt();
int[] item = new int
;
for (int i = 0; i < n; i++) {
item[i] = scanner.nextInt();
}
System.out.println(leastTimeToHuiwen(n, item));
}
}
public static int leastTimeToHuiwen(int n, int[] item) {
// 比较第一个和最后一个数，如果第一个大，则前两个相加替换原来位置。
// 如果最后一个数大，则最后两个相加替换原来位置。
// 如果首尾元素相等，则删除首尾元素。
int count = 0;
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < n; i++) {
list.add(item[i]);
}
while (list.size() > 1) {
if (list.get(0) < list.get(list.size() - 1)) {
int a = list.get(0);
int b = list.get(1);
list.set(0, a + b);
list.remove(1);
count++;
} else if (list.get(0) > list.get(list.size() - 1)) {
int a = list.get(list.size() - 1);
int b = list.get(list.size() - 2);
list.set(list.size() - 2, a + b);
list.remove(list.size() - 1);
count++;
} else {
list.remove(0);
list.remove(list.size() - 1);
}
}
return count;
}
}

private static int leastTimeToHuiwen(int n, int[] item) {
int start = 0;
int end = n - 1;
int count = 0;
while (start < end) {
if (item[start] < item[end]) {
// 头指针位置的值小于尾，头指针+1，并将新指针的值加上旧指针的值
item[start + 1] = item[start] + item[start + 1];
start++;
count++;
} else if (item[start] > item[end]) {
// 尾指针位置的值小于头，尾指针-1，并将新指针的值加上旧指针的值
item[end - 1] = item[end] + item[end - 1];
end--;
count++;
} else {
// 相等，两边都往中间移动
start++;
end--;
}
}
return count;
}

第一行一个数T(T ≤ 100)，表示数据组数。对于每组数据，第一行两个数n,k(1 ≤ n,k ≤ 100)，
接下来一行有2n个数a1,a2,...,a2n(1 ≤ ai ≤ 1000000000)。表示原始牌组从上到下的序列。

对于每组数据，输出一行，最终的序列。数字之间用空格隔开，不要在行末输出多余的空格。

3
3 1
1 2 3 4 5 6
3 2
1 2 3 4 5 6
2 2
1 1 1 1

1 4 2 5 3 6
1 5 4 3 2 6
1 1 1 1

import java.util.*;

public class Main {
// 表示左手边的牌    
private Stack<Integer> left = new Stack<Integer>();
// 表示右手边的牌
private Stack<Integer> right = new Stack<Integer>();
public static void main(String[] args) {
Main mm = new Main();
Scanner sc = new Scanner(System.in);
// 每次洗牌后的结果
List<Integer> tempRes = new ArrayList<Integer>();
// 存储所有组数的结果
List<String> result = new ArrayList<String>();
int m = sc.nextInt();
int n = 0, k = 0;
while (m != 0) {
n = sc.nextInt();
k = sc.nextInt();
for (int i = 0; i < 2 * n; i++) {
tempRes.add(sc.nextInt());
}
while (k != 0) {// k次洗牌
mm.pokeSort(tempRes);
k--;
} // 存储每组结果
result.add(tempRes.toString().replace("[", "").replace("]", "").replace(",", ""));
m--;

tempRes.clear();
}
for (String str : result)// 打印结果
System.out.println(str);
}

private void pokeSort(List<Integer> tempRes) {

for (int i = 0; i < tempRes.size() / 2; i++)
left.push(tempRes.get(i));
for (int i = tempRes.size() / 2; i < tempRes.size(); i++)
right.push(tempRes.get(i));
// 注意清空
tempRes.clear();
while (!left.isEmpty()) {
tempRes.add(right.pop());
tempRes.add(left.pop());
}
Collections.reverse(tempRes);
}
}

构造队列

小明同学把1到n这n个数字按照一定的顺序放入了一个队列Q中。现在他对队列Q执行了如下程序：
while(!Q.empty())              //队列不空，执行循环
{
int x=Q.front();            //取出当前队头的值x
Q.pop();                 //弹出当前队头
Q.push(x);               //把x放入队尾
x = Q.front();              //取出这时候队头的值
printf("%d\n",x);          //输出x
Q.pop();                 //弹出这时候的队头

}
做取出队头的值操作的时候，并不弹出当前队头。
小明同学发现，这段程序恰好按顺序输出了1,2,3,...,n。现在小明想让你构造出原始的队列，你能做到吗？[注：原题样例第三行5有错，应该为3，以下已修正]
输入描述:
第一行一个整数T（T ≤ 100）表示数据组数，每组数据输入一个数n（1 ≤ n ≤ 100000），输入的所有n之和不超过200000。
输出描述:
对于每组数据，输出一行，表示原始的队列。数字之间用一个空格隔开，不要在行末输出多余的空格.
输入例子:
4
1
2
3
10
输出例子:
1
2 1
2 1 3
8 1 6 2 10 3 7 4 9 5

import java.util.*;

public class Main{
public static void main(String[] args) {
//第一种方法，模拟相反操作
solution1();
//第二种方法
solution2();
}

public static void solution1() {
//双端队列
Deque<Integer> q = new LinkedList<>();
Scanner sc = new Scanner(System.in);
int k = sc.nextInt();
while (k-- > 0) {
int n = sc.nextInt();
for (int i = n; i > 0; i--) {
q.offerFirst(i);
int t = q.peekLast();
q.pollLast();
q.offerFirst(t);
}

for (int i = 1; i < n; i++)
System.out.print(q.pollFirst() + " ");
System.out.println(q.pollFirst());
}
}
/* *  思想：先使用一个1到n的数组模拟小明的操作， 
* * 然后会得到一组输出，例如：3,5,10,7.... 
* * 按题意是应该输出   1,2,3,4.... 
* * 这样，我们就可以反推出 
* * 1应该在第3个位置 
* * 2应该在第5个位置 
* * 3应该在第10个位置 
* * 4应该在第7个位置 * .... 
 */
public static void solution2() {
Queue<Integer> q = new LinkedList<>();
Scanner sc = new Scanner(System.in);
int k = sc.nextInt();
while (k-- > 0) {
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
q.offer(i);
}
int cnt = 1;
int num[] = new int[n + 1];
while (!q.isEmpty()) {
int x = q.peek();
q.poll();
q.offer(x);
num[q.peek()] = cnt++;
q.poll();
}
for (int i = 1; i < n; i++)
System.out.print(num[i] + " ");
System.out.println(num
);
}
}
}