JS算法(二)

1.爬楼梯

爬楼梯假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢

1.思想

从第一阶开始假设：第0阶是零种，第一阶有一种，第二阶有两种
即： dp[0] = 0 dp[1] = 1 dp[2] = 2
那么有递推关系，到达第n阶楼梯有从n-1阶走一步和从第n-2阶走两步两种情况，一直往前推，可得递推式： dp[n] = dp[n-1] + dp[n-2]

2.JS代码

var climbStairs = function(n) {
    let dp = [];
    dp[0] = 0,dp[1] = 1,dp[2] = 2;
    for(let i = 3;i <= n;i++){
        dp[i] = dp[i-2] + dp[i-1];
    }
    return dp[n];
};

2.找出数组中任意一个重复的数字

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1
的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入： [2, 3, 1, 0, 2, 5, 3] 输出：2 或 3

2.1 思想

用对象来存储某个数是否出现过，如果第一次出现就添加属性标识为true，否则就直接返回

2.2 JS代码

var findRepeatNumber = function(nums) {
  var flag={};
  for(var i=0;i<nums.length;i++){
      if(!flag[nums[i]])  flag[nums[i]]=true;
      else return nums[i];  
      //console.log(nums[i]);
      //console.log(flag[nums[i]]);
      //console.log(flag); //观察flag的变化
  }
};
s= [1,8,4,5,6,4,8,9,4]
console.log(findRepeatNumber(s))    //4

3.把字符串 s 中的每个空格替换成"%20"

示例 1： 输入：s = “We are happy.” 输出：“We%20are%20happy.”

3.1 思想

利用split()和join()

3.2 JS代码

var replaceSpace = function(s) {
    let arr=s.split(' ').join('%20')
    return arr
};

4.输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2] 输出：[2,3,1]

4.1 思想

用unshift()的方法，将元素放入数组的最后一位，然后打印数组

4.2 JS代码

var reversePrint = function(head) {
  var arr = []
  while(head) {
      arr.unshift(head.val)
      head = head.next
  }
  return arr

5.使用 javascript 实现 productExceptSelf 方法

给定长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output，其中 output[i] 等于 nums 中除
nums[i] 之外其余各元素的乘积，参数为一个整数数组，返回一个数组。

5.1 思想

获得所有元素的乘积，再除nums[i]

5.2 JS代码

function productExceptSelf(nums) {
    var total = 1;
    //获得所有元素的乘积
    nums.forEach(value => {
        total *= value;
    });
    // map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
    // map() 方法按照原始数组元素顺序依次处理元素。
    //除以自身
    var newNums = nums.map(value => {
        return total / value;
    });
    return newNums;
}

var input = [1, 2, 3, 4];
console.log(productExceptSelf(input));   // [24, 12, 8, 6]
var input2 = [2, 3, 4, 5];
console.log(productExceptSelf(input2));  // [60, 40, 30, 24]

6.把句子按单词反转

反转后单词不能有多个空格。

6.1 思想

用正则表达式匹配空格返回的是数组，用reverse对数组反转，然后返回用空格拼接的字符串

6.2 JS代码

function reverseStr(str) {
    // \s 匹配空格
    var s = str.match(/[^\s]+/g)
    s = s.reverse();
    return s.join(' ');
}

str = 'Hello                world        !        ni     hao  ya';
console.log(reverseStr(str));   
// ya hao ni ! world Hello

//match() 方法将检索字符串 String Object，以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g。如果 regexp 没有标志 g，那么 match() 方法就只能在 string Object 中执行一次匹配。如果没有找到任何匹配的文本， match() 将返回 null。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息。

7.使用 javascript 实现 dupicatedWord() 方法

统计数组中字符出现的频次，返回一个 Object<String, Boolean> 对象，字符为 key，当出现两次以上将 value 置为 true，否则为 false。

7.1 思想

使用对象方法，遍历数组中的值，在三目运算中进行判断。先判断obj[value]是否存在，不存在就false，存在就true，再把值赋回obj[value]。
（运算优先级：=== 大于 ？ 大于 =）

7.2 JS代码

function dupicatedWord(arr) {
    let obj = {};
    arr.forEach((value) => {
        obj[value] = typeof obj[value] === 'undefined' ? false : true;
    });

    return obj;
}

let arr = ['a', 'a', 'b', 'b', 'c'];
console.log(dupicatedWord(arr));  // {a: true, b: true, c: false}

8.写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。

斐波那契数列的定义如下： F(0) = 0, F(1) = 1 F(N) = F(N - 1) + F(N - 2), 其中 N >

1. 斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

8.1 思想

dp[i]含义：斐波那契数列的第i个数为dp[i]
递推公式：根据定义易得：dp[i] = (dp[i - 1] + dp[i - 2])
遍历顺序：根据定义，当前数依赖于前两个数，所以从前向后遍历

8.2 JS代码

    const fib = n => {
    const dp = [0, 1];
    for (let i = 2; i <= n; i++) {
        dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007;
    }
    return dp[n];
};

9.一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

9.1 思想

初始的式子为：dp = [1, 1]
有递推关系，到达第n阶楼梯有从n-1阶走一步和从第n-2阶走两步两种情况，一直往前推，可得递推式： dp[n] = dp[n-1] + dp[n-2] .

9.2 JS代码

var numWays = function(n) {
      
    let dp = [1, 1]
    for(let i = 2; i <= n; i++) {
        dp[i] = (dp[i-1] + dp[i-2]) % 1000000007
    }
    return dp[n]


};

10.旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 给你一个可能存在 重复 元素值的数组 numbers
，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为
[1,2,3,4,5] 的一次旋转，该数组的最小值为 1。 注意，数组 [a[0], a[1], a[2], …, a[n-1]]
旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]] 。

示例 1： 输入：numbers = [3,4,5,1,2] 输出：1

示例 2： 输入：numbers = [2,2,2,0,1] 输出：0 提示： n == numbers.length 1 <= n
<= 5000
-5000 <= numbers[i] <= 5000 numbers 原来是一个升序排序的数组，并进行了 1 至 n 次旋转

10.1 思想

用展开运算符将数组展开，利用JS中的min()函数判断后返回。

10.2 JS代码

var minArray = function(numbers) {
  return Math.min(...numbers)
};