剑指offer

3.数组中重复的数字

第一种方法：修改原数组中元素的位置，时间复杂度：o(n)，空间复杂度：o(1)，这种方法可以找到所有的重复数字

public class Solution {
    // Parameters:
    //    numbers:     an array of integers
    //    length:      the length of array numbers
    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    public boolean duplicate(int[] numbers,int length,int[] duplication) {
        if (numbers == null || length <= 0) {
            return false;
        }
        for (int i = 0; i < length; i++) {
            if (numbers[i] < 0 || numbers[i] > length - 1) {
                return false;
            }
        }
        for (int i = 0; i < length; i++) {
            while (numbers[i] != i) {
                if (numbers[i] == numbers[numbers[i]]) {
                    duplication[0] = numbers[i];
                    return true;
                }
                int temp = numbers[i];
                numbers[i] = numbers[temp];
                numbers[temp] = temp;
            }
        }
        return false;
    }
}

第二种方法：不修改原数组中元素的位置，时间复杂度：o(nlogn)，空间复杂度：o(1)，这种方法只能找到其中一个重复数字

public class Solution {
    // Parameters:
    //    numbers:     an array of integers
    //    length:      the length of array numbers
    //    duplication: (Output) the duplicated number in the array number,length of duplication array is 1,so using duplication[0] = ? in implementation;
    //                  Here duplication like pointor in C/C++, duplication[0] equal *duplication in C/C++
    //    这里要特别注意~返回任意重复的一个，赋值duplication[0]
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    public boolean duplicate(int[] numbers,int length,int[] duplication) {
        if (numbers == null || length <= 0) {
            return false;
        }
        int num = getDuplication(numbers, length);
        if (num == -1) {
            return false;
        }
        duplication[0] = num;
        return true;
    }
    private int getDuplication(int[] numbers, int length) {
        int start = 1;
        int end = length - 1;
        while (start <= end) {
            int mid = start + (end - start) / 2;
            int count = countRange(numbers, length, start, mid);
            if (start == end) {
                if (count > 1) {
                    return start;
                }
                return -1;
            }
            if (count > mid - start + 1) {
                end = mid;
            } else {
                start = mid + 1;
            }
        }
        return -1;
    }
    private int countRange(int[] nums, int length, int start, int end) {
        int count = 0;
        for (int i = 0; i < length; i++) {
            if (nums[i] >= start && nums[i] <= end) {
                count++;
            }
        }
        return count;
    }
}

 

5. 替换空格

第一种方法：需要o(n)的额外空间

// time:o(n)
public class Solution {
    public String replaceSpace(StringBuffer str) {
        String oldStr = str.toString();
        char[] ch = oldStr.toCharArray();
        StringBuilder newStr = new StringBuilder();
        for (int i = 0; i < ch.length; i++) {
            if (ch[i] == ' ') {
                newStr.append("%20");
            } else {
                newStr.append(ch[i]);
            }
        }
        return newStr.toString();
    }
}

第二种方法：直接在原字符串中变化

// time:o(n)
public class Solution {
    public String replaceSpace(StringBuffer str) {
        int oldLen = str.length();
        int spaceNum = 0;
        for (int i = 0; i < oldLen; i++) {
            if (str.charAt(i) == ' ') {
                spaceNum++;
            }
        }
        int newLen = oldLen + spaceNum * 2;
        str.setLength(newLen);
        while (newLen != oldLen) {
            if (str.charAt(--oldLen) == ' ') {
                str.setCharAt(--newLen, '0');
                str.setCharAt(--newLen, '2');
                str.setCharAt(--newLen, '%');
            } else {
                str.setCharAt(--newLen, str.charAt(oldLen));
            }
        }
        return str.toString();
    }
}

6. 从尾到头打印链表 

第一种方法：简单

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> res = new ArrayList<>();
        while (listNode != null) {
            res.add(0, listNode.val);
            listNode = listNode.next;
        }
        return res;
    }
}

第二种方法：使用栈

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.*;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> res = new ArrayList<>();
        Stack<Integer> stack = new Stack<>();
        while (listNode != null) {
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        while (!stack.isEmpty()) {
            res.add(stack.pop());
        }
        return res;
    }
}

7. 重建二叉树

总结：

1. 前序遍历

   /**
    * Definition for a binary tree node.
    * public class TreeNode {
    *     int val;
    *     TreeNode left;
    *     TreeNode right;
    *     TreeNode(int x) { val = x; }
    * }
    */
   // non-recursion
   class Solution {
       public List<Integer> preorderTraversal(TreeNode root) {
           Stack<TreeNode> stack = new Stack<>();
           List<Integer> res = new ArrayList<>();
           if (root == null) {
               return res;
           }
           stack.push(root);
           while (!stack.isEmpty()) {
               TreeNode node = stack.pop();
               res.add(node.val);
               if (node.right != null) {
                   stack.push(node.right);
               }
               if (node.left != null) {
                   stack.push(node.left);
               }
           }
           return res;
       }
   }

   /**
    * Definition for a binary tree node.
    * public class TreeNode {
    *     int val;
    *     TreeNode left;
    *     TreeNode right;
    *     TreeNode(int x) { val = x; }
    * }
    */
   // Traverse
   class Solution {
       private List<Integer> res = new ArrayList<>();
       public List<Integer> preorderTraversal(TreeNode root) {
           if (root == null) {
               return res;
           }
           helper(root);
           return res;
       }
       private void helper(TreeNode node) {
           if (node == null) {
               return;
           }
           res.add(node.val);
           helper(node.left);
           helper(node.right);
       }
   }

   /**
    * Definition for a binary tree node.
    * public class TreeNode {
    *     int val;
    *     TreeNode left;
    *     TreeNode right;
    *     TreeNode(int x) { val = x; }
    * }
    */
   // Divide & Conquer
   class Solution {
       public List<Integer> preorderTraversal(TreeNode root) {
           List<Integer> res = new ArrayList<>();
           if (root == null) {
               return res;
           }
           List<Integer> left = preorderTraversal(root.left);
           List<Integer> right = preorderTraversal(root.right);
           res.add(root.val);
           res.addAll(left);
           res.addAll(right);
           return res;
       }
   }

2. 中序遍历

   /**
    * Definition for a binary tree node.
    * public class TreeNode {
    *     int val;
    *     TreeNode left;
    *     TreeNode right;
    *     TreeNode(int x) { val = x; }
    * }
    */
   // recursion
   class Solution {
       public List<Integer> inorderTraversal(TreeNode root) {
           List<Integer> res = new ArrayList<>();
           if (root == null) {
               return res;
           }
           List<Integer> left = inorderTraversal(root.left);
           List<Integer> right = inorderTraversal(root.right);
           res.addAll(left);
           res.add(root.val);
           res.addAll(right);
           return res;
       }
   }

   /**
    * Definition for a binary tree node.
    * public class TreeNode {
    *     int val;
    *     TreeNode left;
    *     TreeNode right;
    *     TreeNode(int x) { val = x; }
    * }
    */
   // Non-recursion
   class Solution {
       public List<Integer> inorderTraversal(TreeNode root) {
           Stack<TreeNode> stack = new Stack<>();
           List<Integer> res = new ArrayList<>();
           TreeNode cur = root;
           while (cur != null || !stack.isEmpty()) {
               while (cur != null) {
                   stack.add(cur);
                   cur = cur.left;
               }
               cur = stack.pop();
               res.add(cur.val);
               cur = cur.right;
           }
           return res;
       }
   }

3. 后序遍历

   /**
    * Definition for a binary tree node.
    * public class TreeNode {
    *     int val;
    *     TreeNode left;
    *     TreeNode right;
    *     TreeNode(int x) { val = x; }
    * }
    */
   class Solution {
       public List<Integer> postorderTraversal(TreeNode root) {
           List<Integer> res = new ArrayList<>();
           if (root == null) {
               return res;
           }
           List<Integer> left = postorderTraversal(root.left);
           List<Integer> right = postorderTraversal(root.right);
           res.addAll(left);
           res.addAll(right);
           res.add(root.val);
           return res;
       }
   }

   后序遍历的非递归确实没看懂

