jz offer

Author: rchen102

JZandNC/jz 17.java

@@ -0,0 +1,31 @@
+class Solution {
+    public int[] printNumbers(int n) {
+        char[] arr = new char[n+1];
+        List<Integer> res = new ArrayList<>();
+        Arrays.fill(arr, '0');
+        while (increment(arr)) {
+            res.add(Integer.parseInt(new String(arr)));
+        }
+        return res.stream().mapToInt(Integer::intValue).toArray();
+    }
+
+    public boolean increment(char[] num) {
+        int carry = 1;
+        for (int i = num.length - 1; i >= 0; i--) {
+            if (carry == 0) break;
+            char cur = num[i];
+            int val = cur - '0';
+            int sum = carry + val;
+            // 判断是否需要进位
+            if (sum >= 10) {
+                carry = 1;
+                sum -= 10;
+            } else {
+                carry = 0;
+            }
+            num[i] = (char) ('0' + sum);
+        }
+        if (num[0] != '0') return false;
+        return true;
+    }
+}

JZandNC/jz 26.java

@@ -0,0 +1,15 @@
+class Solution {
+    public boolean isSubStructure(TreeNode A, TreeNode B) {
+        if (A == null || B == null) return false;
+        boolean res = dfs(A, B);
+        if (res) return true;
+        return isSubStructure(A.left, B) || isSubStructure(A.right, B);        
+    }
+
+    public boolean dfs(TreeNode A, TreeNode B) {
+        if (B == null) return true;  // B 已经遍历完了
+        if (A == null) return false; // A 已经遍历完了，B 还没有
+        if (A.val != B.val) return false;
+        return dfs(A.left, B.left) && dfs(A.right, B.right);
+    }
+}

JZandNC/jz 46.java

@@ -0,0 +1,25 @@
+class Solution {
+    public int translateNum(int num) {
+        // 1. 从前往后，dp 推导（本题不太方便）
+        // dp[i] 以 nums[i] 结尾的字符串，可以翻译的数量，下标从 1 开始
+        // dp[i] = dp[i-1] 或者 dp[i-1] + dp[i-2]（当 nums[i] 和 nums[i-1] 组成的元素 < 26）
+        // 2. 从后往前计算，本质相同
+        // dp[i] [i..end] 这部分可以组成的字符串数量   
+        int prev = 1; // dp[0]
+        int cur = 1;  // dp[1]
+        int prevDigit = num % 10;
+        num = num / 10;
+        while (num != 0) {
+            int digit = num % 10;
+            num = num / 10;
+            // 计算翻译方法
+            int res = cur;
+            if (digit != 0 && digit * 10 + prevDigit <= 25) res += prev;
+            // 更新相关参数，为下轮循环做准备
+            prev = cur;
+            cur = res;
+            prevDigit = digit;
+        }
+        return cur;
+    }
+}

JZandNC/jz 50.java

@@ -0,0 +1,59 @@
+// LinkedHashMap
+class Solution {
+    public char firstUniqChar(String s) {
+        if (s.length() == 0) return ' ';
+        Map<Character, Integer> map = new LinkedHashMap<>();
+        for (char ch : s.toCharArray()) {
+            map.put(ch, map.getOrDefault(ch, 0) + 1);
+        }
+        for (char ch : map.keySet()) {
+            if (map.get(ch) == 1) return ch;
+        }
+        return ' ';
+    }
+}
+
+
+
+// map 中存储 idx+1，避免 0 有歧义
+class Solution {
+    public char firstUniqChar(String s) {
+        if (s.length() == 0) return ' ';
+        int[] map = new int[256];
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            if (map[ch] == 0) map[ch] = i+1;
+            else if (map[ch] >= 1) map[ch] = -1; // 重复出现了，失去了资格 
+        }
+        int minIdx = s.length();
+        for (int i = 0; i < map.length; i++) {
+            if (map[i]-1 >= 0) {
+                minIdx = Math.min(minIdx, map[i]-1);
+            }
+        }
+        if (minIdx == s.length()) return ' ';
+        return s.charAt(minIdx);
+    }
+}
+
+// 初始化 map 为 -1
+class Solution {
+    public char firstUniqChar(String s) {
+        if (s.length() == 0) return ' ';
+        int[] map = new int[256];
+        Arrays.fill(map, -1);
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            if (map[ch] == -1) map[ch] = i;
+            else if (map[ch] >= 0) map[ch] = -2; // 重复出现了，失去了资格 
+        }
+        int minIdx = s.length();
+        for (int i = 0; i < map.length; i++) {
+            if (map[i] >= 0) {
+                minIdx = Math.min(minIdx, map[i]);
+            }
+        }
+        if (minIdx == s.length()) return ' ';
+        return s.charAt(minIdx);
+    }
+}

JZandNC/jz 51.java

@@ -0,0 +1,72 @@
+// 就是个归并排序，不过在归并排序过程中统计了一下逆序对
+class Solution {
+    public int reversePairs(int[] nums) {
+        // 利用归并排序，合并时，进行计算
+        if (nums == null || nums.length == 0) return 0;
+        return countReverse(nums, 0, nums.length - 1);
+    }
+
+    int countReverse(int[] arr, int lo, int hi) {
+        if (lo >= hi) return 0;
+        int mid = lo + ((hi - lo) >> 1);
+        int left = countReverse(arr, lo, mid);
+        int right = countReverse(arr, mid+1, hi);
+        int res = merge(arr, lo, hi);
+        return res + left + right;
+    }
+
+    // merge [lo, mid]  [mid+1, hi]
+    int merge(int[] arr, int lo, int hi) {
+        int mid = lo + ((hi - lo) >> 1);
+        int[] tmp = new int[hi-lo+1];
+        int i = lo, j = mid+1, k = 0;
+        int res = 0;
+        while (i <= mid && j <= hi) {
+            if (arr[i] <= arr[j]) {
+                tmp[k++] = arr[i++]; 
+            }
+            else {
+                tmp[k++] = arr[j++];
+                res += mid - i + 1;
+            }
+        }
+        while (i <= mid) tmp[k++] = arr[i++];
+        while (j <= hi) tmp[k++] = arr[j++];
+        k = 0;
+        while (k < hi - lo + 1) {
+            arr[lo+k] = tmp[k];
+            k++;
+        }
+        return res;
+    }
+}
+
+
+// 会超时
+class Solution {
+    public int reversePairs(int[] nums) {
+        // 冒泡排序，每次交换，逆序度减一
+        // 插入排序，每次移动，逆序度减一
+        int res = 0;
+        int n = nums.length;
+        boolean flag; // 本轮交换是否有数据交换
+        for (int i = 0; i < n; i++) {
+            flag = false;
+            for (int j = 0; j < n - i - 1; j++) {
+                if (nums[j] > nums[j+1]) {
+                    swap(nums, j ,j+1);
+                    flag = true;
+                    res++;
+                }
+            }
+            if (!flag) break;
+        }
+        return res;
+    }
+
+    void swap(int[] arr, int a, int b) {
+        int tmp = arr[a];
+        arr[a] = arr[b];
+        arr[b] = tmp;
+    }
+}