Javascript 最长子字符串非重复字符

问题是“给定一个字符串，查找不带重复字符的最长非重复子字符串”。我有点困惑，为什么返回代码对字符串“dvdf”不起作用。这是我的密码：

function lengthOfLongestSubstring(check) {
    var letters = check.split("");
    var max = 0;
    var result = [];
    for (var i = 0; i < letters.length; i++) {
        var start = i
        if (result.indexOf(letters[i]) === -1) {
            result.push(letters[i])
        } else {
            i = i - 1
            result = []
        }
        if (max === 0 || max < result.length) {
            max = result.length
        }
    }
    return max
}

函数lengthOfLongestSubstring（检查）{
变量字母=支票。拆分（“”）；
var max=0；
var结果=[]；
对于（变量i=0；i

将i重置为i-1不正确。在for循环中需要另一个循环。您可以尝试这样的方法（我没有仔细检查索引）

函数lengthOfLongestSubstring（检查）{
变量字母=支票。拆分（“”）；
var max=0；
对于（变量i=0；imax）{
max=j-i；
}
}
返回最大值；
}

此实现为

“dvdf”

提供正确的结果

它向

当前_字符串添加字符，但不存在重复项。当您发现一个重复的剪切
当前_字符串
到重复点时
max
是当前字符串在任何时候的最大长度。这个逻辑对我来说似乎是正确的，所以我认为它是正确的

function lengthOfLongestSubstring(string) {
    var max = 0, current_string = "", i, char, pos;

    for (i = 0; i < string.length; i += 1) {
        char = string.charAt(i);
        pos = current_string.indexOf(char);
        if (pos !== -1) {
            // cut "dv" to "v" when you see another "d"
            current_string = current_string.substr(pos + 1);
        }
        current_string += char;
        max = Math.max(max, current_string.length);
    }
    return max;
}

lengthOfLongestSubstring("dvdf"); // 3

函数lengthOfLongestSubstring（字符串）{
var max=0，当前_字符串=”，i，char，pos；
对于（i=0；i

通过使用存储每个遇到字符的最后索引的映射替换
结果
数组，每一轮中
当前字符串的值为
，“d”，“dv”，“vd”，“vdf”
，您可以修改循环体，使其跳回相同字符的最后一个索引之后的循环体，并从那里继续搜索，而不是通过当前
i=i-1
从当前位置重新启动，该方法在
'dvdf'
等情况下失败：

下面是您的代码，其中进行了一些更改，以适应以地图代替阵列的情况：
函数lengthOfLongestSubstring（检查）{
变量字母=支票。拆分（“”）；
var max=0；
var result=newmap（）；
var start=0；
对于（变量i=0；iconsole.log（lengthOfLongestSubstring（“dvdf”）；//3
您可以尝试滑动窗口模式来解决此问题


函数lengthOfLongestSubstring（str）{
设最长=0；
让longestStr=“”；
让我们看看={}；
让start=0；
设next=0；
while（下一个”，longestStr，“->”，longest）；
返回时间最长；
}
长度长度子串（“DVDFEV”）；
lengthOfLongestSubstring（“你好”）；
lengthOfLongestSubstring（“1212312344”）使用Map方法查找最长的唯一子字符串

var str = "aaabcbdeaf";
var start = 0;
var map = new Map();
var maxLength = 0;
var longStr = '';

for(next =0; next< str.length ; next++){
if(map.has(str[next])){
  map.set(str[next],map.get(str[next])+1);
  start = Math.max(start,map.get(str[next]));
}
if(maxLength < next-start+1){
  maxLength = next-start+1;
  longStr = str.slice(start,next+1);
}
 map.set(str[next],next);
}
console.log(longStr);

var str=“aaabcbdeaf”；
var start=0；
var map=newmap（）；
var maxLength=0；
var longtr=''；
for（next=0；next
您可以尝试以下方法：


函数maxSubstring（s）{
常量数组=[]
常数长度=s长度
常量推送器=（值）=>{
如果（值！=''）{
如果（array.length>0）{
if（数组索引of（值）=-1）{
array.push（值）
}
}否则{
array.push（值）
}
}
}
推手
for（s.split（“”）.entries（）的常量[索引，值]）{
让长度=长度
设string=s
常数indexO=s.indexOf（值）
推进器（值）
while（长度>索引）{
推进器（串片（索引-1，长度+1））
长度=--长度
}
string=s.slice（索引，长度）
}
array.sort（）
返回数组.pop（）
}
log（maxSubstring（'banana'））
log（maxSubstring（'fgjashore'））
log（maxSubstring（'xyzabcd'））
这里有一个使用滑动窗口和HashMap的解决方案

var lengthOfLongestSubstring = function(str) {
  if (!!!str.length || typeof str !== 'string') return 0;

  if (str.length == 1) return 1;
  let hashTable = {};
  let longestSubstringLength = 0;
  let start = 0;
  for (let i = 0; i < str.length; i++) {
    if (hashTable[str[i]] !== undefined && hashTable[str[i]] >= start) {
      start = hashTable[str[i]] + 1;
    }
    hashTable[str[i]] = i;
    longestSubstringLength = Math.max(longestSubstringLength, (i - start + 1))
  }
  return longestSubstringLength;
}

var lengthOfLongestSubstring=函数（str）{
如果（！！！str.length | | typeof str！=='string'）返回0；
如果（str.length==1）返回1；
设hashTable={}；
设longestSubstringLength=0；
让start=0；
对于（设i=0；ivar lengthOfLongestSubstring = function(str) {
  if (!!!str.length || typeof str !== 'string') return 0;

  if (str.length == 1) return 1;
  let hashTable = {};
  let longestSubstringLength = 0;
  let start = 0;
  for (let i = 0; i < str.length; i++) {
    if (hashTable[str[i]] !== undefined && hashTable[str[i]] >= start) {
      start = hashTable[str[i]] + 1;
    }
    hashTable[str[i]] = i;
    longestSubstringLength = Math.max(longestSubstringLength, (i - start + 1))
  }
  return longestSubstringLength;
}

function lengthOfLongestSubstring(s: string): number {
    let stringLength = s.length;
    let maxLength = 0;
    const charMap = new Map();
    let pos = 0;

    for (let i = 0; i < stringLength; i++) {
        if (charMap.has(s[i])) {
            pos = Math.max(charMap.get(s[i]), pos);
        }

        maxLength = Math.max(maxLength, i - pos + 1);
        charMap.set(s[i], i + 1);
    }
    return maxLength;
}

console.log(lengthOfLongestSubstring("dvdf"));


function lengthOfLongestSubstring (str) {
  const map = new Map();
  let max = 0;
  let left = 0;
  for (let right = 0; right < str.length; right++) {
    const char = str[right];
    if (map.get(char) >= left) left = map.get(char) + 1;
    else max = Math.max(max, right - left + 1);
    map.set(char, right);
  }
  return max;
}

const string = "dvdf";

var lengthOfLongestSubstring = function() {
if(string.length == 1) return 1;
if(string.length == 0) return 0;

let max = 0,i =  0, str = "";

while(i < string.length){
    const index = str.indexOf(string.charAt(i));
    if(index > -1) {
        // s = "fiterm".slice(1,4) => ite
        str = str.slice(index + 1, string.length);
    }
    str += string.charAt(i);
    max = Math.max(str.length, max);
    i++;
}
  return max;
};