在javascript中，如何返回时间复杂度为O（n）的相同字母元素？

我正在尝试解决一个时间复杂度较低的问题，在本例中是

O（n）

问题是：

let arr = ['dog', 'come', 'ogd', 'something', 'emoc'];

它应该会回来

[['dog', 'ogd], ['come', 'emoc']]; // which same using letters

到目前为止，我用两个函数解决了这个问题，它工作得很好，但我的是嵌套循环，它将给我

O（n2）

这是我的密码

const isSameChars = (str1, str2) => {
  let str1sorted = str1.split("").sort().join("");
  let str2sorted = str2.split("").sort().join("");
  if (str1.length !== str2.length) {
    return false;
  }
  for (var i = 0; i < str1sorted.length; i++) {
    let char1 = str1sorted[i];
    let char2 = str2sorted[i];
    if (char1 !== char2) {
      return false;
    }
  }
  return true;
}

const isSameCharElements = (arr) => {
  let result = [];
  for(var i = 0; i < arr.length; i++) {
    for(var j = 0; j < i; j++) {
      if (isSameChars(arr[i], arr[j]) === true) {
        result.push(arr[j])
      }
    }
  }
  return result; 
}

console.log(isSameCharElements(['dog', 'come', 'ogd', 'something', 
'emoc'])) //  [['dog', 'ogd], ['come', 'emoc']]

const isSameChars=（str1，str2）=>{
让str1sorted=str1.split（“”.sort（）.join（“”）；
让str2sorted=str2.split（“”.sort（）.join（“”）；
if（str1.length！==str2.length）{
返回false；
}
对于（变量i=0；i{
让结果=[]；
对于（变量i=0；i

有没有办法用

O（n）

时间复杂度来解决这个问题

---

谢谢你的预付款

通过对字母进行排序，您可以获得任何字符串的“字母袋”表示：

function sortLetters(word){
  return word.split('').sort().join('');
}

然后，您可以迭代输入，将具有相同字母袋表示的单词分组到一个对象中：

const grouped = arr.reduce(function (m, word) {
  var bagRepr = sortLetters(word);
  var withSameLetters =  m[bagRepr] || [];
  withSameLetters.push(word);
  m[bagRepr] = withSameLetters;
  return m;
}, {});

const result = Object.values(grouped)
  .filter(function (arr) {
    return arr.length > 1;  
  });

这是O（n），前提是

sortLetters（）

是O（1），如果单词长度由一个常数限定，则是这种情况

---

免责声明：请注意，我们这里只讨论渐进复杂性-这并不意味着从实用角度来看，这种方法是最有效的

通过对字母进行排序，您可以获得任何字符串的“字母袋”表示：

function sortLetters(word){
  return word.split('').sort().join('');
}

然后，您可以迭代输入，将具有相同字母袋表示的单词分组到一个对象中：

const grouped = arr.reduce(function (m, word) {
  var bagRepr = sortLetters(word);
  var withSameLetters =  m[bagRepr] || [];
  withSameLetters.push(word);
  m[bagRepr] = withSameLetters;
  return m;
}, {});

const result = Object.values(grouped)
  .filter(function (arr) {
    return arr.length > 1;  
  });

这是O（n），前提是

sortLetters（）

是O（1），如果单词长度由一个常数限定，则是这种情况

---

免责声明：请注意，我们这里只讨论渐进复杂性-这并不意味着从实用角度来看，这种方法是最有效的

所以，给你们的问题定义多一点。其思想是采用一个数组，即为每个项目搜索数组的其余部分，以查找具有所有相同字母的单词。然后删除这两个并将其添加到结果中？我不认为你会把这个问题搞清楚，单词的首字母和末字母总是匹配的吗？所以，请你再定义一下这个问题。其思想是采用一个数组，即为每个项目搜索数组的其余部分，以查找具有所有相同字母的单词。然后删除这两个并将其添加到结果中？我认为你永远也不会做到

o（n）

单词的首字母和末字母总是匹配吗？从技术上讲，你需要删除不属于一对的项目才能得到OP想要的输出。您的输出中仍然会有

内容。迭代删除这些项目将是
O（n）
。此外，如果输入包括
come
、
emoc
和
moce
，OP预期会发生什么也不清楚。那应该只有一双吗？还是全部三个？还是别的什么？@ZohirSalakCeNa:
sortLetters
本身绝对不是
O（1）
。但是如果
n
是
arr
的大小，那么它就是。因为我们将时间复杂度视为
arr
大小的函数，而不是字符串本身长度的函数。@MattBurland哦，对了，我添加了一个过滤阶段。仍然是O（n）。@ZohirSalakCeNa如果单词的长度以常数为界，那么sortLetters（）就是O（1）。更一般地说，对有界数组进行排序是O（1）。从技术上讲，您需要删除不属于一对的项，以获得OP想要的输出。您的输出中仍然会有
内容。迭代删除这些项目将是
O（n）
。此外，如果输入包括
come
、
emoc
和
moce
，OP预期会发生什么也不清楚。那应该只有一双吗？还是全部三个？还是别的什么？@ZohirSalakCeNa:
sortLetters
本身绝对不是
O（1）
。但是如果
n
是
arr
的大小，那么它就是。因为我们将时间复杂度视为
arr
大小的函数，而不是字符串本身长度的函数。@MattBurland哦，对了，我添加了一个过滤阶段。仍然是O（n）。@ZohirSalakCeNa如果单词的长度以常数为界，那么sortLetters（）就是O（1）。更一般地说，有界数组的排序是O（1）。