题目：

思路：在前序遍历结果中找开始节点与结束节点，不要忘记减去startIn，对于二叉树节点为奇数个时，则循环不可能导致最后相等，因此判断递归结束条件要按照答案给出的写

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        TreeNode root = construct(pre, 0, pre.length - 1, in, 0, in.length - 1);
        return root;
    }
    private TreeNode construct(int[] pre, int startPre, int endPre, int[] in, int startIn, int endIn) {
        if (startPre > endPre || startIn > endIn) {
            return null;
        }
        TreeNode root = new TreeNode(pre[startPre]);
        for (int i = startIn; i <= endIn; i++) {
            if (in[i] == pre[startPre]) {
                root.left = construct(pre, startPre + 1, startPre + i - startIn, in, startIn, i - 1);
                root.right = construct(pre, startPre + i - startIn + 1, endPre, in, i + 1, endIn);
            }
        }
        return root;
    }
}

9. 用两个栈实现队列

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        if (stack2.isEmpty()) {
            stack1ToStack2();
        }
        return stack2.pop();
    }
    private void stack1ToStack2() {
        while (!stack1.isEmpty()) {
            stack2.push(stack1.pop());
        }
    }
}

用两个队列实现一个栈，leetcode225

10. 斐波那契数列

public class Solution {
    public int Fibonacci(int n) {
        if (n == 0) {
            return 0;
        }
        int[] res = new int[3];
        res[0] = 1;
        res[1] = 1;
        for (int i = 2; i < n; i++) {
            res[i % 3] = res[(i - 1) % 3] + res[(i - 2) % 3];
        }
        return res[(n - 1) % 3];
    }
}

 跳台阶

public class Solution {
    public int JumpFloor(int target) {
        if (target <= 1) {
            return 1;
        }
        int[] res = new int[3];
        res[0] = 1;
        res[1] = 1;
        for (int i = 2; i <= target; i++) {
            res[i % 3] = res[(i - 1) % 3] + res[(i - 2) % 3];
        }
        return res[target % 3];
    }
}

变态跳台阶

public class Solution {
    public int JumpFloorII(int target) {
        if (target <= 1) {
            return 1;
        }
        int[] res = new int[3];
        res[0] = 1;
        res[1] = 1;
        for (int i = 2; i <= target; i++) {
            res[i % 3] = res[(i - 1) % 3] * 2;
        }
        return res[target % 3];
    }
}

 矩形覆盖

public class Solution {
    public int RectCover(int target) {
        if (target <= 0) {
            return 0;
        }
        int[] result = new int[3];
        result[0] = 1;
        result[1] = 1;
        for (int i = 2; i <= target; i++) {
            result[i % 3] = result[(i - 1) % 3] + result[(i - 2) % 3];
        }
        return result[target % 3];
    }
}

 

11. 旋转数组的最小数字

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if (array == null || array.length == 0) {
            return 0;
        }
        int start = 0;
        int end = array.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (array[mid] > array[end]) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (array[start] <= array[end]) {
            return array[start];
        } else {
            return array[end];
        }
    }
}

public class Solution {
    public int JumpFloorII(int target) {
        int result = 1;
        for (int i = 1; i < target; i++) {
            result *= 2;
        }
        return result;
    }
}

12. 矩阵中的路径

public class Solution {
    public boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
        if (matrix == null || matrix.length == 0) {
            return false;
        }
        int[] visited = new int[matrix.length];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (helper(matrix, rows, cols, str, i, j, 0, visited)) {
                    return true;
                }
            }
        }
        return false;
    }
    private boolean helper(char[] matrix, int rows, int cols, char[] str, int i, int j, int k, int[] visited) {
        int index = i * cols + j;
        if (i < 0 || i >= rows || j < 0 || j >= cols || matrix[index] != str[k] || visited[index] == 1) {
            return false;
        }
        if (k == str.length - 1) {
            return true;
        }
        visited[index] = 1;
        if (helper(matrix, rows, cols, str, i - 1, j, k + 1, visited) ||
           helper(matrix, rows, cols, str, i + 1, j, k + 1, visited) ||
           helper(matrix, rows, cols, str, i, j - 1, k + 1, visited) ||
           helper(matrix, rows, cols, str, i, j + 1, k + 1, visited)) {
            return true;
        }
        visited[index] = 0;
        return false;
    }
}

13. 机器人的运动范围

public class Solution {
    public int movingCount(int threshold, int rows, int cols) {
        if (threshold < 0 || rows < 0 || cols < 0) {
            return 0;
        }
        int[] visited = new int[rows * cols];
        int result = helper(threshold, rows, cols, 0, 0, visited);
        return result;
    }
    private int helper(int threshold, int rows, int cols, int row, int col, int[] visited) {
        int count = 0;
        if (check(threshold, rows, cols, row, col, visited)) {
            visited[row * cols + col] = 1;
            count = 1 + helper(threshold, rows, cols, row - 1, col, visited) +
                        helper(threshold, rows, cols, row + 1, col, visited) +
                        helper(threshold, rows, cols, row, col - 1, visited) +
                        helper(threshold, rows, cols, row, col + 1, visited);
        }
        return count;
    }
    private boolean check(int threshold, int rows, int cols, int row, int col, int[] visited) {
        if (row < 0 || row >= rows || col < 0 || col >= cols || visited[row * cols + col] == 1 ||
           getDigitSum(row) + getDigitSum(col) > threshold) {
            return false;
        }
        return true;
    }
    private int getDigitSum(int num) {
        int sum = 0;
        while (num != 0) {
            sum += num % 10;
            num /= 10;
        }
        return sum;
    }
}

14. 剪绳子 

第一种方法：动态规划；第二种方法：贪婪算法

public class Solution {
    public int maxProductAfterCutting(int length) {
        if (length < 2) {
            return 0;
        }
        if (length == 2) {
            return 1;
        }
        if (length == 3) {
            return 2;
        }
        int[] products = new int[length + 1];
        products[0] = 0;
        products[1] = 1;
        products[2] = 2;
        products[3] = 3;
        int max = 0;
        for (int i = 4; i <= length; i++) {
            max = 0;
            for (int j = 0; j <= i / 2; j++) {
                max = Math.max(max, products[j] * products[i - j]);
            }
            products[i] = max;
        }
        return products[length];
    }
}

public class Solution {
    public int maxProductAfterCutting(int length) {
    if (length < 2) {
            return 0;
        }
        if (length == 2) {
            return 1;
        }
        if (length == 3) {
            return 2;
        }
        int timesOf3 = length / 3;
        if (length - timesOf3 * 3 == 1) {
            timesOf3--;
        }
        int timesOf2 = (length - timesOf3 * 3) / 2;
        return Math.pow(3, timesOf3) + Math.pow(2, timesOf2);
    }
}

15. 二进制中1的个数

常规解法

public class Solution {
    public int NumberOf1(int n) {
        int count = 0;
        int flag = 1;
        while (flag != 0) {
            int num = flag & n;
            if (num != 0) {
                count++;
            }
            flag = flag << 1;
        }
        return count;
    }
}

通过减1与原本数字相与，可以得到1的个数

public class Solution {
    public int NumberOf1(int n) {
        int count = 0;
        while (n != 0) {
            n = n & (n - 1);
            count++;
        }
        return count;
    }
}

16. 数值的整数次方

注意：底数为0，指数为负数的情况要特殊考虑

