备考华为校招机试

1.基本计算器2（力扣227）

本题主要利用栈实现，难点在于要考虑输入的数字可能不止一位，要把代表一个数的所有数字获取后再放入栈中，因此用num先来接收每一位数字并且做一个累加，等到遇到操作符时再将本数字压栈。由于输入的都是正整数，默认第一个数字前的操作符为'+'。字符串遍历完成后累加栈中的所有元素。

public int calculate(String s) {
    Deque<Integer> deque = new ArrayDeque<>();
    char preSign = '+';
    int num = 0;
    int i = 0;
    while (i < s.length()){
        if(Character.isDigit(s.charAt(i))){
            //得到该数字
            num = num*10+s.charAt(i)-'0';
        }
        if (!Character.isDigit(s.charAt(i)) && s.charAt(i) != ' ' || i == s.length() - 1){
            switch (preSign){
                case '+':deque.push(num);
                break;
                case '-':deque.push(-num);
                break;
                case '*':deque.push(deque.pop()*num);
                break;
                default:deque.push(deque.pop()/num);
            }
            preSign = s.charAt(i);
            num = 0;
        }
        i++;
    }
    int res = 0;
    while (!deque.isEmpty()){
        res += deque.pop();
    }
    return res;
}

2.反转链表

本题记得设置两个指针，开始时pre为空，cur为head，每次记录cur的下一个为t，然后让pre = cur.next，然后pre和cur分别向后移动到cur和t的位置。

public ListNode reverseList(ListNode head) {
    ListNode pre = null;
    ListNode cur = head;
    while (cur!= null){
        ListNode t = cur.next;
        cur.next = pre;
        pre = cur;
        cur = t;
    }
    return pre;
}

3.合并两个排序的链表

注意设置一个头节点作为最后返回答案的需要。然后如果一个链表遍历完了，直接把另外一个链表追加到合并链表的尾部就好。

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode p = new ListNode();
        ListNode res = p;
        while (l1!= null && l2 != null){
            if (l1.val <= l2.val)
            {
                res.next = l1;
                l1 = l1.next;
            }
            else
            {
                res.next = l2;
                l2 = l2.next;
            }
            res = res.next;
        }
//        while (l1!=null){
//            res.next = l1;
//            l1 = l1.next;
//            res = res.next;
//        }
//      //直接追加
        if(l1!=null)
            res.next = l1;
        else
            res.next = l2;
        return p.next;
    }

4.数组中第k大的数字

本题主要练习优先级队列（堆）的使用，默认是小根堆，因此将数组内元素放进大小为k的小根堆内时，堆顶元素就是第k大的元素，因为堆中有k-1个比它大的元素。

    public int findKthLargest(int[] nums, int k) {
//        int res = 0;
//        Arrays.sort(nums);
//        for (int i = nums.length-1; i >= 0 ; i--) {
//            if(k == 1){
//                res = nums[i];
//                break;
//            }
//            else
//                k--;
//        }
//        return res;
        //使用小根堆，把堆的大小设为k，则堆顶元素就是第k大的元素，因为有k-1个比他大的元素
        PriorityQueue<Integer> heap = new PriorityQueue<>();
        for (int i = 0; i < k; i++) {
            heap.offer(nums[i]);
        }
        for (int i = k; i < nums.length; i++) {
            if(nums[i] > heap.peek()){
                heap.poll();
                heap.offer(nums[i]);
            }
        }
        return heap.peek();
    }

5.连续子数组最大和

贪心的方法每次记录最大和，当和小于零时从下一个位置重新开始计算。使用动态规划时dp[i]表示以 i 结尾的子数组的最大值。

    public int maxSubArray(int[] nums) {
//        //贪心
//        int count = 0;
//        int max = Integer.MIN_VALUE;
//        for (int i = 0; i < nums.length; i++) {
//            count += nums[i];
//            max = Math.max(max,count);
//            if(count<0)
//                count = 0;
//        }
//        return max;
//    }
        //DP
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if(dp[i-1] < 0)
                dp[i] = nums[i];
            else
                dp[i] = dp[i-1]+nums[i];
            max = Math.max(max,dp[i]);
        }
        return max;
    }

6.最小的k个数

本题如果直接Arrays.sort()就没啥意义了，练习优先级队列的使用，要找最小的k个数，采用大根堆，大小设为k，最后的答案就是对中所有的k个元素。

public int[] getLeastNumbers(int[] arr, int k) {
    if(k == 0 || arr.length == 0)
        return new int[0];
    //大根堆
    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2.compareTo(o1);
        }
    });
    for (int i = 0; i < k; i++) {
        priorityQueue.offer(arr[i]);
    }
    for (int i = k; i < arr.length; i++) {
        if(arr[i] < priorityQueue.peek())
        {
            priorityQueue.poll();
            priorityQueue.offer(arr[i]);
        }
    }
    int[] res = new int[k];
    for (int i = res.length-1; i >= 0; i--) {
        res[i] = priorityQueue.poll();
    }
    return res;
}

7.丑数（知识点拓展）

用小根堆实现，避免重复，加入堆前先加入set检查，每次进入堆的都是（2、3、5的倍数）。第n次从小根堆弹出来的就是第n小的丑数。

public int nthUglyNumber(int n) {
    int[] factor = new int[]{2,3,5};
    Set<Long> hashSet = new HashSet<>();
    PriorityQueue<Long> heap = new PriorityQueue<>();
    hashSet.add(1l);
    heap.offer(1l);
    int num = 0;
    for (int i = 0; i < n; i++) {
        long cur = heap.poll();
        num = (int) cur;
        for (int j = 0; j < factor.length; j++) {
            if(hashSet.add(cur*factor[j]))
                heap.offer(cur*factor[j]);
        }
    }
    return num;
}

8.有效的数独

public boolean isValidSudoku(char[][] board) {
    for (int i = 0; i < board.length; i++) {
        for (int j = 0; j < board[i].length; j++) {
            if(board[i][j] == '.' || isValid(board,i,j,board[i][j]))
                continue;
            else
                return false;
        }
    }
    return true;
}
public boolean isValid(char[][] board, int row, int col, char val){
    //判断所在行是否重复
    for (int i = 0; i < 9; i++) {
        if(board[row][i] == val && i!=col)
            return false;
    }
    //判断所在列是否重复
    for (int i = 0; i < 9; i++) {
        if(board[i][col] == val && i!=row)
            return false;
    }
    //判断所在九宫格是否重复
    int startRow = (row/3)*3;
    int startCol = (col/3)*3;
    for (int i = startRow; i < startRow+3; i++) {
        for (int j = startCol; j < startCol+3; j++) {
            if(board[i][j] == val && i!=row && j!=col)
                return false;
        }
    }
    return true;
}