检查字符串中的字符是否都是唯一的

Checking if the characters in a string are all unique

本文关键字：唯一 是否 字符 字符串 检查      更新时间：2023-09-26

我正在尝试仅使用数组来使用JS解决此问题。

var str = 'abcdefgh';
for (i = 0; i < 255; i++) {
  arr[i] = false;
}
function check() {
  for (i = 0; i < str.length; i++) {
    if (arr[str.charCodeAt(i)] == true) {
      return false;
    }
    arr[str.charCodeAt(i)] = true;
  }
  return true;
}

我正在初始化一个固定大小为 256 的数组，以使布尔值false .然后，我将字符串中字符的相应 ASCII 索引的值设置为 true。如果我再次找到相同的角色，我将返回false.

在运行程序时，即使字符串没有任何重复字符，我也会收到 false 返回。

用所有字符填充Set，并将其大小与字符串的长度进行比较：

function isUnique(str) {
  return new Set(str).size == str.length;
}
console.log(isUnique('abc'));    // true
console.log(isUnique('abcabc')); // false

使用对象以获得更快的结果

function is_unique(str) {
  var obj = {};
  for (var z = 0; z < str.length; ++z) {
    var ch = str[z];
    if (obj[ch]) return false;
    obj[ch] = true;
  }
  return true;
}
console.log(is_unique("abcdefgh")); // true
console.log(is_unique("aa")); // false

对

每个字符使用 .match（） 函数。 使用长度计算出现次数。猜猜就是这样。

(str.match(/yourChar/g) || []).length

我们也可以尝试使用indexOf和lastIndexOf方法：

function stringIsUnique(input) {
  for (i = 0; i < input.length; i++) {
    if (input.indexOf(input[i]) !== input.lastIndexOf(input[i])) {
      return false;
    }
  }
  return true;
}

你正在使用arr[str.charCodeAt(i)]这是错误的。应该是arr[str[i].charCodeAt(0)] 

var arr = [];
var str="abcdefgh";
for (i=0;i<255;i++){
    arr[i]=false;
}
function check(){
    for (i=0;i<str.length;i++){
        if (arr[str[i].charCodeAt(0)]==true){
            return false;
        }
        arr[str[i].charCodeAt(0)]=true;
    }
    console.log(arr);
    return true;
}
check();

时间复杂度 = O（n）空间复杂度 = O（n） 

const isUnique = (str) => {
      let charCount = {};
      for(let i = 0; i < str.length; i++) {
        if(charCount[str[i]]){
          return false;
        }
        charCount[str[i]] = true;
      }
      return true;
    }

    const isUniqueCheekyVersion = (str) => {
      return new Set(str).size === str.length;
    }

解决方案 3： 将字符串转换为字符数组，对它们进行排序，然后遍历它们以检查相邻的元素，如果有匹配项返回 false 否则为 true

解决方案 4： 它类似于解决方案 1，除了我们使用在最新版本的 javascript 中引入的 Set 数据结构

// no additional Data structure is required. we can use naive solution
// Time Complexity:O(n^2)
function isUnique(str) {
  for (let i = 0; i < str.length; i++) {
    for (let j = 1 + i; j < str.length; j++) {
      if (str[i] === str[j]) {
        return false;
      }
    }
  }
  return true;
}
// if you can use additional Data structure 
// Time Complexity:O(n)
function isUniqueSecondMethos(str) {
  let dup_str = new Set();
  for (let i = 0; i < str.length; i++) {
    if (dup_str.has(str[i])) {
      return false;
    }
    dup_str.add(str[i]);
  }
  return true;
}
console.log(isUniqueSecondMethos('hello'));

使用对象作为映射器

function uniqueCharacterString(inputString) {
  const characterMap = {};
  let areCharactersUnique = true;
  inputString.trim().split("").map((ch)=>{
    if(characterMap[ch]===undefined) {
      characterMap[ch] = 1;
    } else {
      areCharactersUnique = false;
    }
  })
  return areCharactersUnique;
}

算法

*1. 步骤 -第一个字符串是 ->堆栈 *

*

2.步进字符串隐蔽到字符数组 *

3. 步骤 - 在数组 ['s'、't'、'a'、'c'、'k'] 中使用迭代

4. step - if（beginElement ！== nextElement）{return true}else{return false}

实现代码 

function uniqueChars(string){
var charArray = Array.from(string) //convert charArray
  for(var i=0;i<charArray.length;i++){
    if(charArray[i] !== charArray[i+1]){ 
      return true
    }
    else{
      return false
    }
  }
}
var string ="stack"
console.log(uniqueChars(string))

时间复杂度O（nlogn）

算法

  1. 计算字母的频率，例如 'Mozilla'将返回Object{ M: 1, o: 1, z: 1, i: 1, l: 2, a: 1 }.请注意，-~undefined 上的按位 NOT 运算符 （~） 是 1 ，-~1是 2 ，-~2是3等。
  2. 当所有匹配项仅出现一次时返回true。

实现代码 

var isUnique = (str) => {
  const hash = {};
  for (const key of str) {
    hash[key] = -~hash[key];
  }
  return Object.values(hash).every((t) => t === 1);
};
console.log(isUnique('Mozilla'));
console.log(isUnique('Firefox'));

<小时 />

另一种选择可能是：

var isUnique = (str) => {
  const hash = {};
  for (const i in str) {
    if (hash[str[i]]) return false;
    hash[str[i]] = true;
  }
  return true;
};
console.log(isUnique('Mozilla'));
console.log(isUnique('Firefox'));

要使一个高效，您可以使用 简单的哈希映射 

let isUnique = (s) => {
    let ar = [...s];
    let check = {};
    for (let a of ar) {
        if (!check[a]) {
            check[a] = 1;
        } else {
            return false
        }
    }
    return true;
}
alert("isUnique : "+isUnique("kailu"));

时间复杂度和空间复杂度

使用 ES6 

let isUnique = (s)=>{
   return new Set([...s]).size == s.length;
}
console.log("using ES6 : ",isUnique("kailu"));

我们可以使用字符串的拆分方法：

const checkString = (str) => {
let isUniq = true;
for (let i = 0; i < str.length; i++) {
  if (str.split(str[i]).length > 2) {
    isUniq = false;
    break;
  }
}
return isUniq;
};
console.log(checkString("abcdefgh")); //true
console.log(checkString("aa")); //false
相关文章：