public class Solution {
    public double Power(double base, int exponent) {
        if (base == 0.0 && exponent < 0) {
            return 0.0;
        }
        int absExponent = Math.abs(exponent);
        double res = getResult(base, absExponent);
        if (exponent < 0) {
            res = 1.0 / res;
        }
        return res;
    }
    private double getResult(double base, int exponent) {
        if (exponent == 0) {
            return 1;
        }
        if (exponent == 1) {
            return base;
        }
        double res = getResult(base, exponent >> 1);
        res *= res;
        // 为运算符代替了求余来判断奇数与偶数
        int num = exponent & 1;
        if (num == 1) {
            res *= base;
        }
        return res;
    }
}

18. 删除链表的节点

注意：删除节点时要判断节点是否为null

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        ListNode dummy = new ListNode(0);
        dummy.next = pHead;
        
        ListNode preNode = dummy;
        while (pHead != null && pHead.next != null) {
            if (pHead.val == pHead.next.val) {
                int val = pHead.val;
                while (pHead != null && pHead.val == val) {
                    pHead = pHead.next;
                }
                preNode.next = pHead;
            } else {
                preNode = pHead;
                pHead = pHead.next;
            }
        }
        return dummy.next;
        
    }
}

19. 正则表达式匹配

思路：

当模式中的第二个字符不是*时：

1. 如果字符串第一个字符和模式中的第一个字符相匹配，那么字符串和模式都后移一个字符，然后匹配剩余的

2. 如果字符串第一个字符与模式中的第一个字符不匹配，直接返回false

当模式中的第二个字符是*时：

如果字符串第一个字符与模式中的第一个字符不匹配，则模式后移两个字符，继续匹配；如果字符串第一个字符与模式中的第一个字符匹配，则有三种匹配方式：

1. 模式后移2个字符，相当于x*被忽略

2. 字符串后移1位，模式后移2个字符

3. 字符串后移1位，模式不变，继续匹配字符串下一位，因为*可以匹配多位

public class Solution {
    public boolean match(char[] str, char[] pattern) {
        if (str == null || pattern == null) {
            return false;
        }
        int strIndex = 0;
        int patternIndex = 0;
        return matchCore(str, strIndex, pattern, patternIndex);
    }
    private boolean matchCore(char[] str, int strIndex, char[] pattern, int patternIndex) {
        // 有效性检验，str到尾，pattern也同样到尾
        if (strIndex == str.length && patternIndex == pattern.length) {
            return true;
        }
        // pattern先到尾，匹配失败
        if (strIndex != str.length && patternIndex == pattern.length) {
            return false;
        }
        // 模式第二个是*，且字符串第一个与模式第一个匹配，分三种匹配模式；如不匹配，模式后移2位
        if (patternIndex + 1 < pattern.length && pattern[patternIndex + 1] == '*') {
            if ((strIndex != str.length && str[strIndex] == pattern[patternIndex]) || (strIndex != str.length && pattern[patternIndex] == '.')) {
                return matchCore(str, strIndex + 1, pattern, patternIndex) || // 匹配1个，在匹配str中的下一个
                    // 下面代码可以删除
                    matchCore(str, strIndex + 1, pattern, patternIndex + 2) || // 视为模式匹配1个字符
                    matchCore(str, strIndex, pattern, patternIndex + 2); // 模式后移两位，视为x*匹配0个字符
            } else {
                return matchCore(str, strIndex, pattern, patternIndex + 2);
            }
        }
        // 模式第二个不是*，且字符串第1个跟模式第1个匹配，则都后移1位，否则直接返回false
        if ((strIndex != str.length && str[strIndex] == pattern[patternIndex]) || (strIndex != str.length && pattern[patternIndex] == '.')) {
            return matchCore(str, strIndex + 1, pattern, patternIndex + 1);
        }
        return false;
    }
}

注意：

1. 对于模式的第二个字符是*的情况下，情况2可以被情况1和情况3包含。执行一次情况3，在执行一次情况1相当于情况2

20. 表示数值的字符串

可以分为A、B、C三部分，其中A与C需要判断其是否含有符号，然后其余部分都与B一样进行判断即可

public class Solution {
    private int strIndex = 0;
    public boolean isNumeric(char[] str) {
        if (str == null || str.length == 0) {
            return false;
        }
        boolean numeric = scanInteger(str);
        if (strIndex < str.length && str[strIndex] == '.') {
            strIndex++;
            numeric = scanUnsignedInteger(str) || numeric;
        }
        if (strIndex < str.length && (str[strIndex] == 'e' || str[strIndex] == 'E')) {
            strIndex++;
            numeric = numeric && scanInteger(str);
        }
        return numeric && strIndex >= str.length;
    }
    private boolean scanInteger(char[] str) {
        if (strIndex < str.length && (str[strIndex] == '+' || str[strIndex] == '-')) {
            strIndex++;
        }
        return scanUnsignedInteger(str);
    }
    private boolean scanUnsignedInteger(char[] str) {
        int before = strIndex;
        while (strIndex < str.length && str[strIndex] >= '0' && str[strIndex] <= '9') {
            strIndex++;
        }
        return strIndex > before;
    }
}

注意：

1. || 的判断，如果前面的为true，则后面的不会判断

21. 调整数字顺序使奇数位于偶数前面

不需要保证相对顺序

public class ReorderOddEven {
    private void helper(int[] array) {
        if (array == null || array.length == 0) {
            return;
        }
        int start = 0;
        int end = array.length - 1;
        while (start < end) {
            while (start < array.length && array[start] % 2 == 1) {
                start++;
            }
            while (end >= 0 && array[end] % 2 == 0) {
                end--;
            }
            if (start < end) {
                int temp = array[start];
                array[start] = array[end];
                array[end] = temp;
            }
        }
    }
}

需要保证相对顺序

public class Solution {
    public void reOrderArray(int [] array) {
        if (array == null || array.length == 0) {
            return;
        }
        int count = 0;
        for (int num : array) {
            if (num % 2 == 1) {
                count++;
            }
        }
        int[] newArray = new int[array.length];
        int start = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] % 2 == 1) {
                newArray[start++] = array[i];
            } else {
                newArray[count++] = array[i];
            }
        }
        for (int i = 0; i < array.length; i++) {
            array[i] = newArray[i];
        }
    }
}

public class Solution {
    public void reOrderArray(int [] array) {
        if (array == null || array.length == 0) {
            return;
        }
        int i = 0, j = 0;
        while (j < array.length) {
            while (i < array.length && array[i] % 2 == 1) {
                i++;
            }
            j = i + 1;
            while (j < array.length && array[j] % 2 == 0) {
                j++;
            }
            if (j < array.length) {
                int temp = array[j];
                for (int j2 = j - 1; j2 >= i; j2--) {
                    array[j2 + 1] = array[j2]; // 注意
                }
                array[i++] = temp;
            } else {
                break;
            }
        }
    }
}

22. 链表中倒数第k个节点

两根指针

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if (head == null || k == 0) {
            return null;
        }
        ListNode pHead = head;
        ListNode pBehind = head;
        int start = 0;
        while (start < k - 1) {
            if (pHead.next != null) {
                pHead = pHead.next;
                start++;
            } else {
                return null;
            }
        }
        while (pHead.next != null) {
            pHead = pHead.next;
            pBehind = pBehind.next;
        }
        return pBehind;
    }
}

23. 链表中环的入口节点

两根指针

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode EntryNodeOfLoop(ListNode pHead) {
        if (pHead == null || pHead.next == null) {
            return null;
        }
        ListNode slow = pHead;
        ListNode fast = pHead.next;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return null;
            }
            fast = fast.next.next;
            slow = slow.next;
        }
        while (pHead != slow.next) {
            pHead = pHead.next;
            slow = slow.next;
        }
        return pHead;
    }
}

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        // 确认该链表是否有环，并找到环内任意一个节点
        ListNode meetingNode = meetingNode(head);
        if (meetingNode == null) {
            return null;
        }
        ListNode node = meetingNode;
        int count = 1;
        // 确定环的节点个数
        while (node.next != meetingNode) {
            node = node.next;
            count++;
        }
        // 找到环的起始节点
        ListNode pHead = head;
        ListNode pBehind = head;
        for (int i = 0; i < count; i++) {
            pHead = pHead.next;
        }
        while (pHead != pBehind) {
            pHead = pHead.next;
            pBehind = pBehind.next;
        }
        return pHead;
    }
    private ListNode meetingNode(ListNode head) {
        if (head == null || head.next == null) {
            return null;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return null;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
}

24. 翻转链表

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        while (head != null) {
            ListNode next = head.next;
            head.next = prev;
            prev = head;
            head = next;
        }
        return prev;
    }
}

