LeetCode：Pow(x, n)求x的n次幂

=======题目描述=======

题目链接：https://leetcode.com/problems/binary-tree-level-order-traversal/

题目内容：

Implement pow(x, n), which calculates x raised to the power n (xn).

Example 1:

Input: 2.00000, 10
Output: 1024.00000

Example 2:

Input: 2.10000, 3
Output: 9.26100

Example 3:

Input: 2.00000, -2
Output: 0.25000
Explanation: 2-2 = 1/22 = 1/4 = 0.25

Note:

• -100.0 < x < 100.0
• n is a 32-bit signed integer, within the range [−231, 231 − 1]

=======算法实现=======

class Solution {
public:
 double myPow(double x, int n) {
        if(n == 0)
            return 1;
        if(n == 1)
            return x;
        if(n < 0)
        {
            x = 1.0/x;
            //特殊情况特殊处理int的范围时-2147483648～2147483647
            if(n == -2147483648)       
            {   
                n = 2147483647;
                return x * myPow(x,n);
            }
            else
            {
              n *= (-1);   
            }  
            return myPow(x,n);
        }
        if(n%2 == 0)        //偶数次幂
        {
            double t = myPow(x,n/2);
            return t*t;
        }
        else
        {
            double t = myPow(x,n/2);
            return t*t*x;
        }
    }


};

上面的算法如果修改为下面的方式，会提示错误：

修改为 return (double)(myPow(x,n/2))*(double)(myPow(x,n/2))*x;也是同样的错误，还不太理解错误的原因，结果超出长度？

class Solution {
public:
 double myPow(double x, int n) {
        if(n == 0)
            return 1;
        if(n == 1)
            return x;
        if(n < 0)
        {
            x = 1.0/x;
            //特殊情况特殊处理int的范围时-2147483648～2147483647
            if(n == -2147483648)       
            {   
                n = 2147483647;
                return x * myPow(x,n);
            }
            else
            {
              n *= (-1);   
            }  
            return myPow(x,n);
        }
        if(n%2 == 0)        //偶数次幂
        {
           // double t = myPow(x,n/2);
            return myPow(x,n/2)*myPow(x,n/2);
        }
        else
        {
            //double t = myPow(x,n/2);
            return myPow(x,n/2)*myPow(x,n/2)*x;
        }
    }


};

百度的时候发现下面的代码看起来更清晰：

class Solution {
public:
    double myPow(double x, int n) {
        if(x == 0)
        {
            return 0.0;
        }
        if(n > 0)
        {
            return Pow(x, n);
        }
        else
        {
            return 1 / Pow(x, -n);
        }
    }
    
   double Pow(double x, int n){
        if(n == 0)
            return 1;
        double mid = Pow(x, n/2);
        if(n%2 == 0)
        {
            return mid * mid;
        }
        else
        {
            return mid * mid * x;
        }
    }


};

https://www.jianshu.com/p/e7d354f3f91b

=======算法笔记*递归=======

1、递归

①定义：

是指函数/过程/子程序在运行过程序中直接或间接调用自身而产生的重入现象。

在计算机编程里，递归指的是一个过程：函数不断引用自身，直到引用的对象已知。

使用递归解决问题，思路清晰，代码少。但是在主流高级语言中（如C语言、Pascal语言等）使用递归算法要耗用更多的栈空间，所以在堆栈尺寸受限制时（如嵌入式系统或者内核态编程），应避免采用。所有的递归算法都可以改写成与之等价的非递归算法。

②构成递归的条件：

1. 子问题须与原始问题为同样的事，且更为简单；

2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。

递归关系就是实体自己和自己建立关系。

Fib(0) = 1 [基本情况] Fib(1) = 1 [基本情况] 对所有n > 1的整数：Fib(n) = (Fib(n-1) + Fib(n-2)) [递归定义] 尽管有许多数学函数均可以递归表示，但在实际应用中，递归定义的高开销往往会让人望而却步。

递归实现遍历文件夹：

import os

def fileDisplay(filepath):
    for each in os.listdir(filepath):
        # 得到文件的绝对路径:
        absolutePath = os.path.join(filepath， each)
        # 得到是否为文件还是目录的布尔值:
        is_file = os.path.isfile(absolutePath)
        if is_file:
            # 当前的绝对路径为文件:
            print(each)
        else:
            # 当前的绝对路径为目录:
            fileDisplay(absolutePath)

fileDisplay('/home/pushy')

递归实现创建多级目录文件夹：

import os

def createFile(dirname):
    exits = os.path.exists(dirname)
    if exits:
        return True
    else:
        # 开始递归调用函数，并接受其返回值:
        rec_result = createFile(os.path.dirname(dirname))
        if rec_result:
            # 如果不存在该目录，则创建dirname的目录，并返回已经创建(存在)的值True:
            os.mkdir(dirname)
            return True

createFile('./aa/bb/cc')

2、递归与循环的比较

图片来源：https://blog.csdn.net/ScarlettYellow/article/details/80458856

3、斐波那契数列​​​​​​​Fibonacci Sequence

斐波那契数列，又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）。

递归实现斐波拉契数列：

def fib(x):
    if x < 2:
        return 0 if x == 0 else 1
    # 当x > 2时，开始递归调用fib()函数:
    return fib(x - 1) + fib(x - 2)

参考：

https://www.cnblogs.com/Pushy/p/8455862.html