本文解析了五道编程面试题，涉及除法优化、不使用特定运算符的计算、二进制字符串处理、整数中1的个数计数以及字符串字符匹配的高效方法，展示了在不同场景下的算法设计与优化技巧。
面试题1：
分析：
-
这个题目限制我们不能使用乘号和除号、求余号进行运算。所以我们选择用减法实现除法。
-
但是当被除数太大并且除数太小会导致执行次数太多，效率太低。我们需要优化该解法，当被除数大于除数时，继续比较被除数是否大于除数的2倍，如果是，重复该操作，就可以将时间复杂化度提升到O（logn）。
-
上述讨论被除数和除数都是正整数，当有负数时则可以将它们先转正数再进行计算，将负数转为正数之前我们知道int类型的取值范围在(-231,231-1)，所以直接将负数转为正数可能出溢出。
源代码
class Solution {
public int divide(int dividend, int divisor) {
//排除（-2^31）/（-1）的情况
if(dividend == 0x80000000 && divisor == -1){
return Integer.MAX_VALUE;
}
//用于判断商的正负:1为负，其他情况为正
int symbol = 2;
if(dividend > 0){
symbol--;
dividend = -dividend;
}
if(divisor > 0){
symbol--;
divisor = -divisor;
}
int result = divideCore(dividend,divisor);
return symbol == 1 ? -result:result;
}
private int divideCore(int dividend, int divisor){
int result = 0;
//当被除数小于等于除数的时候进入循环
while(dividend <= divisor){
int value = divisor;
int quotient = 1;
//0xc0000000是0x80000000的一半也就是（-2^30）、因为不能使用*，故选择value + value来使除数加倍
while(value >= 0xc0000000 && dividend <= value + value){
quotient += quotient;
value += value;
}
result += quotient;
divisor -= value;
}
return result;
}
}
面试题2：
分析：
不少人看到这道题的第一反应是将二进制字符串转为int型整数或者long型整数（我也是），然后把两个整数相加后转回二进制字符串。但是一旦二进制字符串太长它表示的整数就可能超出int型整数或者long型整数的范围。因此加法操作只能针对两个字符串进行。
源代码
class Solution {
public String addBinary(String a, String b) {
//每个字符串的长度
int i = a.length()-1;
int j = b.length()-1;
//保留进位值，逢二进一
int carry = 0;
StringBuilder result = new StringBuilder();
//当两个字符串长度同时减为0时循环结束
while(i >= 0 || j >= 0){
//当出现i的长度大于j时将对j的前面进行补0，反之亦然。
int digitA = i >= 0 ? a.charAt(i--)-'0' : 0;
int digitB = j >= 0 ? b.charAt(j--)-'0' : 0;
//计算当前位数的值
int sum = digitA + digitB + carry;
carry = sum >= 2 ? 1 : 0;
sum = sum >= 2 ? sum - 2 : sum;
result.append(sum);
}
if(carry == 1){
result.append(1);
}
return result.reverse().toString();
}
}
面试题3：
分析：
计算整数i的二进制形式中的1的个数有多种不同的方法，比如暴力破解将整数转为二进制字符串再一个一个遍历计算出来，但是效率太低了，有一种比较高效的方法是每次用 “i & （i-1）”将整数i的最右边的1变成0.整数i减去1，那么它最右边的1变为0.如果它的右边还有0，则右边所有的0都变成1，而其左边所有位都保存不变。例如：1100 & 1011 = 1000，每进行一次“i & （i-1）”便增加1，以此来计算1的个数。
源代码
class Solution {
public int[] countBits(int n) {
int[] arr = new int[n+1];
for(int i = 1;i <= n;i++){
int j = i;
while(j > 0){
j = j & (j-1);
arr[i]++;
}
}
return arr;
}
}
第一种思路：
如果一个整数共有k位，那么它的二进制形式中可能有O（k）个1.在上述代码中，while循环中的代码对每个整数将执行O（k）次，因此时间复杂度将达到O（nk）。根据前面分析可知，整数i的二进制形式中1的个数比“ i&（i-1）”的二进制形式中1的个数多1.
源代码
class Solution {
public int[] countBits(int n) {
int[] arr = new int[n+1];
for(int i = 1;i <= n;i++){
arr[i] = arr[i & (i-1)] + 1;
}
return arr;
}
}
该方法时间复杂度为O（n）。
第二种思路：
正整数i为一个偶数，那么i相当于i/2左移1位，因此i与i/2的二进制形式中1的个数是相同的。如果i是奇数，那么i相当于i/2左移1位之后再将最右边一位设为1是相同的，例如：6的二进制形式中1的个数等于3的二进制形式中1的个数，7的二进制形式中1的个数等于3的二进制形式中1的个数增加1。
源代码
class Solution {
public int[] countBits(int n) {
int[] arr = new int[n+1];
for(int i = 1;i <= n;i++){
if(i % 2 == 0){
arr[i] = arr[i >> 1];
}else{
arr[i] = arr[i >> 1] + 1;
}
}
return arr;
}
}
面试题4：
分析：
- 我们知道任何一个数字异或它本身的结果都是0.如果将数组中所有数字进行异或运算，那么最终的结果就是那个只出现一次的数字。但是这个题目是只有一个数字出现了一次，其他数字出现了3次。因此进行异或运算不能消除出现3次的数字。
- 一个整数是有32个0或1组成。我们可以将数组中所有数字的同一位置的数位相加。如果将所有数字的第i个的数位都相加起来，除于3，如果能整除则只出现一次的第i个数位一定是0，如果余1，则只出现一次的第i个数位一定是1，当我们知道一个整数任意一位是0还是1之后，我们就可以知道它的数值了。
源代码
class Solution {
public int singleNumber(int[] nums) {
int[] bigNum = new int[32];
for(int num:nums){
for(int i = 0;i < 32;i++){
bigNum[i] += (num >> (31-i)) & 1;
}
}
int result = 0;
for(int i = 0;i < 32;i++){
result = (result << 1) + bigNum[i] % 3;
}
return result;
}
}
面试题5：
分析：
- 解决这个问题的关键在于如何判断两个字符串str1和str2中是否有相同的字符。一个比较直观的想法就是基于字符串str1中每个字符ch，并且扫描字符串str2判断字符ch是否出现在str2中。如果两个字符串的长度分别为p和q，这种暴力破解的时间复杂度O（pq）。
- 使用哈希表优化时间效率，对于每个哈希表记录出现在该字符串中的所有字符。再判断两个字符串str1和str2中没有相同的字符时，只需要从‘a’到’z‘判断某个字符是否在两个字符串对应的哈希表中都出现了。该时间复杂度为O（1）。
源代码
class Solution {
public int maxProduct(String[] words) {
boolean[][] bl = new boolean[words.length][26];
for(int i = 0;i < words.length;i++){
for(char c:words[i].toCharArray()){
bl[i][c - 'a'] = true;
}
}
int max = 0;
for(int i = 0;i < words.length;i++){
for(int j = i+1;j < words.length;j++){
int k = 0;
for(;k < 26;k++){
if(bl[i][k] && bl[j][k]){
break;
}
}
if(k == 26){
max = Math.max(max,words[i].length() * words[j].length());
}
}
}
return max;
}
}
思路：
前面解法用布尔型数组记录字符串中出现的字符。布尔值只有两种可能，要么是true，要么是false。这与二进制差不多，二进制也只有两种，要么是1，要么是0，二进制有32位，字母只有26位，所以完全可以使用二进制形式代替布尔型数组，进行压缩。
class Solution {
public int maxProduct(String[] words) {
int[] arr = new int[words.length];
for(int i = 0;i < words.length;i++){
for(char c:words[i].toCharArray()){
//注意这里是|=,为什么呢，因为如果是”=“的话，那么就不能实现26数位的叠加，因为会被”=“覆盖。
//如果其他的，就出现如字符串为“aaa”时，就是出现0001（前面的0省略）+0001的叠加导致逢二进一，从而打乱我们的布局。
arr[i] |= (1 << (c-'a'));
}
}
int max = 0;
for(int i = 0;i < words.length;i++){
for(int j = i+1;j < words.length;j++){
if((arr[i] & arr[j]) == 0){
max = Math.max(max,words[i].length() * words[j].length());
}
}
}
return max;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