25. 合并两个排序的链表

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if (list1 == null) {
            return list2;
        }
        if (list2 == null) {
            return list1;
        }
        ListNode head = null;
        if (list1.val < list2.val) {
            head = list1;
            head.next = Merge(list1.next, list2);
        } else {
            head = list2;
            head.next = Merge(list1, list2.next);
        }
        return head;
    }
}

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        ListNode dummy = new ListNode(0);
        ListNode head = dummy;
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                head.next = list1;
                list1 = list1.next;
            } else {
                head.next = list2;
                list2 = list2.next;
            }
            head = head.next;
        }
        if (list1 != null) {
            head.next = list1;
        }
        if (list2 != null) {
            head.next = list2;
        }
        return dummy.next;
    }
}

26. 树的子结构

递归遍历树

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

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

    }

}
*/
public class Solution {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        boolean result = false;
        if (root1 != null && root2 != null) {
            if (root1.val == root2.val) {
                result = DoesTree1HaveTree2(root1, root2);
            }
            if (!result) {
                result = HasSubtree(root1.left, root2) || HasSubtree(root1.right, root2);
            }
        }
        return result;
    }
    private boolean DoesTree1HaveTree2(TreeNode root1, TreeNode root2) {
        if (root2 == null) {
            return true;
        }
        if (root1 == null) {
            return false;
        }
        if (root1.val != root2.val) {
            return false;
        }
        return DoesTree1HaveTree2(root1.left, root2.left) && DoesTree1HaveTree2(root1.right, root2.right);
    }
}

27. 二叉树的镜像

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

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

    }

}
*/
public class Solution {
    public void Mirror(TreeNode root) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null) {
            return;
        }
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        if (root.left != null) {
            Mirror(root.left);
        }
        if (root.right != null) {
            Mirror(root.right);
        }
    }
}

28. 对称的二叉树

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

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

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode pRoot) {
        if (pRoot == null) {
            return true;
        }
        return helper(pRoot.left, pRoot.right);
    }
    private boolean helper(TreeNode root1, TreeNode root2) {
        if (root1 == null && root2 == null) {
            return true;
        }
        if (root1 == null || root2 == null) {
            return false;
        }
        if (root1.val != root2.val) {
            return false;
        }
        return helper(root1.left, root2.right) && helper(root1.right, root2.left);
    }
}

29. 顺时针打印矩阵

方法一

import java.util.ArrayList;
public class Solution {
    ArrayList<Integer> result = new ArrayList<>();
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }
        int col = matrix[0].length;
        int row = matrix.length;
        int start = 0;
        while (start * 2 < col && start * 2 < row) {
            printMatrixInCircle(matrix, start);
            start++;
        }
        return result;
    }
    private void printMatrixInCircle(int[][] matrix, int start) {
        int endX = matrix.length - 1 - start;
        int endY = matrix[0].length - 1 - start;
        for (int i = start; i <= endY; i++) {
            result.add(matrix[start][i]);
        }
        if (start < endX) {
            for (int i = start + 1; i  <= endX; i++) {
                result.add(matrix[i][endY]);
            }
        }
        if (start < endX && start < endY) {
            for (int i = endY - 1; i >= start; i--) {
                result.add(matrix[endX][i]);
            }
        }
        if (start < endY && start < endX - 1) {
            for (int i = endX - 1; i > start; i--) {
                result.add(matrix[i][start]);
            }
        }
    }
}

方法二

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int[][] matrix) {
        ArrayList<Integer> res = new ArrayList<>();
        int row = matrix.length;
        int col = matrix[0].length;
        if (row == 0 || col == 0) {
            return res;
        }
        int left = 0, top = 0;
        int right = col - 1, bottom = row - 1;
        while (left <= right && top <= bottom) {
            for (int i = left; i <= right; i++) {
                res.add(matrix[top][i]);
            }
            for (int i = top + 1; i <= bottom; i++) {
                res.add(matrix[i][right]);
            }
            // 下面判断防止单行单列
            if (top != bottom) {
                for (int i = right - 1; i >= left; i--) {
                    res.add(matrix[bottom][i]);
                }
            }
            if (left != right) {
                for (int i = bottom - 1; i > top; i--) {
                    res.add(matrix[i][left]);
                }
            }
            left++;
            top++;
            right--;
            bottom--;
        }
        return res;
    }
}

30. 包含min函数的栈

也可以采用minStack与stack的size相同

import java.util.Stack;

public class Solution {

    Stack<Integer> stack = new Stack<>();
    Stack<Integer> minStack = new Stack<>();
    public void push(int node) {
        stack.push(node);
        if (minStack.isEmpty()) {
            minStack.push(node);
        } else {
            if (minStack.peek() >= node) {
                minStack.push(node);
            }
        }
    }
    
    public void pop() {
        if (stack.pop() == minStack.peek()) {
            minStack.pop();
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int min() {
        return minStack.peek();
    }
}

31. 栈的压入、弹出序列

import java.util.*;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if (pushA == null || pushA.length == 0) {
            return false;
        }
        Stack<Integer> stack = new Stack<>();
        int popIndex = 0;
        for (int i = 0; i < pushA.length; i++) {
            stack.push(pushA[i]);
            while (popIndex < popA.length && stack.peek() == popA[popIndex]) {
                stack.pop();
                popIndex++;
            }
        }
        return stack.isEmpty();
    }
}

32. 从上到下打印二叉树

1. 不分行从上到下打印二叉树

BFS，标配队列

import java.util.*;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                result.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return result;
    }
}

2. 分行从上到下打印二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                list.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(list);
        }
        return res;
    }
}

3. 之字行打印二叉树

第一种方法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        boolean isLeftToRight = true;
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            if (!isLeftToRight) {
                Collections.reverse(level);
            }
            isLeftToRight = !isLeftToRight;
            result.add(level);
        }
        return result;
    }
}

第二种方法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        helper(root, 0, res);
        return res;
    }
    private void helper(TreeNode root, int n, List<List<Integer>> res) {
        if (root != null) {
            if (n >= res.size()) {
                List<Integer> level = new ArrayList<>();
                res.add(level);
            }
            if (n % 2 == 0) {
                res.get(n).add(root.val);
            } else {
                res.get(n).add(0, root.val);
            }
            helper(root.left, n + 1, res);
            helper(root.right, n + 1, res);
        }
    }
}

33. 二叉搜索树的后序遍历序列

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if (sequence == null || sequence.length == 0) {
            return false;
        }
        return helper(sequence, 0, sequence.length - 1);
    }
    private boolean helper(int[] sequence, int start, int end) {
        // 递归的退出条件
        if (start >= end) {
            return true;
        }
        // 找出小于根节点的索引
        int i = end;
        while (i > start && sequence[i - 1] > sequence[end]) {
            i--;
        }
        // 验证左子树是否符合二叉搜索树的条件
        for (int j = start; j < i; j++) {
            if (sequence[j] > sequence[end]) {
                return false;
            }
        }
        // 递归验证左子树和右子树
        return helper(sequence, start, i - 1) && helper(sequence, i, end - 1);
    }
}

34. 二叉树中和为某一值的路径

