错误总结
前言
自信满满去牛客网刷剑指offer，结果前几题没一道过的。所以痛定思痛，决定把自己犯的睿智错误记录下来，以此为戒。
剪绳子
错误原因：Math.pow参数搞反了。
//我想写个3^n，结果写成了下面这个n^3，看了好久才发现。
Math.pow(n,3);
机器人的运动范围
错误原因：搜索的时候没有返回sum+1;
public int dfs(int i,int j){
visited[i][j] = true;
if(check(i,j) > threshold){
return 0;
}
int sum = 0;
if(i<visited.length - 1 && !visited[i+1][j])
sum += dfs(i+1,j);
if(j<visited[0].length - 1 && !visited[i][j+1])
sum += dfs(i,j+1);
//这是我一开始写的，没有加上1，而且我dfs末节点返回的是0，就导致了sum始终为0
//所以dfs末节点返回的时候一定要当心，注意什么时候返回false，什么时候返回true
//返回0的时候一定要当心，如果不进行处理的话一直会是0
return sum;
//return sum+1;
}
矩阵中的路径
错误原因：
- DFS没有返回true
- 计算元素位置错误
- 乱用i++
public boolean dfs(int i,int j,int index){
//然后数组元素的计算也出了问题，一开始写成了row*i+col*j
//应该在纸上先找找规律，不要这么自信
if(matrix[j+cols*i] != str[index])
return false;
//首先错在这里，没有返回true的情况，所以怎么返回都是false。
if(matrix[j+cols*i] == str[index] && index == str.length-1)
return true;
visited[i][j] = true;
boolean up = false;
boolean down = false;
boolean left = false;
boolean right = false;
if(i>0 && !visited[i-1][j])
//最后是这里，找了半天没看出来，
//在这里使用index++会导致每次条件判断后无论成立不成立都会使index++，
//明明没有找到符合当前字符的坐标，却把字符向后移动了一位，所以i++千万不要乱用。
//正确的写法应该是 up = dfs(i-1,j,index+1);
up = dfs(i-1,j,index++);
if(i<rows-1 && !visited[i+1][j])
down = dfs(i+1,j,index+1);
if(j>0 && !visited[i][j-1])
left = dfs(i,j-1,index+1);
if(j<cols-1 && !visited[i][j+1])
right = dfs(i,j+1,index+1);
return up||down||right||left;
}
滑动窗口的最大值
错误原因：忘记left++
while(right < num.length){
while(!queue.isEmpty() && queue.peekLast() < num[right])
queue.removeLast();
queue.addLast(num[right++]);
if(right-left == size){
res.add(queue.peekFirst());
}else if(right-left > size){
//说明此时left需要向右移动
if(queue.peekFirst() == num[left]){
queue.removeFirst();
//我把left++写在这里了，
//导致只有当队列头元素和左边界相等的时候left才会自增
left++;
}
res.add(queue.peekFirst());
//应该在这里写 left++;
}
}
数据流的中位数
错误原因：Java优先队列的名字不会打，默认是小顶堆记不清。
//首先PriorityQueue拼不对
static PriorityQueue<Integer> smallHeap = new PriorityQueue<>();
//其次lambda表达式写错了，降序排列的CMP应该是return y-x;
static PriorityQueue<Integer> bigHeap = new PriorityQueue<>((x,y)->(y-x));
二叉搜索树的第K个节点
错误原因：没有搞清楚应该使用全局变量还是局部变量。
TreeNode res = null;
//int target = 1;
TreeNode KthNode(TreeNode pRoot, int k)
{
//target = k;
findNode(pRoot, k);
return res;
}
/**
* 中序遍历递归寻找Kth节点
**/
public void findNode(TreeNode p, int k){
if(k == 0)
return;
if(p == null)
return;
//我在这边使用了局部变量k，这会导致当左子树k=0返回的时候，
//在父节点看来k还是为1,所以还会向右子树递归，导致结果出错。
//应该定义一个全局变量target来保存k的状态。
findNode(p.left, k);
k--;
if(k==0){
res = p;
return;
}
findNode(p.right, k);
}
二叉树的下一个节点
错误原因：没有考虑清楚当前节点没有右子树且是其父节点的右子树的情况。
/*
public class TreeLinkNode {
int val;
TreeLinkNode left = null;
TreeLinkNode right = null;
TreeLinkNode next = null;
TreeLinkNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public TreeLinkNode GetNext(TreeLinkNode pNode)
{
if(pNode == null)
return null;
//右子树不为空的时候返回右子树的最左节点
if(pNode.right != null){
TreeLinkNode tmp = pNode.right;
while(tmp.left != null){
tmp = tmp.left;
}
return tmp;
}
//不存在右子树的情况
//说明根节点,直接返回null
if(pNode.next == null)
return null;
//说明不是根节点，判断是该节点是父节点的左节点还是右节点
TreeLinkNode father = pNode.next;
//左节点，返回父节点
if(father.left == pNode)
return father;
else{
//右节点，不断向上判断直到父节点是null,
//或者找个一个是其父节点的左节点
//一开始的时候没有考虑清楚，以为这种情况下直接返回其祖父节点就行了
//其实不是这样，还会要在草稿纸上多画画
while(father.next != null){
TreeLinkNode tmp = father.next;
if(tmp.left == father)
return tmp;
else
father = father.next;
}
return null;
}
}
}
删除链表中的重复节点
题目大意：给出一个排好序的链表，删除其中重复的所有节点。
错误原因：没有考虑头结点为空的情况。
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ListNode deleteDuplication(ListNode pHead)
{
//一开始没有写这一段
//导致会在while(cur.next != null)中空指针异常
if(pHead == null)
return null;
ListNode voidHead = new ListNode(0);
voidHead.next = pHead;
ListNode pre = voidHead;
ListNode cur = pHead;
while(cur.next != null){
ListNode next = cur.next;
if(next.val != cur.val){
cur = cur.next;
pre = pre.next;
}else{
while(next != null && next.val == cur.val){
next = next.next;
}
pre.next = next;
cur = pre.next;
}
if(cur == null)
break;
}
return voidHead.next;
}
}
寻找环的入口
题目大意：给出一个链表，判断其是否有环，如有的话返回环的入口，没有则返回null。
错误原因：在快慢指针重新从头出发的时候没有初始化慢指针。
/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ListNode EntryNodeOfLoop(ListNode pHead)
{
ListNode fast = pHead.next;
ListNode slow = pHead;
while(slow != null && fast != null){
//找到环了
if(slow == fast){
int count = 1;
slow = slow.next;
while(slow != fast){
count++;
slow = slow.next;
}
fast = pHead;
//这里忘记初始化了，导致死循环
slow = pHead;
while(count-- >0){
fast = fast.next;
}
while(fast != slow){
fast = fast.next;
slow = slow.next;
}
return slow;
}else{
slow = slow.next;
fast = fast.next;
if(fast != null)
fast = fast.next;
else
return null;
}
}
return null;
}
}
表示数值的字符串
题目大意：
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。
例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。
但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。
错误原因：忘记判断当字符为其他字符的情况。
public class Solution {
public boolean isNumeric(char[] str) {
if(str == null || str.length == 0)
return false;
int index = 0;
boolean numFlag = false;
boolean dotFlag = false;
boolean eFlag = false;
for(int i=0;i<str.length;i++){
char c = str[i];
if(c == '+' || c == '-'){
if(i == 0 || str[i-1] == 'e' || str[i-1] == 'E')
continue;
else
return false;
}
else if(c >= '0' && c<= '9'){
numFlag = true;
continue;
}
else if(c == '.'){
if(dotFlag || eFlag)
return false;
else{
dotFlag = true;
continue;
}
}
else if(c == 'e' || c == 'E'){
if(eFlag)
return false;
else{
eFlag = true;
numFlag = false;
}
}
//忘记考虑当前字符既不是.也不是e也不是+和数字了
//导致测试用例1a3.14没有通过。
//所以分情况讨论的题目一定要把测试用例中的所有情况列出来
else {
return false;
}
}
return numFlag;
}
}
正则匹配字符串
题目大意：
请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。
在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配。
错误原因：数组越界，做的太慢。虽然两次过了，但是做了20多分钟，等于没做出来。谁叫这道题要分类讨论呢，每次看到就瑟瑟发抖感觉都有心理阴影了。
更新：没想到6月20日的每日一题是这道题，那么错哪了呢？数组开小了，dp[][]的长宽应该是对应字符串的长宽+1.
public class Solution {
public boolean match(char[] str, char[] pattern)
{
if(str == null && pattern == null)
return true;
if(str == null || pattern == null)
return false;
//初始化一个dp数组，dp[i][j]代表的是s[i-1]和p[j-1]的情况。
boolean[][] dp = new boolean[str.length+1][pattern.length+1];
dp[0][0] = true;
for(int i=0;i<pattern.length+1;i++){
//问题出在这里一开始写的pattern[i]，所以越界了
//自己上面都写了j代表patter[j-1]居然还写错，不太应该
if( i > 1 && pattern[i-1] == '*')
//这里一开始也写错了，写成了patter[i] = patter[i-2]
//这居然都没有发现，还好错误在数组越界的附近，所以看到了
dp[0][i] = dp[0][i-2];
}
for(int i=1;i<str.length+1;i++){
for(int j=1;j<pattern.length+1;j++){
if(pattern[j-1] != '*'){
if(pattern[j-1] == '.' || pattern[j-1] == str[i-1]){
dp[i][j] = dp[i-1][j-1];
}else{
dp[i][j] = false;
}
}else{
//当前字符与*前面的字符相同，这个时候可以把str中的字符向前移动一位
if(str[i-1] == pattern[j-2] || pattern[j-2] == '.')
dp[i][j] |= dp[i-1][j];
//无论相同还是不同都可以无视后面两位，直接把p中字符向前移动两位
dp[i][j] |= dp[i][j-2];
}
}
}
return dp[str.length][pattern.length];
}
}
把字符串转化为整数
题目大意：将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
错误原因：字符串数组初始化错误；没有考虑负数的情况。
public class Solution {
public int StrToInt(String str) {
if(str == null || str.length() == 0)
return 0;
int res = 0;
boolean flag = false;
//这里一开始写成了new char[]，出了错我还一脸懵逼
//一定是我写的时候被笔试邮件分神了。
char[] chars = str.toCharArray();
for(int i=0;i<chars.length;i++){
if(chars[i] == '+' || chars[i] == '-'){
if(i!=0)
return 0;
if(chars[i] == '-')
flag = true;
}
else if(chars[i] >= '0' && chars[i] <= '9'){
res = res*10 + chars[i] - '0';
}
else{
return 0;
}
}
//一开始忘记判断是负数了
return flag?-res:res;
}
}
不用加减乘除做加法
题目大意：不用加减乘除做加法
错误原因：忘记怎么做了。。。。这么短的代码你也能忘？
public class Solution {
public int Add(int num1,int num2) {
while(num2 != 0){
//这里应该先计算出进位然后右移
int tmp = (num1&num2)<<1;
//计算出当前不用进位的和
num1 = num1 ^ num2;
//把进位当加数进行下一次循环
num2 = tmp;
}
return num1;
}
}
约瑟夫环
题目：总之就是约瑟夫环
错误：又双叒叕忘了。
这次记好了，递推公式为ans = (ans+m)% i (2<=i<=n)。
代码：
public int LastRemaining_Solution(int n, int m) {
if(n == 0 || m == 0)
return -1;
int ans = 0;
// 最后一轮剩下2个人，所以从2开始反推
for (int i = 2; i <= n; i++) {
ans = (ans + m) % i;
}
return ans;
}
翻转单词顺序列
题目大意：逆转一个字符串。
错误原因：
万万没想到这道题和leetcode上不一样，还稍微简单一些。
牛客上的题目不需要把多个连续空格取去除。
public class Solution {
public String ReverseSentence(String str) {
if(str == null || str.length() == 0)
return "";
//注意处理一下" "情况，按照牛客的要求应该返回" "
if(str.trim().equals(""))
return str;
String[] strings = str.trim().split(" ");
StringBuilder sb = new StringBuilder();
for(int i=strings.length-1;i>=0;i--){
if(i != 0)
sb.append(strings[i]).append(" ");
else
sb.append(strings[i]);
}
return sb.toString();
}
}
和为S的连续序列
题目大意：给出一个整数S，求所有和为S的连续整数序列。
错误原因：搞错了sum变化的时机。
import java.util.ArrayList;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer>> res = new ArrayList<>();
if(sum <= 2)
return res;
int limit = (sum+1)/2;
int left = 1;
int right = 2;
int target = sum;
sum = 3;
while(left < right && right <= limit){
//一开始的时候把sum初始化为1，在这里sum += right;
//这样的话有一个问题，即使移动的是左边界，sum也会执行一次+=right
//显然是错误的。
if(sum == target){
ArrayList<Integer> tmp = new ArrayList<>();
for(int i=left;i<right+1;i++){
tmp.add(i);
}
res.add(tmp);
sum -= left;
left++;
}
else if(sum < target){
right++;
//刚开这里写错了
sum += right;
}
else if(sum > target){
sum -= left;
left++;
}
}
return res;
}
}
数组中只出现一次的数字
题目大意：给出一个数组，每个数字都出现两次，只有两个数字只出现一个次，找出这两个数字。
错误原因：
其实这道题也是老朋友了，结果还是没有能够一次过。
在找两个数字异或和哪一位为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 < 2)
return;
int sum = 0;
for(int i=0;i<array.length;i++){
sum ^= array[i];
}
int digit =1;
if(sum == 0)
return;
while(true){
//错误出现在这里，一开始我写成了(sum&digit) == 1
//这样会导致只有当最后一位为1的才会退
if((sum&digit) == digit)
break;
else
digit <<= 1;
}
int sum1 =0;
int sum2 =0;
for(int i=0;i<array.length;i++){
if((array[i]&digit) == digit)
sum1 ^= array[i];
else
sum2 ^= array[i];
}
num1[0] = sum1;
num2[0] = sum2;
}
}
后记
这一轮暂时先做到这边，虽然很多题目都已经做过好几遍了，但是还是出了不少差错。
事实证明了一句话“思想很简单，细节是魔鬼”。对于做过好几次的题也不能掉以轻心，还是要多加练习。比如今天做的正则匹配，怎么会忘记字符串比较的题目需要把DP长度多开一位呢？
接下来两天先好好复习一下之前的知识点，先从JAVA基础开始吧。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
