牛客网之网易2016实习研发工程师编程题

[编程题] 比较重量
小明陪小红去看钻石，他们从一堆钻石中随机抽取两颗并比较她们的重量。这些钻石的重量各不相同。在他们们比较了一段时间后，它们看中了两颗钻石g1和g2。现在请你根据之前比较的信息判断这两颗钻石的哪颗更重。
给定两颗钻石的编号g1,g2，编号从1开始，同时给定关系数组vector,其中元素为一些二元组，第一个元素为一次比较中较重的钻石的编号，第二个元素为较轻的钻石的编号。最后给定之前的比较次数n。请返回这两颗钻石的关系，若g1更重返回1，g2更重返回-1，无法判断返回0。输入数据保证合法，不会有矛盾情况出现。
测试样例：
2,3,[[1,2],[2,4],[1,3],[4,3]],4
返回: 1

思路：根据g1编号，去找相关的二元组，找直接比它关系大的放集合（max）里，和找比它关系小的放集合（min）里，然后找二元组中间接比它关系大的元素放集合max里，间接比它关系小的元素放集合min里，最后看g2是在集合max里，还是集合min里。

import java.util.*;

public class Cmp {
    public int cmp(int g1, int g2, int[][] records, int n) {
        // write code here
         HashSet<Integer> max = new HashSet<>();   
        HashSet<Integer> min = new HashSet<>();   
        for (int i = 0; i < n; i++) {   
            if (records[i][0] == g1) {   
                min.add(records[i][1]);   
            }   
            if (records[i][1] == g1) {   
                max.add(records[i][0]);   
            }   
        }   

        for (int i = 0; i < n; i++) {   
            if (records[i][0] != g1 && records[i][1] != g1) {   
                if (max.contains(records[i][1])) {   
                    max.add(records[i][0]);   
                }   
                if (min.contains(records[i][0])) {   
                    min.add(records[i][1]);   
                }   
            }   
        }   

        if (max.contains(g2) && !min.contains(g2)) {   
            return -1;   
        } else if (!max.contains(g2) && min.contains(g2)) {   
            return 1;   
        } else   
            return 0;   
    }  
    }
}

[编程题] 二叉树
有一棵二叉树，树上每个点标有权值，权值各不相同，请设计一个算法算出权值最大的叶节点到权值最小的叶节点的距离。二叉树每条边的距离为1，一个节点经过多少条边到达另一个节点为这两个节点之间的距离。
给定二叉树的根节点root，请返回所求距离。

import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class Tree {
    public int getDis(TreeNode root) {
        // write code here
    }
}

贴上我的代码供大家参考。

package WangYi2016;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

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

public class Tree {

    public int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;

    public int getDis(TreeNode root) {
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        helper(root, map);
        // showMap(map);
        System.out.println("min:" + min + ",max:" + max);
        // root.left=null;
        List<Integer> path1 = getPath(min, map, new ArrayList<Integer>());
        List<Integer> path2 = getPath(max, map, new ArrayList<Integer>());

        int len1 = path1.size();
        int len2 = path2.size();
        int result = 0;
        for (int i = len1 - 1, j = len2 - 1; i >= 0 && j >= 0; i--, j--) {
            //一直找到最近的相等的子节点，两边一加就是最短距离
            if (path1.get(i) == path2.get(j)) {
                result = i + j;
            }
        }
        return result;

    }

    private List<Integer> getPath(int i, Map<Integer, Integer> map,
            List<Integer> list) {
        while (map.containsKey(i)) {
            list.add(i);
            i = map.get(i);
        }
        list.add(i);
        return list;
    }

    /**
    * 递归的先序遍历算法
    **/
    public void helper(TreeNode root, HashMap<Integer, Integer> map) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null) {
            int val = root.val;
            min = val < min ? val : min;
            max = val > max ? val : max;
        }
        if (root.left != null) {
            //因为权值互不相同，所以弄成map就可以连起来
            map.put(root.left.val, root.val);
            helper(root.left, map);
        }
        if (root.right != null) {
            map.put(root.right.val, root.val);
            helper(root.right, map);
        }
    }

    public static void main(String[] args) {
        Tree tree = new Tree();  
        TreeNode root = new TreeNode(5);  
        TreeNode left = new TreeNode(4);  
        TreeNode right = new TreeNode(6);  
        root.left = left;  
        root.right = right;  
        TreeNode r2 = new TreeNode(8);  
        right.right = r2;  
        Map<TreeNode, TreeNode> map=new HashMap<TreeNode, TreeNode>();  

        System.out.println(tree.getDis(root));
    }
}

[编程题] 寻找第K大
有一个整数数组，请你根据快速排序的思路，找出数组中第K大的数。
给定一个整数数组a,同时给定它的大小n和要找的K(K在1到n之间)，请返回第K大的数，保证答案存在。
测试样例：
[1,3,5,2,2],5,3
返回：2

import java.util.*;

public class Finder {
    public int findKth(int[] a, int n, int K) {
        // write code here
        Arrays.sort(a);
        return a[n-k];
    }
}

用这种自带的sort肯定是代码简便，但是我觉得大家还是要自己会手写排序算法。

就随手写了一个选择排序

public void selfSort(int[] a) {
        int k,temp;
        for (int i = 0; i < a.length; i++) {
            k = i;
            for (int j = i + 1; j < a.length; j++)
                if (a[j] < a[k])
                    k = j;
            //swap(a[i],a[k]); //这里突然想到Java没有指针
            temp = a[i];
            a[i] = a[k];
            a[k] = temp;
        }
    }

上面的提到的swap我就测试了一下，想着用对象引用当参数，可是还是不行。

        Integer m = new Integer(2);
        Integer n = new Integer(3);
        new Finder().swap(m, n);
        System.out.println("---" + m + "---" + n);

输出结果还是—2—3