import java.util.ArrayList;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        ArrayList<Integer> list = new ArrayList<>();
        list.add(root.val);
        DFShelper(root, root.val, target, list, result);
        return result;
    }
    private void DFShelper(TreeNode root, int curSum, int target, ArrayList<Integer> list, ArrayList<ArrayList<Integer>> result) {
        if (root.left == null && root.right == null) {
            if (curSum == target) {
                result.add(new ArrayList<>(list));
            }
        }
        if (root.left != null) {
            list.add(root.left.val);
            DFShelper(root.left, curSum + root.left.val, target, list, result);
            list.remove(list.size() - 1);
        }
        if (root.right != null) {
            list.add(root.right.val);
            DFShelper(root.right, curSum + root.right.val, target, list, result);
            list.remove(list.size() - 1);
        }
    }
}

注意：

1. 每次添加list到result里，记住用new

35. 复杂链表的复制

/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead) {
        if (pHead == null) {
            return pHead;
        }
        cloneNext(pHead);
        cloneRandom(pHead);
        return splitList(pHead);
    }
    private void cloneNext(RandomListNode pHead) {
        RandomListNode head = pHead;
        while (head != null) {
            RandomListNode cloneNode = new RandomListNode(head.label);
            cloneNode.next = head.next;
            head.next = cloneNode;
            head = cloneNode.next;
        }
    }
    private void cloneRandom(RandomListNode pHead) {
        RandomListNode head = pHead;
        while (head != null) {
            RandomListNode cloneNode = head.next;
            if (head.random != null) {
                cloneNode.random = head.random.next;
            }
            head = cloneNode.next;
        }
    }
    private RandomListNode splitList(RandomListNode pHead) {
        RandomListNode newNode = pHead.next;
        while (pHead != null) {
            RandomListNode cloneNode = pHead.next;
            pHead.next = cloneNode.next;
            pHead = pHead.next;
            if (cloneNode.next != null) {
                cloneNode.next = pHead.next;
            }
        }
        return newNode;
    }
}

import java.util.*;
/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead) {
        if (pHead == null) {
            return pHead;
        }
        Map<RandomListNode, RandomListNode> mapping = new HashMap<>();
        RandomListNode dummy = new RandomListNode(0);
        RandomListNode prev = dummy;
        RandomListNode newNode;
        while (pHead != null) {
            if (mapping.containsKey(pHead)) {
                newNode = mapping.get(pHead);
            } else {
                newNode = new RandomListNode(pHead.label);
                mapping.put(pHead, newNode);
            }
            prev.next = newNode;
            if (pHead.random != null) {
                if (mapping.containsKey(pHead.random)) {
                    newNode.random = mapping.get(pHead.random);
                } else {
                    newNode.random = new RandomListNode(pHead.random.label);
                    mapping.put(pHead.random, newNode.random);
                }
            }
            prev = prev.next;
            pHead = pHead.next;
        }
        return dummy.next;
    }
}

36. 二叉搜索树与双向链表

 方法一. 采用stack

import java.util.*;
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    public TreeNode Convert(TreeNode root) {
        if (root == null) {
            return root;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        TreeNode pre = null;
        boolean isFirst = true;
        while (p != null || !stack.isEmpty()) {
            while (p != null) {
                stack.push(p);
                p = p.left;
            }
            p = stack.pop();
            if (isFirst) {
                root = p;
                pre = p;
                isFirst = false;
            } else {
                pre.right = p;
                p.left = pre;
                pre = p;
            }
            p = p.right;
        }
        return root;
    }
}

方法二和三：

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

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

    }

}
*/
public class Solution {
    public TreeNode Convert(TreeNode root) {
        if (root == null || (root.left == null && root.right == null)) {
            return root;
        }
        TreeNode left = Convert(root.left);
        TreeNode p = left;
        while (p != null && p.right != null) {
            p = p.right;
        }
        if (left != null) {
            p.right = root;
            root.left = p;
        }
        TreeNode right = Convert(root.right);
        if (right != null) {
            root.right = right;
            right.left = root;
        }
        return left != null ? left : root;
    }
}

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

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

    }

}
*/
public class Solution {
    TreeNode leftLast = null;
    public TreeNode Convert(TreeNode root) {
        if (root == null) {
            return root;
        }
        if (root.left == null && root.right == null) {
            leftLast = root;
            return root;
        }
        TreeNode left = Convert(root.left);
        if (left != null) {
            leftLast.right = root;
            root.left = leftLast;
        }
        leftLast = root; // 当根节点只含左子树时，则该根节点为最后一个节点
        TreeNode right = Convert(root.right);
        if (right != null) {
            root.right = right;
            right.left = root;
        }
        return left != null ? left : root;
    }
}

注意：

1. 第三种方法的leftLast = root;  // 当根节点只含左子树时，则该根节点为最后一个节点

37. 序列化二叉树

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

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

    }

}
*/
public class Solution {
    int index = -1;
    String Serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        if (root == null) {
            sb.append("#,");
            return sb.toString();
        }
        sb.append(root.val + ",");
        sb.append(Serialize(root.left));
        sb.append(Serialize(root.right));
        return sb.toString();
  }
    TreeNode Deserialize(String str) {
        index++;
        String[] strr = str.split(",");
        TreeNode node = null;
        if (!strr[index].equals("#")) {
            node = new TreeNode(Integer.valueOf(strr[index]));
            node.left = Deserialize(str);
            node.right = Deserialize(str);
        }
        return node;
        
  }
}

38. 字符串的排列

import java.util.*;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> result = new ArrayList<>();
        if (str == null || str.length() == 0) {
            return result;
        }
        StringBuilder sb = new StringBuilder();
        char[] strs = str.toCharArray();
        Arrays.sort(strs);
        int[] visited = new int[str.length()];
        dfsHelper(strs, visited, sb, result);
        return result;
    }
    private void dfsHelper(char[] str, int[] visited, StringBuilder sb, ArrayList<String> result) {
        if (str.length == sb.length()) {
            result.add(new String(sb.toString()));
        }
        for (int i = 0; i < str.length; i++) {
            if (visited[i] == 1 || (i != 0 && str[i] == str[i - 1] && visited[i - 1] == 0)) {
                continue;
            }
            sb.append(str[i]);
            visited[i] = 1;
            dfsHelper(str, visited, sb, result);
            sb.deleteCharAt(sb.length() - 1);
            visited[i] = 0;
        }
    }
}

下面这种方法很巧妙，通过swap方法实现

import java.util.*;
public class Solution {
    public ArrayList<String> Permutation(String str) {
        ArrayList<String> result = new ArrayList<>();
        if (str == null || str.length() == 0) {
            return result;
        }
        dfsHelper(str.toCharArray(), 0, result);
        Collections.sort(result);
        return result;
    }
    private void dfsHelper(char[] str, int index, ArrayList<String> result) {
        if (index == str.length - 1) {
            String val = String.valueOf(str);
            if (!result.contains(val)) {
                result.add(val);
            }
        }
        for (int i = index; i < str.length; i++) {
            swap(str, i, index);
            dfsHelper(str, index + 1, result);
            swap(str, i, index);
        }
    }
    private void swap(char[] str, int i, int j) {
        if (i != j) {
            char temp = str[i];
            str[i] = str[j];
            str[j] = temp;
        }
    }
}

39. 数组中出现次数超过一半的数字

投票算法

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if (array == null || array.length == 0) {
            return 0;
        }
        int target = array[0];
        int count = 1;
        for (int i = 1; i < array.length; i++) {
            if (count == 0) {
                target = array[i];
                count++;
            } else if (array[i] == target) {
                count++;
            } else {
                count--;
            }
        }
        count = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] == target) {
                count++;
            }
        }
        return count > array.length / 2 ? target : 0;
    }
}

40. 最小的k个数

