Nodejs 面试题,欢迎解答

Nodejs 面试题,欢迎解答

var a = ‘lkjgfaoids’; var b = ‘adk’;

问题: 判断出字符串 b 中的每一个字符,在 a 中是否存在。

这是一个性能优化题,下面的解法性能不够,请提出更好的方案。

解法一:

var as = a.split(’’);

var bs = b.split(’’);

for(var i in as){

for(var k in bs){ if(as[i]==bs[k]){ … } } }

解法二:

var bs = b.split(’’); for(var i in bs){ if(a.indexOf(bs[i])){ … } }


21 回复

Node.js 面试题:字符串字符存在性判断

问题描述

给定两个字符串 ab,判断字符串 b 中的每一个字符是否存在于字符串 a 中。

var a = 'lkjgfaoids';
var b = 'adk';

解法一:双重循环(性能不佳)

以下是原始的双重循环解法:

var a = 'lkjgfaoids';
var b = 'adk';

var as = a.split('');
var bs = b.split('');

for (var i in as) {
    for (var k in bs) {
        if (as[i] === bs[k]) {
            console.log('Character ' + bs[k] + ' exists in string a');
        }
    }
}

问题:这种解法的时间复杂度为 O(n * m),其中 n 是字符串 a 的长度,m 是字符串 b 的长度。这会导致性能低下,特别是在处理较长的字符串时。

解法二:使用 indexOf 方法(性能有所提升)

改进的方法是使用 String.prototype.indexOf 方法来查找字符是否存在:

var a = 'lkjgfaoids';
var b = 'adk';

var bs = b.split('');

for (var i in bs) {
    if (a.indexOf(bs[i]) !== -1) {
        console.log('Character ' + bs[i] + ' exists in string a');
    }
}

问题:虽然这种方法避免了双重循环,但 indexOf 方法仍然需要遍历整个字符串 a 来查找每个字符。因此,时间复杂度仍然是 O(n * m)。

最佳解法:使用哈希表(时间复杂度为 O(n + m))

为了进一步提高性能,我们可以使用哈希表(对象)来存储字符串 a 中的所有字符,并通过一次遍历来检查字符串 b 中的字符是否存在于哈希表中:

var a = 'lkjgfaoids';
var b = 'adk';

// 创建一个哈希表来存储字符串 a 中的字符
var charMap = {};

// 将字符串 a 中的每个字符添加到哈希表中
for (var i = 0; i < a.length; i++) {
    charMap[a[i]] = true;
}

// 检查字符串 b 中的每个字符是否存在于哈希表中
var bs = b.split('');
for (var i = 0; i < bs.length; i++) {
    if (charMap[bs[i]]) {
        console.log('Character ' + bs[i] + ' exists in string a');
    }
}

解释

  • 使用哈希表存储字符串 a 中的字符可以将查找时间从 O(n) 降低到 O(1)。
  • 时间复杂度为 O(n + m),其中 n 是字符串 a 的长度,m 是字符串 b 的长度。
  • 这种方法显著提高了性能,尤其是在处理长字符串时。

通过这种方式,我们可以在较短的时间内高效地完成字符存在性的判断。


有个思路是 先排序,再进行比较, 一次循环就能算出结果

for (var i in a) { console.log(b.indexOf(a[i])) }

我太坏了

这样呢?


   b.split('').forEach(function(item){
    if(a.localeCompare(item)){
     console.log('%s exits', item);
    }
   });

var map_arr = [] for(var i=0;i<a.length;++i) map_arr[a[i]]=1 for(var i=0;i<b.length;++i) if(map_arr[b[i]]) return true return false 随便写了伪代码,求工作介绍

这个思路真心不错 看过类似的

可以再优化,外层定义一个数组,初始化为空,,在if里面判断数组中是否存在当前变量a[i],如果存在则说明已经检测过,忽略,否则,添加到数组中,并检查b中是否存在。

en,…看错题意了,是判断每一个…所以if里面要改

