移除元素
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:
给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
分析：
用一个index标记当前真正的位置，在遍历的过程中如果当前位置数值和目标数值不相等那么就赋值，如果和待删除数据相等那么跳过不赋值。这就是遍历一次重新赋值的过程。
ac代码为：
public int removeElement(int[] nums, int val) { int index=0; for(int i=0;i<nums.length;i++) { if(nums[i]==val) continue; nums[index++]=nums[i]; } return index; }
实现 strStr()
题目描述：
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
示例 1:
输入: haystack = “hello”, needle = “ll”
输出: 2
示例 2:
输入: haystack = “aaaaa”, needle = “bba”
输出: -1
说明:
当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。
对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符
分析
由于数据量的问题，本题使用KMP算法效率并不是很好(KMP需要预处理)，相反使用普通方法效率就很高.使用sunday算法效果也比较普通，就很神奇。
普通的匹配又称双指针啥的其实就是一个暴力匹配，但是同为暴力匹配官方给的方法速度要快很多，个人写法为：
public int strStr(String haystack, String needle) { if(needle==null||"".equals(needle)) return 0; char a[]=haystack.toCharArray(); char b[]=needle.toCharArray(); for(int i=0;i<a.length-b.length+1;i++) { int j=-1; while(j++<b.length) { if(a[i+j]!=b[j]) { break; } if(j==b.length-1) return i; } } return -1; }
官方给的简洁写法：
public int strStr(String haystack, String needle) { int L = needle.length(), n = haystack.length(); for (int start = 0; start < n - L + 1; ++start) { if (haystack.substring(start, start + L).equals(needle)) { return start; } } return -1; }
kmp方法笔者也实现了，但是由于数据问题效果一般般，当然kmp算法这里就不作详细介绍：
public int[] getNext(String needle) { char[] p = needle.toCharArray(); int[] next = new int[p.length]; next[0] = -1; int j = 0; int k = -1; while (j < p.length - 1) { if (k == -1 || p[j] == p[k]) { next[++j] = ++k; } else { k = next[k]; } } return next; } public int KMP(String haystack, String needle) { char[] t = haystack.toCharArray(); char[] p = needle.toCharArray(); int i = 0; // 主串的位置 int j = 0; // 模式串的位置 int[] next = getNext(needle); while (i < t.length && j < p.length) { if (j == -1 || t[i] == p[j]) { // 当j为-1时，要移动的是i，当然j也要归0 i++; j++; } else { // i不需要回溯了 // i = i - j + 1; j = next[j]; // j回到指定位置 } if(j==p.length) {return i-j;} } return -1; } public int strStr(String haystack, String needle) { if(needle==null||"".equals(needle)) return 0; return KMP(haystack, needle); }
同样使用sunday算法 (后面会专门讲解)效果也是一般般
public int strStr(String haystack, String needle) { if(needle==null||"".equals(needle)) return 0; int lastchar[]=new int [200]; char a[]=haystack.toCharArray(); char p[]=needle.toCharArray(); for(int i=0;i<p.length;i++) { lastchar[p[i]]=i+1; } int i=0; int j=0; int len=a.length-p.length+1; while (i<a.length) { int index=i-(lastchar[a[i]]-1);//a[i] 字符 if(lastchar[a[i]]!=0&&index>=0&&index<len)//可以匹配 { while (j<p.length) {//尝试匹配 if(p[j]!=a[index+j]) break; j++; } if(j==p.length) { return index; } else { i=index+p.length; j=0; } } else { i++; } } return -1; }
两数相除
题目描述
给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
返回被除数 dividend 除以除数 divisor 得到的商。
整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2
示例 1:
输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333…) = truncate(3) = 3
示例 2:
输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = truncate(-2.33333…) = -2
提示：
被除数和除数均为 32 位有符号整数。
除数不为 0。
假设我们的环境只能存储 32 位有符号整数，其数值范围是
[−2^31, 2^31 − 1]。本题中，如果除法结果溢出，则返回2^31 − 1。
分析
需要计算除法的数值是多少，并且还遇到以下问题：
- 数值可能越界
- 不能使用乘除法
数值越界问题可以特殊情况考虑即可。但是不能使用乘除法怎么去知道除法的结果是多少呢？
法一：加法累加
这可能是最笨的方法了，除以几，就用这个数去叠加找到结果。
当然这样如果数字很大，除数为1，2这种的会很慢，只能勉强ac。
public static int divide(int dividend, int divisor) { int zhengfu=1; long divd=dividend,divs=divisor; if(dividend>0&&divisor<0) { divs=-divisor;zhengfu=-1; } else if(dividend<0&&divisor>0) { divd=-divd;zhengfu=-1; } else if (dividend<0&&divisor<0) { divd=-divd;divs=-divs; } if(Math.abs(divd)<Math.abs(divs))return 0; long i=0,index=0; if(divs==1)i=divd+1; else while (index<=divd) { i++;index+=divs; } long va=(zhengfu==1?(i-1):(1-i)); if(va>Integer.MAX_VALUE)return Integer.MAX_VALUE; if(va<Integer.MIN_VALUE)return Integer.MIN_VALUE; return (int) va; }
用什么方法可以优化算法呢？这就涉及到二进制的问题了。在二进制中：
- 2=0010 表示有2个1
- 4=0100表示有4个1
- 6=0110表示有4+2个1
同样任何一个数都可以用二进制来表示，1101表示8+4+1.同理我们将这种思想带到本题进行计算，只不过基础单位不为1而已：
因为我们使用加法实现数值乘以二的效果，所以利用这个每次找到范围内的最大个数(数值叠加同时需要其他变量统计次数)。然后处理完这部分数据继续操作剩下的数值直到停止。当然具体实现上可以考虑剪枝(除数为±1的时候，同时要妥善解决正负数和越界问题，这里就用long处理，全部转成正数然后用一个标记正负)。
实现代码为：
public static int divide(int dividend, int divisor) { if(divisor==1)return dividend; if(divisor==-1)return dividend==Integer.MIN_VALUE?Integer.MAX_VALUE:-dividend; long value=0;//记录总次数结果 int time=1;//临时每次的次数 long divd=dividend,divs=divisor;//转成long处理 int zhengfu=1;//判断是正数还是负数 if(divd<0) { divd=-divd;zhengfu=-zhengfu; } if(divs<0) { divs=-divs;zhengfu=-zhengfu; } long team=divs;//临时数据2倍叠加 while (team<=divd) { if(team+team>divd) { value+=time; divd-=team; team=divs; time=1; continue; } team+=team; time+=time; } return (int) (zhengfu==1?value:-value); }
结语
好吧，本次打卡结束，欢迎点赞支持，如果打卡欢迎关注公众号bigsai回复进群即可加入打卡。