方法一：采用最大堆

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> result = new ArrayList<>();
        if (input == null || input.length == 0 || input.length < k) {
            return result;
        }
        Queue<Integer> maxHeap = new PriorityQueue<>(input.length, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        for (int num : input) {
            maxHeap.offer(num);
            if (maxHeap.size() > k) {
                maxHeap.poll();
            }
        }
        for (int num : maxHeap) {
            result.add(num);
        }
        return result;
    }
}

方法二：采用最小堆

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> result = new ArrayList<>();
        if (input == null || input.length == 0 || input.length < k) {
            return result;
        }
        Queue<Integer> minHeap = new PriorityQueue<>();
        for (int num : input) {
            minHeap.offer(num);
        }
        for (int i = 0; i < k; i++) {
            result.add(minHeap.poll());
        }
        return result;
    }
}

41. 数据流中的中位数

import java.util.*;
public class Solution {
    Queue<Integer> minHeap = new PriorityQueue<>();
    Queue<Integer> maxHeap = new PriorityQueue<>(new Comparator<Integer>() {
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });
    int count = 0;

    public void Insert(Integer num) {
        if (count % 2 == 0) {
            if (maxHeap.size() != 0 && num < maxHeap.peek()) {
                maxHeap.offer(num);
                minHeap.offer(maxHeap.poll());
            } else {
                minHeap.offer(num);
            }
        } else {
            if (minHeap.size() != 0 && num > minHeap.peek()) {
                minHeap.offer(num);
                maxHeap.offer(minHeap.poll());
            } else {
                maxHeap.offer(num);
            }
        }
        count++;
    }

    public Double GetMedian() {
        if (count % 2 == 0) {
            return new Double((minHeap.peek() + maxHeap.peek()) / 2.0);
        } else {
            return new Double(minHeap.peek());
        }
    }


}

42. 连续子数组的最大和

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        int max = Integer.MIN_VALUE;
        int minSum = 0;
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
            max = Math.max(max, sum - minSum);
            minSum = Math.min(minSum, sum);
        }
        return max;
    }
}

注意：

1. 先求最大值，在求解目前的最小和

以下还有一个方法：

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        if (array == null || array.length == 0) {
            return -1;
        }
        int curSum = 0;
        int max = Integer.MIN_VALUE;
        for (int num : array) {
            if (curSum <= 0) {
                curSum = num; // 如果当前和已经小于零，则可以直接抛弃以前的和
            } else {
                curSum += num;
            }
            max = Math.max(max, curSum);
        }
        return max;
    }
}

43. 1~n整数中1出现的次数

public class Solution {
    public int NumberOf1Between1AndN_Solution(int n) {
        int ones = 0;
        for (int m = 1; m <= n; m *= 10) {
            int a = n / m;
            int b = n % m;
            ones += (a + 8) / 10 * m + (a % 10 == 1 ? b + 1: 0);
        }
        return ones;
    }
}

45. 把数组排成最小的数

import java.util.*;

public class Solution {
    public String PrintMinNumber(int [] numbers) {
        String result = "";
        List<Integer> list = new ArrayList<>();
        for (int num : numbers) {
            list.add(num);
        }
        Collections.sort(list, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                String str1 = o1 + "" + o2;
                String str2 = o2 + "" + o1;
                return str1.compareTo(str2);
            }
        });
        for (int num : list) {
            result += num;
        }
        return result;
    }
}

46. 把数字翻译成字符串

public class Solution {
    public int getTranslationCount(int number) {
        if (number < 0) {
            return 0;
        }
        String str = number + "";
        return getTranslationCount(str);
    }
    private int getTranslationCount(String str) {
        int len = str.length();
        int[] counts = new int[len];
        int count = 0;
        for (int i = len - 1; i >= 0; i--) {
            if (i < len - 1) {
                count = counts[i + 1];
            } else {
                count = 1;
            }
            if (i < len - 1) {
                int digits1 = str.charAt(i) - '0';
                int digits2 = str.charAt(i + 1) - '0';
                int num = digits1 * 10 + digits2;
                if (num > 9 && num < 26) {
                    if (i < len - 2) {
                        count += counts[i + 2];
                    } else {
                        count += 1;
                    }
                }
            }
            counts[i] = count;
        }
        return counts[0];
    }
}

47. 礼物的最大价值

方法一：没有优化

public class digitAtIndex {
    private static int getMaxValue(int[][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        if (matrix == null || row == 0 || col == 0) {
            return 0;
        }
        int[][] maxValues = new int[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                int left = 0;
                int up = 0;
                if (j > 0) {
                    left = maxValues[i][j - 1];
                }
                if (i > 0) {
                    up = maxValues[i - 1][j];
                }
                maxValues[i][j] = Math.max(left, up) + matrix[i][j];
            }
        }
        int maxValue = maxValues[row - 1][col - 1];
        return maxValue;
    }
    public static void main(String[] args) {
        int[][] number = {{1, 10, 3, 8}, {12, 2, 9, 6}, {5, 7, 4, 11}, {3, 7, 16, 5}};
        System.out.println(getMaxValue(number));
    }
}

方法二. 优化后的代码，由于没有必要存储第i-2行的数值，所以最大价值的数组可以表示为一位数组，意义如下

• 数组的前面j个数字分别表示当前第i行的前面j个格子的礼物的最大价值
• 之后的数字表示分别保存前面第i-1行的n-j个格子礼物的最大价值

public class Solution {
    private static int getMaxValue2(int[][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        if (matrix == null || row == 0 || col == 0) {
            return 0;
        }
        int[] maxValues = new int[col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                int left = 0;
                int up = 0;
                if (i > 0) {
                    up = maxValues[j];
                }
                if (j > 0) {
                    left = maxValues[j - 1];
                }
                maxValues[j] = Math.max(left, up) + matrix[i][j];
            }
        }
        return maxValues[col - 1];
    }
    public static void main(String[] args) {
        int[][] number = {{1, 10, 3, 8}, {12, 2, 9, 6}, {5, 7, 4, 11}, {3, 7, 16, 5}};
        System.out.println(getMaxValue2(number));
    }
}

48. 最长不含重复字符的子字符串

方法一：不太明白curLength的更新

public class longestSubstring {
    private static int longestSubstring(String str) {
        if (str == null || str.length() == 0) {
            return -1;
        }
        int[] position = new int[26];
        for (int i = 0; i < 26; i++) {
            position[i] = -1;
        }
        int curLength = 0;
        int maxLength = 0;
        for (int i = 0; i < str.length(); i++) {
            int preIndex = position[str.charAt(i) - 'a'];
            if (preIndex < 0 || i - preIndex > curLength) {
                curLength++;
            } else {
                if (curLength > maxLength) {
                    maxLength = curLength;
                }
                curLength = i - preIndex;
            }
            position[str.charAt(i) - 'a'] = i;
        }
        if (curLength > maxLength) {
            maxLength = curLength;
        }
        return maxLength;
    }
    public static void main(String[] args) {
        String str = "arabcacfr";
        System.out.println(longestSubstring(str));
    }
}

方法二：

import java.util.HashMap;
import java.util.Map;

public class myTest {
    private static int longestSubstring(String str) {
        if (str == null || str.length() == 0) {
            return -1;
        }
        Map<Character, Integer> mapping = new HashMap<>();
        int max = 0;
        for (int i = 0, j = 0; i < str.length(); i++) {
            // 比较巧妙
            /**
             * "arabcacfr"
             * 当遇到最后一个字母r时，此时该字母前面也出现过
             * j = 3，即上一次重复字母出现位置+1
             * 与字母r上一次出现的位置+1，进行比较，取值最大的
             * 以上过程保证了该子串不会出现重复字母
             */
            if (mapping.containsKey(str.charAt(i))) {
                j = Math.max(j, mapping.get(str.charAt(i)) + 1);
            }
            mapping.put(str.charAt(i), i);
            max = Math.max(max, i - j + 1);
        }
        return max;
    }
    public static void main(String[] args) {
        String str = "arabcacfr";
        System.out.println(longestSubstring(str));
    }
}