把一个o^2的循环转成2o 优化了不少

我也是用这种类似桶排的方法 0. 0

取交集不就行了吗。。

用正则表达式吧,它是c直接扩展的,性能高,把b中的字符在a中替换成空,通过长度的变化知道是否在a中出现,不过这样改变了a的值,不知道能否满足你的需求。

如果在a很长的情况下,js的循环肯定没有c的效率高,而且替换成空还有个好处,a的长度会越来越短,循环的次数也会越来越少,性能就越高

”通过长度的变化知道是否在a中出现“

可行??我认为不行啊

var a = ‘lkjgfaoids’; var b = ‘adk’;

问题: 判断出字符串 b 中的每一个字符,在 a 中是否存在。 解法:

var bs = b.split(’’);

if(a.indexOf(bs[0])){ … }

if(a.indexOf(bs[1])){ … }

if(a.indexOf(bs[2])){ … }

只有三个字母,所以不用循环。还请大家指教。

var str = ‘lkjgfaoids’; var reg = /[adk]/g; var result = reg.exec(str); if(result.length === 3) { return true; }

 var reg=new RegExp(b,'g');
 return reg.test(a);

没测试过性能 var a = ‘lkjgfaoids’; var b = ‘adk’; var aa = a.split(’’).sort().join(’’); var bb = b.split(’’).sort(); var reg = new RegExp(bb.join(’.*’)); console.log(reg.test(aa));

var a = ‘lkjgfaoids’; var b = ‘adk’; for(var i = 0, len = b.length; i < len; i++) { a.indexOf(b.charAt(i)) > -1 && console.log(b.charAt(i)); }

虽然有点长,但是题中的应该是够用的 var findChar = (function() { if(typeof Array.prototype.forEach !== “function”) { Array.prototype.forEach = function(callback, thisArgs) { if(typeof callback !== “function”) { throw new TypeError(‘type error’); } var len = this.length, _this = thisArgs || window; for(var i =0; i < len; i++) { callback.call(_this, this[i], i, this); } } } function find(ori, des) { var desArr = []; //slice方法 for (var i = 0,j = des.length; i < j; i++) { desArr.push(des.charAt(i)); } desArr.forEach(function(val) { if(ori.indexOf(val) > -1) { //… } }) } return find; })(); findChar(‘lkjgfaoids’, ‘adk’);

为了判断字符串 b 中的每一个字符是否在字符串 a 中存在,并且提供一个性能更优的解决方案,我们可以采用一种更为高效的方法。当前提供的两种方法中,解法一是双重循环,时间复杂度为 O(n * m),其中 n 和 m 分别是字符串 a 和 b 的长度;解法二是使用 indexOf 方法,但它的性能也不是最优。

一个更优的方案是先将字符串 a 转换成一个集合(例如一个对象或者 Map),然后通过检查字符串 b 中的每个字符是否在这个集合中存在。这种方法的时间复杂度接近于 O(n + m),因为构建集合的操作是线性的。

示例代码:

const a = 'lkjgfaoids';
const b = 'adk';

// 将字符串 a 转换为集合
const setA = new Set(a.split(''));

// 检查字符串 b 中的每一个字符是否在集合中存在
const bs = b.split('');
let allCharsExist = true;

for (const char of bs) {
    if (!setA.has(char)) {
        allCharsExist = false;
        break;
    }
}

console.log(allCharsExist); // 输出结果

解释:

  1. 使用 Set 数据结构来存储字符串 a 中的每个字符。Set 是一种集合,它自动去重,且可以高效地进行成员检测。
  2. 将字符串 b 也转换成一个数组,遍历该数组中的每个字符,检查这些字符是否存在于 Set 中。
  3. 如果所有字符都存在,则 allCharsExist 保持为 true,否则变为 false

这种解决方案比原始的解法一和解法二更为高效,因为它避免了不必要的重复计算和嵌套循环。

回到顶部