前言

已经一周没有刷题了…

1.整数反转

7. 整数反转-中等
题目：给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−2^31, 2^31 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。
①数学

var reverse = function(x) {
    if(x==0) return x;
    let ans=0;
    while(x!==0){
        const digit=x%10;
        //  ~~  双非按位取反运算符
        x=~~(x/10);
        ans=ans*10+digit;
        if(ans<Math.pow(-2,31)||ans>Math.pow(2,31)-1){
            return 0;
        }
    }
    return ans;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

时间复杂度：O(log∣x∣)。翻转的次数即x十进制的位数。
空间复杂度：O(1)。
关于~~
②很妙的解法
题解中大部分都是方法①，找到了下面这种很妙的解法，转成字符串后分割再反转。

if (x>=0) {
        x= x.toString().split('').reverse().join('');
    }

    else {
        x= -x;
        x= -( x.toString().split('').reverse().join(''));
        
    }

    if (x >=Math.pow(2,31) ||x <Math.pow(-2,31) ) return 0;
    else return x;
1
2
3
4
5
6
7
8
9
10
11
12

问题：不会计算时间复杂度

2.不同的二叉搜索树

96. 不同的二叉搜索树-中等
题目： 给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。
①动态规划
动态规划永远的痛
重点是推导状态转移方程
定义两个函数：

推导出G(n)的递归表达式：

var numTrees = function(n) {
    const dp=new Array(n+1).fill(0);
    dp[0]=1,dp[1]=1;

    for(let i=2;i<=n;i++){
        for(let j=1;j<=i;j++){
            dp[i]+=dp[j-1]*dp[i-j];
        }
    }
    return dp[n];
};
1
2
3
4
5
6
7
8
9
10
11

时：O(n²)， n表示二叉搜索树的节点个数。G(n)函数一共有n个值需要求解，每次求解需要O(n)的时间复杂度，因此总时间复杂度为O(n²)
空：O(n)，存储G，也就是dp数组
②数学
卡特兰数

var numTrees = function(n) {
    let C = 1;
    for (let i = 0; i < n; ++i) {
        C = C * 2 * (2 * i + 1) / (i + 2);
    }
    return C;
};
1
2
3
4
5
6
7

③递归

var numTrees = function(n) {

    if(n===0||n===1) return 1;

    if(result[n]){
        return result[n];
    }
    
    let ans=0;
    for(let i=1;i<=n;i++){
        ans+=numTrees(i-1)*numTrees(n-i);
    }
    result[n]=ans;
    return ans;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.不同的二叉搜索树II

95. 不同的二叉搜索树 II-中等
题目： 给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树 。可以按 任意顺序 返回答案。

4.恢复二叉搜索树

99. 恢复二叉搜索树-中等

5.二叉树的锯齿形层序遍历

103. 二叉树的锯齿形层序遍历