From 745314052cbc5647c218e375d8d6417b5535804e Mon Sep 17 00:00:00 2001 From: CyC2018 <1029579233@qq.com> Date: Sat, 17 Mar 2018 19:47:59 +0800 Subject: [PATCH] auto commit --- notes/剑指 offer 题解.md | 131 ++++++++++++++++++++++++++++++--------- 1 file changed, 103 insertions(+), 28 deletions(-) diff --git a/notes/剑指 offer 题解.md b/notes/剑指 offer 题解.md index 4851618c..c0f792fb 100644 --- a/notes/剑指 offer 题解.md +++ b/notes/剑指 offer 题解.md @@ -461,6 +461,8 @@ public class Solution { 一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。 +## 解题思路 + ```java public int JumpFloor(int n) { if (n == 1) return 1; @@ -480,6 +482,8 @@ public int JumpFloor(int n) { 一只青蛙一次可以跳上 1 级台阶，也可以跳上 2 级……它也可以跳上 n 级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。 +## 解题思路 + ```java public int JumpFloorII(int n) { int[] dp = new int[n]; @@ -499,6 +503,8 @@ public int JumpFloorII(int n) { 我们可以用 2\*1 的小矩形横着或者竖着去覆盖更大的矩形。请问用 n 个 2\*1 的小矩形无重叠地覆盖一个 2\*n 的大矩形，总共有多少种方法？ +## 解题思路 + ```java public int RectCover(int n) { if (n < 2) return n; @@ -685,7 +691,7 @@ int maxProductAfterCuttin(int length) { 输入一个整数，输出该数二进制表示中 1 的个数。其中负数用补码表示 -**使用库函数** +### Integer.bitCount() ```java public int NumberOf1(int n) { @@ -693,9 +699,11 @@ public int NumberOf1(int n) { } ``` -**O(logM) 时间复杂度解法，其中 M 表示 1 的个数** +### n&(n-1) -n&(n-1) 该位运算是去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110100，减去 1 得到 10110011，这两个数相与得到 10110000。 +O(logM) 时间复杂度解法，其中 M 表示 1 的个数。 + +该位运算是去除 n 的位级表示中最低的那一位。例如对于二进制表示 10110100，减去 1 得到 10110011，这两个数相与得到 10110000。 ```java public int NumberOf1(int n) { @@ -782,16 +790,16 @@ private void printNumber(char[] number) { ## 解题思路 -- 如果链表不是尾节点，那么可以直接将下一个节点的值赋给节点，令节点指向下下个节点，然后删除下一个节点，时间复杂度为 O(1)。 +① 如果链表不是尾节点，那么可以直接将下一个节点的值赋给节点，令节点指向下下个节点，然后删除下一个节点，时间复杂度为 O(1)。

-- 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向节点的下一个节点，时间复杂度为 O(N)。 +② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向节点的下一个节点，时间复杂度为 O(N)。

-- 综上，如果进行 N 次操作，那么大约需要移动节点的次数为 N-1+N=2N-1，其中 N-1 表示不是链表尾节点情况下的移动次数，N 表示是尾节点情况下的移动次数。(2N-1)/N \~ 2，因此该算法的时间复杂度为 O(1)。 +③ 综上，如果进行 N 次操作，那么大约需要移动节点的次数为 N-1+N=2N-1，其中 N-1 表示不是链表尾节点情况下的移动次数，N 表示是尾节点情况下的移动次数。(2N-1)/N \~ 2，因此该算法的时间复杂度为 O(1)。 ```java public ListNode deleteNode(ListNode head, ListNode tobeDelete) { @@ -819,9 +827,8 @@ Input : 1->2->3->3->4->4->5 Output : 1->2->5 ``` -**解题描述** +## 解题描述 -递归。 ```java public ListNode deleteDuplication(ListNode pHead) { @@ -844,7 +851,9 @@ public ListNode deleteDuplication(ListNode pHead) { ## 题目描述 -请实现一个函数用来匹配包括 '.' 和 '\*' 的正则表达式。模式中的字符 '.' 表示任意一个字符，而 '\*' 表示它前面的字符可以出现任意次（包含 0 次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配. +请实现一个函数用来匹配包括 '.' 和 '\*' 的正则表达式。模式中的字符 '.' 表示任意一个字符，而 '\*' 表示它前面的字符可以出现任意次（包含 0 次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串 "aaa" 与模式 "a.a" 和 "ab\*ac\*a" 匹配，但是与 "aa.a" 和 "ab\*a" 均不匹配。 + +## 解题思路 ```java public boolean match(char[] s, char[] p) { @@ -879,6 +888,8 @@ public boolean match(char[] s, char[] p) { 请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串 "+100","5e2","-123","3.1416" 和 "-1E-16" 都表示数值。 但是 "12e","1a3.14","1.2.3","+-5" 和 "12e+4.3" 都不是。 +## 解题思路 + ```java public boolean isNumeric(char[] str) { String string = String.valueOf(str); @@ -888,14 +899,13 @@ public boolean isNumeric(char[] str) { # 21. 调整数组顺序使奇数位于偶数前面 -**题目要求** +## 题目描述 保证奇数和奇数，偶数和偶数之间的相对位置不变，这和书本不太一样。 ## 解题思路 -- 时间复杂度 : O(n2) -- 空间复杂度 : O(1) +复杂度：O(n2) + O(1) ```java public void reOrderArray(int[] array) { @@ -915,8 +925,7 @@ public void reOrderArray(int[] array) { } ``` -- 时间复杂度 : O(n) -- 空间复杂度 : O(n) +复杂度：O(n) + O(n) ```java public void reOrderArray(int[] array) { @@ -937,6 +946,8 @@ public void reOrderArray(int[] array) { 设链表的长度为 N。设两个指针 P1 和 P2，先让 P1 移动 K 个节点，则还有 N - K 个节点可以移动。此时让 P1 和 P2 同时移动，可以知道当 P1 移动到链表结尾时，P2 移动到 N - K 个节点处，该位置就是倒数第 K 个节点。 +## 解题思路 +

```java @@ -988,8 +999,6 @@ public ListNode EntryNodeOfLoop(ListNode pHead) { ## 解题思路 -头插法 - ```java public ListNode ReverseList(ListNode head) { ListNode newList = new ListNode(-1); @@ -1009,6 +1018,8 @@ public ListNode ReverseList(ListNode head) {

+## 解题思路 + ```java public ListNode Merge(ListNode list1, ListNode list2) { ListNode head = new ListNode(-1); @@ -1035,6 +1046,8 @@ public ListNode Merge(ListNode list1, ListNode list2) {

+## 解题思路 + ```java public boolean HasSubtree(TreeNode root1, TreeNode root2) { if (root1 == null || root2 == null) return false; @@ -1056,6 +1069,8 @@ private boolean isSubtree(TreeNode root1, TreeNode root2) {

+## 解题思路 + ```java public void Mirror(TreeNode root) { if (root == null) return; @@ -1079,6 +1094,8 @@ public void Mirror(TreeNode root) { 3 4 4 3 ``` +## 解题思路 + ```java boolean isSymmetrical(TreeNode pRoot) { if (pRoot == null) return true; @@ -1107,6 +1124,8 @@ boolean isSymmetrical(TreeNode t1, TreeNode t2) { 平衡二叉树左右子树高度差不超过 1。 +## 解题思路 + ```java private boolean isBalanced = true; @@ -1132,6 +1151,8 @@ private int height(TreeNode root) {

+## 解题思路 + ```java public ArrayList printMatrix(int[][] matrix) { ArrayList ret = new ArrayList<>(); @@ -1153,6 +1174,8 @@ public ArrayList printMatrix(int[][] matrix) { 定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的 min 函数。 +## 解题思路 + ```java private Stack stack = new Stack<>(); private Stack minStack = new Stack<>(); @@ -1185,6 +1208,8 @@ public int min() { 输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。 +## 解题思路 + ```java public boolean IsPopOrder(int[] pushA, int[] popA) { int n = pushA.length; @@ -1241,6 +1266,8 @@ public ArrayList PrintFromTopToBottom(TreeNode root) { 和上题几乎一样。 +## 解题思路 + ```java ArrayList> Print(TreeNode pRoot) { ArrayList> ret = new ArrayList<>(); @@ -1268,6 +1295,8 @@ ArrayList> Print(TreeNode pRoot) { 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。 +## 解题思路 + ```java public ArrayList> Print(TreeNode pRoot) { ArrayList> ret = new ArrayList<>(); @@ -1306,6 +1335,8 @@ public ArrayList> Print(TreeNode pRoot) {

+## 解题思路 + ```java public boolean VerifySquenceOfBST(int[] sequence) { if (sequence.length == 0) return false; @@ -1334,6 +1365,8 @@ private boolean verify(int[] sequence, int first, int last) {

+## 解题思路 + ```java private ArrayList> ret = new ArrayList<>(); @@ -1420,6 +1453,8 @@ public RandomListNode Clone(RandomListNode pHead) {

+## 解题思路 + ```java private TreeNode pre = null; public TreeNode Convert(TreeNode pRootOfTree) { @@ -1445,6 +1480,8 @@ private void inOrder(TreeNode node) { 请实现两个函数，分别用来序列化和反序列化二叉树。 +## 解题思路 + ```java public class Solution { @@ -1481,6 +1518,8 @@ public class Solution { 输入一个字符串 , 按字典序打印出该字符串中字符的所有排列。例如输入字符串 abc, 则打印出由字符 a, b, c 所能排列出来的所有字符串 abc, acb, bac, bca, cab 和 cba。 +## 解题思路 + ```java private ArrayList ret = new ArrayList<>(); @@ -1538,10 +1577,11 @@ public int MoreThanHalfNum_Solution(int[] nums) { # 40. 最小的 K 个数 -**快速选择** +## 解题思路 -- 时间复杂度：O(N) -- 空间复杂度：O(1) +### 快速选择 + +- 复杂度：O(N) + O(1) - 只有当可以修改数组元素时才可以使用 快速排序的 partition() 方法，会返回一个整数 j 使得 a[lo..j-1] 小于等于 a[j]，且 a[j+1..hi] 大于等于 a[j]，此时 a[j] 就是数组的第 j 大元素，可以利用这个特性找出数组的第 K 个元素，这种找第 K 个元素的算法称为快速选择算法。 @@ -1601,10 +1641,9 @@ private boolean less(int v, int w) { } ``` -**大小为 K 的最小堆** +### 大小为 K 的最小堆 -- 时间复杂度：O(NlogK) -- 空间复杂度：O(K) +- 复杂度：O(NlogK) + O(K) - 特别适合处理海量数据 应该注意的是，应该使用大顶堆来维护最小堆，而不能直接创建一个小顶堆并设置一个大小，企图让小顶堆中的元素都是最小元素。 @@ -1632,6 +1671,8 @@ public ArrayList GetLeastNumbers_Solution(int[] input, int k) { 如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。 +## 解题思路 + ```java public class Solution { // 大顶堆，存储左半边元素 @@ -1672,6 +1713,8 @@ public class Solution { 请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符 "go" 时，第一个只出现一次的字符是 "g"。当从该字符流中读出前六个字符“google" 时，第一个只出现一次的字符是 "l"。 +## 解题思路 + ```java public class Solution { private int[] cnts = new int[256]; @@ -1696,7 +1739,9 @@ public class Solution { ## 题目描述 -{6,-3,-2,7,-15,1,2,2}，连续子向量的最大和为 8（从第 0 个开始,到第 3 个为止） +{6,-3,-2,7,-15,1,2,2}，连续子向量的最大和为 8（从第 0 个开始，到第 3 个为止）。 + +## 解题思路 ```java public int FindGreatestSumOfSubArray(int[] nums) { @@ -1733,6 +1778,8 @@ public int NumberOf1Between1AndN_Solution(int n) { 数字以 0123456789101112131415... 的格式序列化到一个字符串中，求这个字符串的第 index 位。 +## 解题思路 + ```java public int digitAtIndex(int index) { if (index < 0) return -1; @@ -1804,6 +1851,8 @@ public String PrintMinNumber(int[] numbers) { 给定一个数字，按照如下规则翻译成字符串：0 翻译成“a”，1 翻译成“b”...25 翻译成“z”。一个数字有多种翻译可能，例如 12258 一共有 5 种，分别是 bccfi，bwfi，bczi，mcfi，mzi。实现一个函数，用来计算一个数字有多少种不同的翻译方法。 +## 解题思路 + ```java public int getTranslationCount(String number) { int n = number.length(); @@ -1861,6 +1910,8 @@ public int getMaxValue(int[][] values) { 输入一个字符串（只包含 a\~z 的字符），求其最长不含重复字符的子字符串的长度。例如对于 arabcacfr，最长不含重复字符的子字符串为 acfr，长度为 4。 +## 解题思路 + ```java public int longestSubStringWithoutDuplication(String str) { int curLen = 0; @@ -1887,6 +1938,8 @@ public int longestSubStringWithoutDuplication(String str) { 把只包含因子 2、3 和 5 的数称作丑数（Ugly Number）。例如 6、8 都是丑数，但 14 不是，因为它包含因子 7。 习惯上我们把 1 当做是第一个丑数。求按从小到大的顺序的第 N 个丑数。 +## 解题思路 + ```java public int GetUglyNumber_Solution(int N) { if (N <= 6) return N; @@ -1923,6 +1976,8 @@ public int FirstNotRepeatingChar(String str) { 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数 P。 +## 解题思路 + ```java private long cnt = 0; private int[] tmp; // 在这里创建辅助数组，而不是在 merge() 递归函数中创建 @@ -2123,7 +2178,9 @@ public ArrayList FindNumbersWithSum(int[] array, int sum) { ## 题目描述 -和为 100 的连续序列有 18, 19, 20, 21, 22 +和为 100 的连续序列有 18, 19, 20, 21, 22。 + +## 解题思路 ```java public ArrayList> FindContinuousSequence(int sum) { @@ -2200,6 +2257,8 @@ private void reverse(char[] c, int start, int end) { 对于一个给定的字符序列 S，请你把其循环左移 K 位后的序列输出。例如，字符序列 S=”abcXYZdef”, 要求输出循环左移 3 位后的结果，即“XYZdefabc”。 +## 解题思路 + ```java public String LeftRotateString(String str, int k) { if (str.length() == 0) return ""; @@ -2225,7 +2284,9 @@ private void reverse(char[] c, int i, int j) { ## 题目描述 -给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}； +给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组 {2, 3, 4, 2, 6, 2, 5, 1} 及滑动窗口的大小 3，那么一共存在 6 个滑动窗口，他们的最大值分别为 {4, 4, 6, 6, 6, 5}。 + +## 解题思路 ```java public ArrayList maxInWindows(int[] num, int size) { @@ -2250,7 +2311,11 @@ public ArrayList maxInWindows(int[] num, int size) { 把 n 个骰子仍在地上，求点数和为 s 的概率。 -最直观的动态规划解法，O(n2) 的空间复杂度。 +## 解题思路 + +### 动态规划解法 + +空间复杂度：O(n2) ```java private static int face = 6; @@ -2276,7 +2341,9 @@ public double countProbability(int n, int s) { } ``` -使用旋转数组将空间复杂度降低为 O(n) +### 动态规划解法 + 旋转数组 + +空间复杂度：O(n) ```java private static int face = 6; @@ -2310,6 +2377,8 @@ public double countProbability(int n, int s) { 五张牌，其中大小鬼为癞子，牌面大小为 0。判断是否能组成顺子。 +## 解题思路 + ```java public boolean isContinuous(int [] numbers) { if(numbers.length < 5) return false; @@ -2350,6 +2419,8 @@ public int LastRemaining_Solution(int n, int m) { 可以有一次买入和一次卖出，买入必须在前。求最大收益。 +## 解题思路 + ```java public int maxProfit(int[] prices) { int n = prices.length; @@ -2368,7 +2439,9 @@ public int maxProfit(int[] prices) { ## 题目描述 -求 1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句（A?B:C） +求 1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case 等关键字及条件判断语句（A?B:C）。 + +## 解题思路 ```java public int Sum_Solution(int n) { @@ -2395,6 +2468,8 @@ public int Add(int num1, int num2) { 给定一个数组 A[0, 1,..., n-1], 请构建一个数组 B[0, 1,..., n-1], 其中 B 中的元素 B[i]=A[0]\*A[1]\*...\*A[i-1]\*A[i+1]\*...\*A[n-1]。不能使用除法。 +## 解题思路 + ```java public int[] multiply(int[] A) { int n = A.length;