一些编程面试题-优快云博客

本文链接：https://blog.youkuaiyun.com/CodeHeng/article/details/49000931

本文探讨了在编程中实现代数运算时如何使用高效算法与数据结构优化性能，包括数值计算、数学函数的近似计算、以及利用递归与循环优化算法效率。重点介绍了快速幂算法、斐波那契数列的循环实现、二进制计数方法，以及二进制指数运算。此外，还讨论了如何通过循环避免递归带来的重复计算问题，提高算法的执行效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define ArraySize(a) (sizeof(a)/sizeof(a[0]))
// 斐波那契数列(递归效率低,重复计算多)
long long Fibonacci(unsigned int n)
{
    if (0 >= n)
    {
        return 0;
    }
    else if (1 == n)
    {
        return 1;
    }
    else
    {
        return Fibonacci(n-1) + Fibonacci(n-2);
    }
}
// 斐波那契数列(循环效率高)
long long Fibonacci2(unsigned int n)
{
    long long pre1 = 0;
    long long pre2 = 1;
    if (0 >= n)
    {
        return pre1;
    }
    else if (1 == n)
    {
        return pre2;
    }
    
    long long FibN = 0;
    
    for (unsigned int i = 2; i <= n; i ++)
    {
        FibN = pre1 + pre2;
        pre1 = pre2;
        pre2 = FibN;
    }
    return FibN;
}

/*
*二进制表示1的个数(局限：不能为负数)
*/
int number(int _ninput)
{
    int count = 0;
    int begin = _ninput;
    
    while (begin != 0)
    {
        int temp = begin & 1;
        if (temp == 1)
        {
            count ++;
        }
        begin >>= 1;
    }
    
    return count;
}

/*
*二进制表示1的个数(固定循环32次)
*/
int number1(int _ninput)
{
    int count = 0;
    int flag = 1;
    
    while (flag != 0)
    {
        int temp = _ninput & flag;
        if (temp != 0)
        {
            count ++;
        }
        flag <<= 1;
    }
    
    return count;
}

/*
*二进制表示1的个数(有多少个1就循环多少次)
*/
int number2(int _ninput)
{
    int count = 0;
    
    while (_ninput != 0)
    {
        count ++;
        _ninput = _ninput & (_ninput -1);
    }
    
    return count;
}

static bool _equal(double _arg1, double _arg2)
{
    double temp = _arg1 - _arg2;
    bool bRet = false;
    if (temp > -0.0000001 && temp < 0.0000001)
    {
        bRet = true;
    }
    
    return bRet;
}

// 求base的exponent次方
double Power(double _base, int exponent)
{
    if (_equal(_base, 0.0) || exponent == 0)
    {
        return 1.0;
    }
    
    int abs_exponent = exponent;
    if (exponent < 0)
    {
        abs_exponent = -exponent;
    }
    
    double result = 1.0;
    for (int i = 0; i < abs_exponent; i ++)
    {
        result *= _base;
    }
    
    if (exponent < 0)
    {
        result = 1.0/result;
    }
    
    return result;
}

static bool _increse(char* _szNum)
{
    int nLength = strlen(_szNum);
    int i = 0;
    int nCarryOver = 0;
    
    for (i = nLength - 1; i >= 0; i --)
    {
        int temp = _szNum[i] - '0' + nCarryOver;
        if (i == nLength - 1) // 只对个位数进行加1操作
        {
            temp ++;
        }
        
        if (temp >= 10)
        {
            if (0 == i)
            {
                return false;
            }
            temp -= 10;
            _szNum[i] = '0' + temp;
            nCarryOver = 1;
        }
        else
        {
            nCarryOver = 0;
            _szNum[i] = '0' + temp;
            break;
        }
    }
    
    return true;
}

static bool _Print(char* _szNum)
{
    int nLength = strlen(_szNum);
    bool bBegin = false;
    
    for (int i = 0; i < nLength; i ++)
    {
        if (_szNum[i] != '0') // 从第一个不是'0'字符开始打印
        {
            bBegin = true;
        }
        if (bBegin)
        {
            printf("%c", _szNum[i]);
        }
    }
    printf("\n");
    
    return true;
}

// 按顺序打印从1到最大的n位十进制数，字符串解法，不局限最大数
bool PrintMaxNDigit(int _n)
{
    if (_n <= 0)
    {
        return false; 
    }
    
    char* szNum = new char[_n + 1];
    memset(szNum, '0', _n);
    szNum[_n] = '\0';
    
    while (_increse(szNum))
    {
        _Print(szNum);
    }
    
    delete[] szNum;
    return true;
}

int main(int argc, char** argv)
{
    printf("%lf\n", Power(2, 0));
    PrintMaxNDigit(1);
    
    return 0;
}