【算法和数据结构】_11_小算法_itoa、ftoa及字符串倒置

【1】main.c

/****************************************************
*
*    把整数按照进制数转换为相应进制的字符串
*（要考虑符号），比如 -1234，转换为 “-1234”。
*   
*
****************************************************/

#include <stdio.h>
#include <string.h>
 
#define BUF_LEN 12

//将数字转换成十进制子函数
void iToDecCh(int iNum,char *p);

//字符串倒置函数
void strReverse(char* str);

/*
        根据不同的进制申请不同的字符空间
    因为有符号的int最大值为：
        INT_MAX: +2147 4836 47
        INT_MIN: -2147 4836 47
    共需要11个字符，加上最后的'\0'；则需要12字节的空间
        
        任何1个整数表示成16进制，则需要 0X FFFF FFFF
    2+8 个字符，加上最后的'\0';则需要11个字节的空间

    这里定义12个字符的buf。
*/
char strBuf[BUF_LEN];



/*******
*
*   主函数： main 函数开始
*
********/
int main()
{
    char* p;
    
    iToDecCh(0,strBuf);
    //strReverse(strBuf);

    p=strBuf;
    while(*p)
        putchar(*p++);

    getchar();
    return 0;
}

/******************************************
        将一个数字转换成十进制字符串
算法：

原型：
     void iToDecCh(int num,char *p)
返回值：
    无
参数：
    int num: 待转换的数字
    char* p: 存储字符串的线性地址空间首地址
异常：
     无
其他：
    无
********************************************/
void iToDecCh(int num,char *p)
{
    int i;
    int flag;

    unsigned int decMask;
    unsigned int signedFlag;

    signedFlag=0x8000000; // 用于判断正负

    if(0==num)
    {
        p[0]='+';
        p[1]='0';
        return ;
    }
         
    //判断正、负情况     
    if(num & signedFlag)
    {
        flag=0;  // p[11] ='-'; 负数    
        num=-1 * num; //将负数变成整数
    }
    else
    {
        flag=1;  // p[11] ='+'; 正数
    }

    i=0;
    while(num > 0)
    {          
        p[i++]= num % 10 + '0';
        num=num /10;
    }

    if(flag==1)
        p[i++]='+';
    else
        p[i++]='-';

    p[i]='\0';

    strReverse(p);
}


/*****************************************
        字符串倒置函数
算法：

原型：
    void strReverse(char* str)
返回值：
    无
参数：
    char *str:待倒置的字符串首地址
异常：
    无
其他：

******************************************/
void strReverse(char* str)
{
    int i,
        j;

    j=strlen(str);

    for(i=0,j--;i<j;i++,j--)
    {
        str[i]=str[i] ^ str[j];
        str[j]=str[j] ^ str[i];
        str[i]=str[j] ^ str[i];
    }
}

 

【2】main.c

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

#define NUL ('\0')
 

char ftoaArray[30];
char itoaArray[30];

//字符串倒置函数，将 “abcd” 倒置为 “dcba”
char* strRev(char* str)
{
    char* head;
    char* pShift;

    head=str;
    pShift=str;

    while(*pShift) pShift++;

    --pShift;
    while(pShift>head)
    {
        *pShift = *pShift ^ *head;
        *head =   *pShift ^ *head;
        *pShift-- = *pShift ^ *head++;    //最后的时候移动指针的指向
    }

    return str;
}


//将浮点数转换为字符串, 保留4位数据精度
//这里是在ADC转换的时候，进行测试用的
//所以这里没有进行正负的判断
char* ftoa(float num)
{
    int i;
    int x;
    float y;
    char* shift;

    x=(int)num; //取数据的整数部分

    shift=ftoaArray;
    while(x > 10)
    {
        *shift++= x%10 + '0';
        x /= 10;
    }
    *shift++ = x + '0';
    *shift = NUL ;
    strRev(ftoaArray);

    *shift++ = '.'; //把最后的 '\0' 替换为 '.'


    //这样处理就可以将小数点小于4位、和大于4位的都处理完
    i=1;
    y=num-(int)num;  //y为小于1的小数
    while(y>0.000001)  
    {
        y= y*10;
        x=y;
        *shift++ =x +'0';
        y = y-(int)(y);

        if(4==i) //不管有没有转换完，循环4次都跳出 
        {
            break;
        }
        i++;
    }
    *shift = NUL;

    return ftoaArray;
}

//将十进制的数转换为字符串
char* itoa(unsigned short num)
{
    int i=0;

    while(num >= 10)
    {
        itoaArray[i++]=num%10 + '0';
        num    /= 10;
    }
    itoaArray[i++]=num + '0';
    itoaArray[i]=NUL;

    strRev(itoaArray);

    return itoaArray;
}



/*******
*
*   主函数： main 函数开始
*
********/
int main()
{

    char* str="abcd";
    strRev(str);
    puts(str);

    itoa(1234);
    puts(itoaArray);


    ftoa(311.1415516);
    printf("%s",ftoaArray);

    getchar();
    return 0;
}

   其实，在第二个的itoa中，可以用指针代替数组的index索引，用指针速度更快。