车主邦的三道笔试题

1. 将⼀组忽略⼤王⼩王的扑克牌，从⼩到⼤排序，请尽量选择时间复杂度低的⽅案（忽略花⾊，2最 ⼤，A⽐K⼤，2⽐A⼤） 输⼊: 第⼀⾏是给出牌的数量，第⼆⾏为牌的值 7 J Q Q A K 3 2 输出: 3 J Q Q K A 2

2. 层次遍历输出⼆叉树：给定⼀个整数⼆叉树，要求从上往下输出每层的元素值。

3. 给定⼀个整数数组，要求输出⼀个同样⼤⼩的数组，输出的数组每个元素是给定数组除同样位置元 素外其他元素的乘积，不许⽤除法 输⼊: 第⼀⾏是给定数组的元素个数，第⼆⾏为数组元素的值 5 1 2 3 4 5 编程题 输出: 120 60 40 30 24

编程题

1. 排序算法中时间复杂度较好，为O(N*logN) 的三种排序为快速排序，归并排序和堆排序，由于题中给扑克牌排序不需要算法具有稳定性，且快速排序常数项较低，所以选用随机快速排序。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;

public class PokeSort {

    public static void main(String[] args) throws IOException {
        // 初始化用于确定牌大小的 map, map2
        // map(牌，权值) map2(权值，牌)
        HashMap<String, Integer> map = new HashMap<>();
        for (int i=3; i<=10; i++) {
            map.put(i+"", i);
        }
        map.put("J", 11);
        map.put("Q", 12);
        map.put("K", 13);
        map.put("A", 14);
        map.put("2", 15);
        HashMap<Integer, String> map2 = new HashMap<>();
        for (String str : map.keySet()) {
            map2.put(map.get(str), str);
        }
        // 处理输入
        BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(b.readLine());
        int[] arr = new int[n];
        String[] strs = b.readLine().trim().split(" ");
        for(int i= 0; i < n;i++){
            arr[i] = map.get(strs[i]);
        }
        b.close();
        // 随机快速排序
        quickSort(arr, 0, arr.length-1);
        for (int i : arr){
            System.out.print(map2.get(i) + " ");
        }
    }

    public static void quickSort(int[] arr, int L, int R) {
        if(L < R) {
            // 随机一个换到数组最后做划分值
            swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
            int[] p = partition(arr, L, R);
            // 将小于区的范围用于递归，p[0] - 1 为小于区最后一个位置
            quickSort(arr, L, p[0] - 1);
            // 将大于区的范围用于递归，p[1] + 1 为大于区开始的个位置
            quickSort(arr, p[1] + 1, R);
        }
    }

    public static int[] partition(int[] arr, int L, int R) {
        int less = L - 1;	// 小于区右边界
        int more = R;		// 大于区左边界
        while (L < more){
            // L 表示当前考虑的数的下标
            if (arr[L] < arr[R]) {
                swap(arr, ++less, L++);		// 把当前数换到小于区的右边，小于区右扩，L++
            } else if (arr[L] > arr[R]) {
                swap(arr, --more, L);		// 把当前数换到大于区的左边，大于区左扩，L 不变
            } else {
                L++;
            }
        }
        swap(arr, more, R);
        return new int[] { less + 1, more }; // 返回的是等于区域的那一段
    }

    public static void swap(int[] arr, int m, int n){
        int temp = arr[n];
        arr[n] = arr[m];
        arr[m] = temp;
    }
}

2. 使用队列实现二叉树的层次遍历

import java.util.LinkedList;
import java.util.Queue;

public class PrintByLevel {

    public static class TreeNode{
        public int val;
        public TreeNode left;
        public TreeNode right;
        public TreeNode(int data) {
            this.val = data;
        }
    }

    public static void printByLevel(TreeNode head) {
        if (head == null) return;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(head);
        TreeNode node;
        while (!queue.isEmpty()) {
            node = queue.poll();
            System.out.print(node.val + " ");
            if (node.left != null){
                queue.offer(node.left);
            }
            if (node.right != null){
                queue.offer(node.right);
            }
        }
    }

    public static void main(String[] args) {
        TreeNode head = new TreeNode(3);
        head.left = new TreeNode(9);
        head.right = new TreeNode(20);
        head.right.left = new TreeNode(15);
        head.right.right = new TreeNode(7);
        head.right.left.left = new TreeNode(4);
        head.right.left.right = new TreeNode(8);
        printByLevel(head);
    }
}

3. 从左往右遍历一次先求出每个元素左侧的所有元素乘积保存在结果数组中，再从右往左遍历一次动态求右侧乘积，乘到结果数组上。两次遍历，时间复杂度O(N)，不占用额外空间，空间复杂度O(1)。

public class Main {

    public static void main(String[] args) throws IOException {
        // 处理输入
        BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(b.readLine());
        int[] arr = new int[n];
        String[] strs = b.readLine().trim().split(" ");
        for(int i= 0; i < n;i++){
            arr[i] = Integer.parseInt(strs[i]);
        }
        b.close();
        process(arr);
    }

    public static void process(int[] arr) {
        int[] result = new int[arr.length];
        result[0] = 1;
        for (int i=1; i<arr.length; i++) {
            result[i] = result[i-1] * arr[i-1];
        }
        int rightProduct = 1;
        for (int i=arr.length-1; i>=0; i--){
            result[i] = result[i] * rightProduct;
            rightProduct *= arr[i];
        }
        for(int num : result){
            System.out.print(num + " ");
        }
    }

}

车主邦的这套题难度并不大，除了三道编程外还有一些选择题。每道题我都写上了自己的解题思路，可是过了这些天依然没有回复 : (

不管怎样，摆正心态继续努力吧~