2022初级算法字符串1

1. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例1

输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]

示例2

输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]

提示

• 1 <= s.length <= 105
• s[i] 都是 ASCII 码表中的可打印字符

解答

/**
 * @param {character[]} s
 * @return {void} Do not return anything, modify s in-place instead.
 */
var reverseString = function(s) {
    s.reverse()
};

知识点

• reverse() 方法用于颠倒数组中元素的顺序。

2. 整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。

示例1

输入：x = 123
输出：321

示例2

输入：x = -123
输出：-321

示例3

输入：x = 120
输出：21

示例4

输入：x = 0
输出：0

提示
-2^31 <= x <= 2^31 - 1

解答

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    const arr = (Math.abs(x)+'').split('').reverse();
    var arr2=''
    if(arr[0]==0){
        arr.shift(0)
    }
    arr2 = arr.join('')
    if(x<0){
        arr2 = 0-arr2
    }
    if(arr2<Math.pow(-2,31)||arr2>Math.pow(2,31)-1) return 0;
    return arr2
};

知识点

• 绝对值：Math.abs(x)
• x的y次幂：Math.pow(x,y)
• 字符串转数组：str.split(‘’)
• 数组原型方法：
  shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。
  unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。
  reverse() 方法用于颠倒数组中元素的顺序。

3. 字符串中的第一个唯一字符

给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1 。

示例1

输入: s = "leetcode"
输出: 0

示例2

输入: s = "loveleetcode"
输出: 2

示例3

输入: s = "aabb"
输出: -1

提示

• 1 <= s.length <= 105
• s 只包含小写字母

解答

/**
 * @param {string} s
 * @return {number}
 */
var firstUniqChar = function(s) {
    let map = new Map();
    for(let i=0;i<s.length;i++){
        let word = s.charAt(i);
        let val = map.get(word);
        if(map.has(word)){
            map.set(word,val+1)
        }else{
            map.set(word,1)
        }
    }
    for(let i=0;i<s.length;i++){
        if(map.get(s.charAt(i))===1) return i;
    }
    return -1
};

知识点

1、Map是什么

Map类型是键值对的有序列表，而键和值都可以是任意类型
Map与Set的区别

• Set是一种叫做集合的数据结构，Map是一种叫做字典的数据结构
• Set集合是以[值，值]的形式存储元素，
  Map字典是以[键，值]的形式存储

2、增删改查

2.1 size

size属性返回 Map 结构的成员总数。

const map = new Map();
map.set('foo', true);
map.set('bar', false);
map.size // 2

2.2 set()

设置键名key对应的键值为value，然后返回整个 Map 结构
如果key已经有值，则键值会被更新，否则就新生成该键
同时返回的是当前Map对象，可采用链式写法

const m = new Map();
let fn = function(){}

m.set('jeney', 6)        // 键是字符串
m.set(fn, 'standard')     // 键是函数
m.set(undefined, 'nah')    // 键是 undefined
m.set(1, 'a').set(2, 'b').set(3, 'c') // 链式操作

2.3 get()

get方法读取key对应的键值，如果找不到key，返回undefined

const m = new Map();
const hi = function() {console.log('hi');};
m.set(hi, 'Hi ES6!') // 键是函数
m.get(hi)  // Hello ES6!

2.4 has()

has方法返回一个布尔值，表示某个键是否在当前 Map 对象之中

const m = new Map();

m.set('jeney', 6);
m.set(262, 'az');
m.set(undefined, 'bu');

m.has('jeney')     // true
m.has('years')       // false
m.has(undefined)     // true

2.4 delete()

delete方法删除某个键，返回true。如果删除失败，返回false

const m = new Map();
m.set(undefined, 'nah');
m.has(undefined)     // true

m.delete(undefined)
m.has(undefined)       // false

2.5 clear()

clear方法清除所有成员，没有返回值

let map = new Map();
map.set('foo', true);
map.set('bar', false);

map.size // 2
map.clear()
map.size // 0

3、遍历

• keys()：返回键名的遍历器
• values()：返回键值的遍历器
• entries()：返回所有成员的遍历器
• forEach()：遍历 Map 的所有成员

const map = new Map([
  ['F', 'no'],
  ['T',  'yes'],
]);

//keys()
for (let key of map.keys()) {
  console.log(key);       // "F"  "T"
}

//values()
for (let value of map.values()) {
  console.log(value);    // "no"  "yes"
}

// entries()
for (let item of map.entries()) {
  console.log(item[0], item[1]);
}
// "F" "no"  、"T" "yes"

// 或者
for (let [key, value] of map.entries()) {
  console.log(key, value);
}
// "F" "no" 、"T" "yes"

// 等同于使用map.entries()
for (let [key, value] of map) {
  console.log(key, value);
}
// "F" "no"  、 "T" "yes"

map.forEach(function(value, key, map) {
  console.log(key, value);    // "F" "no"  、 "T" "yes"
});