49. 丑数

import java.util.*;
public class Solution {
    public int GetUglyNumber_Solution(int index) {
        if (index == 0) {
            return 0;
        }
        ArrayList<Integer> uglys = new ArrayList<>();
        uglys.add(1);
        int index2 = 0;
        int index3 = 0;
        int index5 = 0;
        for (int i = 1; i < index; i++) {
            int num2 = uglys.get(index2) * 2;
            int num3 = uglys.get(index3) * 3;
            int num5 = uglys.get(index5) * 5;
            int min = Math.min(num2, Math.min(num3, num5));
            uglys.add(min);
            // 当为6时，index2与index3都要变化
            if (min == num2) {
                index2++;
            } 
            if (min == num3) {
                index3++;
            } 
            if (min == num5) {
                index5++;
            }
        }
        return uglys.get(index - 1);
    }
}

50. 第一个只出现一次的字符

public class Solution {
    public int FirstNotRepeatingChar(String str) {
        if (str == null || str.length() == 0) {
            return -1;
        }
        int[] position = new int[256];
        for (int i = 0; i < str.length(); i++) {
            position[str.charAt(i)]++;
        }
        for (int i = 0; i < str.length(); i++) {
            if (position[str.charAt(i)] == 1) {
                return i;
            }
        }
        return -1;
    }
}

51. 数组中的逆序对

 

52. 两个链表的第一个公共节点

方法一：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if (pHead1 == null || pHead2 == null) {
            return null;
        }
        ListNode tail1 = pHead1;
        while (tail1.next != null) {
            tail1 = tail1.next;
        }
        tail1.next = pHead1;
        ListNode result = helper(pHead2);
        tail1.next = null;
        return result;
    }
    private ListNode helper(ListNode head) {
        ListNode fast = head.next;
        ListNode slow = head;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return null;
            }
            fast = fast.next.next;
            slow = slow.next;
        }
        while (head != slow.next) {
            head = head.next;
            slow = slow.next;
        }
        return head;
    }
}

方法二：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if (pHead1 == null || pHead2 == null) {
            return null;
        }
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
        while (p1 != p2) {
            p1 = p1 == null ? pHead2 : p1.next;
            p2 = p2 == null ? pHead1 : p2.next;
        }
        return p1;
    }
}

方法三：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        Stack<ListNode> stackA = new Stack<>();
        Stack<ListNode> stackB = new Stack<>();
        while (headA != null || headB != null) {
            if (headA != null) {
                stackA.push(headA);
                headA = headA.next;
            }
            if (headB != null) {
                stackB.push(headB);
                headB = headB.next;
            }
        }
        ListNode common = null;
        while (!stackA.isEmpty() && !stackB.isEmpty()) {
            ListNode nodeA = stackA.pop();
            ListNode nodeB = stackB.pop();
            if (nodeA.val != nodeB.val) {
                break;
            }
            common = new ListNode(nodeA.val);
        }
        return common;
    }
}

方法四：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        int lenA = 0;
        int lenB = 0;
        ListNode nodeA = headA;
        ListNode nodeB = headB;
        while (nodeA != null || nodeB != null) {
            if (nodeA != null) {
                lenA++;
                nodeA = nodeA.next;
            }
            if (nodeB != null) {
                lenB++;
                nodeB = nodeB.next;
            }
        }
        int steps = Math.abs(lenA - lenB);
        while (steps != 0) {
            if (lenA > lenB) {
                headA = headA.next;
            } else {
                headB = headB.next;
            }
            steps--;
        }
        while (headA != null && headB != null) {
            if (headA.val == headB.val) {
                return headA;
            }
            headA = headA.next;
            headB = headB.next;
        }
        return null;
    }
}

53. 在排序数字中查找数字

一. 数字在排序数组中出现的次数

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        if (array == null || array.length == 0) {
            return 0;
        }
        int start = findFirst(array, k);
        int end = findEnd(array, k);
        if (start == -1 || end == -1) {
            return 0;
        }
        return end - start + 1;
    }
    private int findFirst(int[] array, int k) {
        int start = 0;
        int end = array.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (array[mid] >= k) {
                end = mid;
            } else {
                start = mid;
            }
        }
        if (array[start] == k) {
            return start;
        } else if (array[end] == k) {
            return end;
        }
        return -1;
    }
    private int findEnd(int[] array, int k) {
        int start = 0;
        int end = array.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (array[mid] <= k) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (array[end] == k) {
            return end;
        } else if (array[start] == k) {
            return start;
        }
        return -1;
    }
}

二. 0 ~ n - 1中缺失的数字

class test {
    private static int getMissingNumber(int[] array) {
        if (array == null || array.length == 0) {
            return -1;
        }
        int start = 0;
        int end = array.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (array[mid] != mid) {
                if (mid == 0 || array[mid - 1] == mid - 1) {
                    return mid;
                }
                end = mid;
            } else {
                start = mid;
            }
        }
        if (array[start] != start) {
            return start;
        }
        if (array[end] != end) {
            return end;
        }
        return -1;
    }
    public static void main (String[] args) {
        int[] array = {0, 1, 2, 3, 5, 6, 7, 8, 9};
        int[] array1 = {0, 1, 2, 3, 4, 5, 6, 8, 9};
        System.out.println(getMissingNumber(array));
        System.out.println(getMissingNumber(array1));
    }
}

三. 数组中数值与下标值相等的元素

public class NumberSameAsIndex {
    private static int numberSameAsIndex(int[] array) {
        if (array == null || array.length == 0) {
            return -1;
        }
        int start = 0;
        int end = array.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (array[mid] == mid) {
                return mid;
            } else if (array[mid] < mid) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (array[start] == start) {
            return start;
        }
        return end;
    }
    public static void main(String[] args) {
        int[] array = {-3, -1, 1, 3, 5};
        System.out.println(numberSameAsIndex(array));
    }
}

54. 二叉搜索树的第k大节点

/**
 * @author hta
 * @since 下午6:20 17-11-26
 */
public class test {
    static class TreeNode {
        TreeNode left = null;
        TreeNode right = null;
        int val;
        TreeNode (int val) {
            this.val = val;
        }
    }
    private static int globalK = 0;
    private static TreeNode KthNode (TreeNode root, int k) {
        if (root == null || k == 0) {
            return null;
        }
        globalK = k;
        return KthNodeHelper(root);
    }
    private static TreeNode KthNodeHelper(TreeNode root) {
        TreeNode target = null;
        if (root.left != null) {
            target = KthNodeHelper(root.left);
        }
        if (target == null) {
            if (globalK == 1) {
                target = root;
            }
            globalK--;
        }
        if (target == null && root.right != null) {
            target = KthNodeHelper(root.right);
        }
        return target;
    }
    public static void main (String[] args) {
        TreeNode root = new TreeNode(5);
        TreeNode left = new TreeNode(3);
        TreeNode right = new TreeNode(7);
        root.left = left;
        root.right = right;
        left.left = new TreeNode(2);
        left.right = new TreeNode(4);
        right.left = new TreeNode(6);
        right.right = new TreeNode(8);
        System.out.println(KthNode(root, 3).val);
    }
}

55. 二叉树的深度

一. 二叉树深度

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
 
    public TreeNode(int val) {
        this.val = val;
 
    }
 
}
*/
public class Solution {
    public int TreeDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = TreeDepth(root.left);
        int rightDepth = TreeDepth(root.right);
        return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
    }
}

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

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

    }

}
*/
public class Solution {
    private int depth = 0;
    public int TreeDepth(TreeNode root) {
        depthHelper(root, 1);
        return depth;
    }
    private void depthHelper(TreeNode root, int curDepth) {
        if (root == null) {
            return;
        }
        if (depth < curDepth) {
            depth = curDepth;
        }
        depthHelper(root.left, curDepth + 1);
        depthHelper(root.right, curDepth + 1);
    }
}

