力扣练习题

49.字母异位词分组

strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
var groupAnagrams = function(strs) {
    var map=new Map();
    strs.forEach(item=>{  //数组里面原来的数据为item
        let temp=Array.from(item);  //排序后的为temp
        temp.sort();
        //把数组里面的每一项变成标准顺序排列[ 'a', 'e', 't' ][ 'a', 'e', 't' ][ 'a', 'n', 't' ][ 'a', 'e', 't' ][ 'a', 'n', 't' ][ 'a', 'b', 't' ]
        //console.log(temp)  //temp=[ 'a', 'e', 't' ]
        let key=temp.toString();  
        //console.log(key)   //key=a,e,t
        let list = map.get(key)?map.get(key):new Array();  //？  数组
        list.push(item);
        map.set(key,list);
    })
    
    /* 
    console.log(map)
    Map {
  'a,e,t' => [ 'eat', 'tea', 'ate' ],
  'a,n,t' => [ 'tan', 'nat' ],
  'a,b,t' => [ 'bat' ]
}
    */
/* 
console.log(map.values())
[Map Iterator] { [ 'eat', 'tea', 'ate' ], [ 'tan', 'nat' ], [ 'bat' ] }
*/
    return Array.from(map.values())
    
}
//groupAnagrams(strs)
console.log(groupAnagrams(strs))

方法：字符串数组，把他们每一项转成数组

Array.from()

array.toString()

返回map中的value：map.values()

13、罗马数字转整数

var s = "MCMXCIV"
var romanToInt = function(s) {
    var sum=0;  //学会map的格式
    let map = new Map([['I',1],['V',5],['X',10],['L',50],['C',100],['D',500],['M',1000]])
    //console.log(map)
    for(let i=0;i<s.length;i++){
        let res = map.get(s[i])
        let tem = map.get(s[i+1])
        if(res<tem){  //如果前者比后者小，那么
            sum =sum-res
        }else{
            sum =res+sum
        }
    }
    return(sum)
};
romanToInt(s)

收获：

• map相关操作：

let map = new Map();
// 增
// 1.
let map1 = new Map([['a',1],['b',2],['c',3]])
// 2.
map.set('a',1);
map.set('b',2);
map.set('c',3);

// 删
map.delete('c');

// 清除
map.clear();

// 取值
map.get('c');

// 是否存在
map.has('c');

// 长度
map.size;
 

• 迭代：

let map = new Map([['a',1],['b',2],['c',3]])
// 遍历
// 1.
map.forEach((value, key) => {
    console.log(key, value)
});
// a,1
// b,2
// c,3

// 2.
for (const item of map) {
    console.log(item);
}
// [a,1]
// [b,2]
// [c,3]

// keys
map.keys();
// ['a','b','c']

// values()
map.values();
// 1
// 2
// 3

// entries()
map.entries();
// [a,1]
// [b,2]
// [c,3]
 

• 应用举例：

function contrast(arr) {
    const map = new Map()
    const result = []
    for (let i = 0; i < arr.length; i++) {
        if (map.has(arr[i].key)) {
            map.set(arr[i].key, true)
        } else {
            map.set(arr[i].key, false)
            result.push(arr[i])
        }
    }
    return result
}
 

169、多数元素

var nums = [2, 2, 1, 1, 1, 2, 2];
var majorityElement = function (nums) {
  let map = new Map();
  for (const num of nums) {
    if (map.has(num)) {
        let i=map.get(num)
        i++;
        map.set(num,i)
    } else {
      map.set(num, 1);
     // console.log(map);
    }
  }
  let res=map.values();
console.log(res)
};
majorityElement(nums);

242、有效的字母异位词

方法一、异位词想到排序，按同一种标准排列起来然后看是否相同

 s = "anagram"， s = "gnaaram"
var isAnagram = function (s) {
    console.log(s)  //anagram   //字符串  
    console.log([...s]) */
    /* 
    [
     'a', 'n', 'a',
     'g', 'r', 'a',
     'm'
    ]
    */
    /* console.log([...s].join(''))  //anagram
};
isAnagram(s)

收获：

[...s]可以把字符串转化成数组

sort()是数组的方法

以上可以这样操作：

var isAnagram = function(s, t) {
    return [...s].sort().join('')===[...t].sort().join('')
};

方法二：哈希，数组结构实现

s = "anagram",t = "nagaram"
var isAnagram = function (s) {
    if(s.length!=t.length){
        return false
    }
    const record=new Array(26).fill(0);
    let base='a'.charCodeAt() //97  console.log('b'.charCodeAt())  98 console.log('c'.charCodeAt()) 99 console.log('z'.charCodeAt())  122
    for(const i of s){
        record[i.charCodeAt()-base]++;  //通过基准找到位置，使得该位置上数组的值从0变成1
    }
   for(const i of t){
       if(!record[i.charCodeAt()-base]){return false}
    record[i.charCodeAt()-base]--;
   }
   return true
}
isAnagram(s,t)

我自己用map实现的，最后不知到怎么输出?

s = "anagram",t = "nagaram"
var isAnagram = function (s) {
    var maps=new Map();
    var mapt=new Map();
    [...s].forEach(item => {
        maps.has(item)?maps.set(item,maps.get(item)+1):maps.set(item,1)
    });
    [...t].forEach(item => {
        mapt.has(item)?mapt.set(item,mapt.get(item)+1):mapt.set(item,1)
    });
   // console.log(maps)
    //console.log(mapt)
  //maps、mapt内容一样，顺序不同，怎么判断他们是一样的

//这里是看的力扣，但是不懂
    const ls1 = Object.entries(maps)  //?
    console.log(ls1)
    const ls2 = Object.entries(mapt)  //逐位判断  ？不理解
  return ls1.length === ls2.length && !ls1.find(item => !map2[item[0]] || map2[item[0]] !== item[1])
}
isAnagram(s)