二. 平衡二叉树

public class Solution {
    private class ResultType {
        boolean isBalanced;
        int maxDepth;
        ResultType(boolean isBalanced, int maxDepth) {
            this.isBalanced = isBalanced;
            this.maxDepth = maxDepth;
        }
    }
    public boolean IsBalanced_Solution(TreeNode root) {
        if (root == null) {
            return true;
        }
        return helper(root).isBalanced;
    }
    private ResultType helper(TreeNode root) {
        if (root == null) {
            return new ResultType(true, 0);
        }
        ResultType left = helper(root.left);
        ResultType right = helper(root.right);
        if (!left.isBalanced || !right.isBalanced) {
            return new ResultType(false, -1);
        }
        if (Math.abs(left.maxDepth - right.maxDepth) > 1) {
            return new ResultType(false, -1);
        }
        return new ResultType(true, Math.max(left.maxDepth, right.maxDepth) + 1);
    }
}

56. 数组中数字的出现次数

一. 数组中只出现一次的两个数字

思路：仿照只出现一次的一个数字的过程，将数组按照最后异或结果的某一位是否为1将数组划分为两个数组

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        if (array == null || array.length == 0) {
            return;
        }
        int result = 0;
        for (int num : array) {
            result ^= num;
        }
        int indexOfBit1 = findIndex(result);
        for (int num : array) {
            if (isBit1(num, indexOfBit1)) {
                num1[0] ^= num;
            } else {
                num2[0] ^= num;
            }
        }
    }
    private int findIndex(int result) {
        int index = 0;
        while ((result & 1) == 0 && index < 32) {
            result = result >> 1;
            index++;
        }
        return index;
    }
    private boolean isBit1(int num, int index) {
        num = num >> index;
        if ((num & 1) == 1) {
            return true;
        }
        return false;
    }
}

二. 数组中唯一只出现一次的数字

/**
 * @author hta
 * @since 下午9:07 17-11-26
 */
public class FindNumberAppearingOnce {
    private static int findNumberAppearingOnce(int[] array) {
        if (array == null || array.length == 0) {
            return -1;
        }
        int[] bitSum = new int[32];
        for (int i = 0; i < array.length; i++) {
            int bitMask = 1;
            // 记得bit的顺序
            for (int j = 31; j >= 0; j--) {
                int bit = array[i] & bitMask;
                if (bit != 0) {
                    bitSum[j]++;
                }
                bitMask <<= 1;
            }
        }
        int result = 0;
        // 记得bit的顺序
        for (int i = 0; i < 32; i++) {
            result <<= 1;
            result += bitSum[i] % 3;
        }
        return result;
    }
    public static void main(String[] args) {
        int[] array = {1, 1, 1, 2, 2, 2, 3, 5, 5, 5};
        System.out.println(findNumberAppearingOnce(array));
    }
}

57. 和为s的数字

一. 和为s的两个数字

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        ArrayList<Integer> result = new ArrayList<>();
        if (array == null || array.length == 0) {
            return result;
        }
        int start = 0;
        int end = array.length - 1;
        while (start < end) {
            int curSum = array[start] + array[end];
            if (curSum == sum) {
                result.add(array[start]);
                result.add(array[end]);
                return result;
            } else if (curSum > sum) {
                end--;
            } else {
                start++;
            }
        }
        return result;
    }
}

二. 和为s的连续正数序列

import java.util.ArrayList;
public class Solution {
    public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        if (sum < 3) {
            return result;
        }
        int small = 1;
        int big = 2;
        int middle = (sum + 1) / 2;
        int curSum = small + big;
        while (small < middle) {
            if (curSum == sum) {
                result.add(getList(small, big));
            }
            while (curSum > sum && small < middle) {
                curSum -= small;
                small++;
                if (curSum == sum) {
                    result.add(getList(small, big));
                }
            }
            big++;
            curSum += big;
        }
        return result;
    }
    private ArrayList<Integer> getList(int small, int big) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = small; i <= big; i++) {
            list.add(i);
        }
        return list;
    }
}

58. 翻转字符串

一. 翻转单词顺序

public class Solution {
    public String ReverseSentence(String str) {
        if (str.trim().equals("")) {
            return str;
        }
        String[] strs = str.split(" ");
        StringBuffer sb = new StringBuffer();
        for (int i = strs.length - 1; i >= 0; i--) {
            sb.append(strs[i]);
            if (i > 0) {
                sb.append(" ");
            }
        }
        return sb.toString();
    }
}

二. 左旋转字符串

public class Solution {
    public String LeftRotateString(String str,int n) {
        if (str == null || str.length() == 0 || n == 0) {
            return str;
        }
        n %= str.length();
        char[] chars = str.toCharArray();
        reverse(chars, 0, n - 1);
        reverse(chars, n, str.length() - 1);
        reverse(chars, 0, str.length() - 1);
        return new String(chars);
    }
    private void reverse(char[] chars, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            char temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
        }
    }
}

59. 队列的最大值

一. 滑动窗口的最大值

import java.util.*;
public class Solution {
    public ArrayList<Integer> maxInWindows(int [] num, int size) {
        ArrayList<Integer> result = new ArrayList<>();
        if (num == null || num.length == 0 || size == 0) {
            return result;
        }
        int index = 0;
        while (index <= num.length - size) {
            int max = Integer.MIN_VALUE;
            for (int i = index; i < index + size; i++) {
                max = Math.max(max, num[i]);
            }
            result.add(max);
            index++;
        }
        return result;
    }
}

import java.util.*;
public class Solution {
    public ArrayList<Integer> maxInWindows(int [] num, int size) {
        ArrayList<Integer> result = new ArrayList<>();
        if (num.length < size || size < 1) {
            return result;
        }
        ArrayDeque<Integer> index = new ArrayDeque<>();
        int begin;
        for (int i = 0; i < num.length; i++) {
            begin = i - size + 1;
            if (index.isEmpty()) {
                index.offer(i);
            } else if (begin > index.peek()) {
                index.poll();
            }
            while (!index.isEmpty() && num[i] >= num[index.peekLast()]) {
                index.pollLast();
            }
            index.add(i);
            if (begin >= 0) {
                result.add(num[index.peek()]);
            }
        }
        return result;
    }
}

二. 队列的最大值

import java.util.ArrayDeque;

public class QueueWithMax {
    private class InternalData {
        int index;
        int number;
        InternalData(int index, int number) {
            this.index = index;
            this.number = number;
        }
    }
    private ArrayDeque<InternalData> queue;
    private ArrayDeque<InternalData> maxQueue;
    private int curIndex;
    QueueWithMax() {
        queue = new ArrayDeque<>();
        maxQueue = new ArrayDeque<>();
    }

    public void offer(int num) {
        while (!maxQueue.isEmpty() && num >= maxQueue.peekLast().number) {
            maxQueue.pollLast();
        }
        InternalData internalData = new InternalData(curIndex, num);
        queue.offer(internalData);
        maxQueue.offer(internalData);
        curIndex++;
    }

    public int poll() throws Exception {
        if (maxQueue.isEmpty()) {
            throw new Exception("queue is empty");
        }
        if (queue.peek().index == maxQueue.peek().index) {
            maxQueue.poll();
        }
        return queue.poll().number;
    }

    public int max() throws Exception {
        if (maxQueue.isEmpty()) {
            throw new Exception("queue is empty");
        }
        return maxQueue.peek().number;
    }
}
class test {
    public static void main(String[] args) throws Exception {
        int[] array = {7, 8, 5, 4, 3, 6, 9};
        QueueWithMax queue = new QueueWithMax();
        queue.offer(array[0]);
        queue.offer(array[1]);
        queue.offer(array[2]);
        queue.offer(array[6]);
        queue.offer(array[5]);
        queue.poll();
        System.out.println(queue.max());
    }
}

60. n个骰子的点数