20160219.CCPP体系详解(0029天)

程序片段(01):ReplaceAll.c

内容概要:ReplaceAll

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//01.(删除+替换)所有指定字符串
//  (双索引+双指针)-->(删除+替换)原理
//  注:增加(拓展)+删除(压缩)+修改(压缩|不变|拓展)+查询(不变)
void replaceAll(char ** ppSrcStr, char * pOldStr, char * pNewStr)
{
    char * pSrcStr = *ppSrcStr;//常量指针-->变量指针(同一本体)-->跨函数间接修改常量指针
    int srcStrLen = strlen(pSrcStr);
    int oldStrLen = strlen(pOldStr);
    int newStrLen = strlen(pNewStr);
    char * p1 = pSrcStr;
    char * p2 = pSrcStr;
    if (oldStrLen == newStrLen)
    {
        while (*p1 = *p2)
        {
            int find = 1;
            for (int i = 0; i < oldStrLen; ++i)
            {
                if ('\0' == *(p2 + i) || *(p2 + i) != *(pOldStr + i))
                {
                    find = 0;
                    break;
                }
            }
            if (!find)
            {
                ++p2;
                ++p1;
            }
            else
            {
                for (int i = 0; i < newStrLen; ++i)
                {
                    *(p2 + i) = *(pNewStr + i);
                }
            }
        }
    }
    else if (oldStrLen < newStrLen)
    {
        while (*p1 = *p2)
        {
            int find = 1;
            for (int i = 0; i < oldStrLen; ++i)
            {
                if ('\0' == *(p2 + i) || *(p2 + i) != *(pOldStr + i))
                {
                    find = 0;
                    break;
                }
            }
            if (!find)
            {
                ++p2;
                ++p1;
            }
            else
            {
                int m = p2 - pSrcStr;
                int n = p1 - pSrcStr;
                pSrcStr = *ppSrcStr = (char *)_recalloc(*ppSrcStr, srcStrLen + newStrLen - oldStrLen + 1, sizeof(char));
                p2 = pSrcStr + m;
                p1 = pSrcStr + n;
                int moveLen = newStrLen - oldStrLen;
                for (char * p = p2 + strlen(p2); p >= p2; --p)
                {
                    *(p + moveLen) = *p;
                }
                for (int i = 0; i < newStrLen; ++i)
                {
                    *(p2 + i) = *(pNewStr + i);
                }
            }
        }
    }
    else
    {
        while (*p1 = *p2)
        {
            int find = 1;
            for (int i = 0; i < oldStrLen; ++i)
            {
                if ('\0' == *(p2 + i) || *(p2 + i) != *(pOldStr + i))
                {
                    find = 0;
                    break;
                }
            }
            if (!find)
            {
                ++p2;
                ++p1;
            }
            else
            {
                for (int i = 0; i < newStrLen; ++i)
                {//赋值有效字符串
                    *(p2 + oldStrLen - newStrLen + i) = *(pNewStr + i);
                }
                p2 += oldStrLen - newStrLen;//跳过无效字符串
            }
        }
    }
}

int main01(void)
{
    int srcStrLen = strlen("12345543211234554321");
    char * pStr = (char *)malloc(srcStrLen + 1);
    strcpy(pStr, "12345543211234554321");
    printf("%s \n", pStr);
    //replaceAll(&pStr, "12345", "ABCDE");
    //replaceAll(&pStr, "123", "ABCDE");
    replaceAll(&pStr, "12345", "ABC");
    printf("%s \n", pStr);

    system("pause");
}

程序片段(02):获取最长数字串.c

内容概要:寻找母串当中最长的数字子串

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

int main01(void)
{
    char * pInputStr = "abc12345hij1234321jkl1237ol";
    char * pMaxNumStr = NULL;
    int maxNumLen = 0;
    char * pChr = pInputStr;//指向普通字符的指针
    while (*pChr)
    {
        while (!('0' <= *pChr && *pChr <= '9'))
        {
            ++pChr;
        }
        char * pNum = pChr;//指向数字字符的指针
        while ('0' <= *pChr && *pChr <= '9')
        {
            ++pChr;
        }
        if (pChr - pNum > maxNumLen)
        {
            maxNumLen = pChr - pNum;
            pMaxNumStr = pNum;
        }
    }
    printf("%d \n", maxNumLen);
    for (int i = 0; i < maxNumLen; ++i)
    {
        putchar(*(pMaxNumStr + i));
    }

    system("pause");
}

程序片段(03):数组.c

内容概要:递归的高级形式判定数组是否递增

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

int loopJudge(int * pArr, int num)
{
    for (int i = 0; i < num - 1; ++i)
    {
        if (*(pArr + i) > *(pArr + i + 1))
        {
            return 0;
        }
    }
    return 1;
}

//01.递归的高级形式:
//  通过逻辑运算符建立递归关系
int recurJudge(int * pArr, int num)
{
    if (1 == num)//保证判定式成立
        return *(pArr + 0) < *(pArr + 1);
    //形成整体表达式
    return *(pArr + num - 2) < *(pArr + num - 1) && recurJudge(pArr, num - 1);
}

int main01(void)
{
    int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    //printf("%d \n", loopJudge(arr, 10));
    printf("%d \n", recurJudge(arr, 10));

    system("pause");
}

程序片段(04):01.数组最大值.c+02.冒泡求最大值.c

内容概要:取数组最大值循环递归

///01.数组最大值.c
#include <stdio.h>
#include <stdlib.h>

int maxNumByLoop(int * pArr, int num)
{//打擂算法
    int maxNum = *(pArr + 0);
    for (int i = 1; i < num; ++i)
        if (maxNum < *(pArr + i))
            maxNum = *(pArr + i);
    return maxNum;
}

int maxNumByRecur(int * pArr, int num, int maxValue)
{
    if (0 == num)//表达式恒成立
    {
        if (maxValue < *(pArr + 0))
        {
            maxValue = *(pArr + 0);
        }
        return maxValue;
    }
    if (maxValue < *(pArr + num - 1))
    {//直接数组个数
        maxValue = *(pArr + num - 1);
    }
    maxNumByRecur(pArr, num - 1, maxValue);
}

int main02(void)
{
    int arr[10] = { 1, 4, 5, 9, 18, 13, 2, 0, 12, 8 };
    printf("maxValue = %d \n", maxNumByLoop(arr, 10));
    printf("maxValue = %d \n", maxNumByRecur(arr, 10, 0));

    system("pause");
}

///02.冒泡求最大值.c
#include <stdio.h>
#include <stdlib.h>

static int maxNumByRecur(int * pArr, int num)
{//递归算法
    if (1 == num)
    {
        if (*(pArr + 0) < *(pArr + 1))
        {
            *(pArr + 0) = *(pArr + 0) ^ *(pArr + 1);
            *(pArr + 1) = *(pArr + 0) ^ *(pArr + 1);
            *(pArr + 0) = *(pArr + 0) ^ *(pArr + 1);
        }
        return *(pArr + 0);
    }
    if (*(pArr + num - 2) < *(pArr + num - 1))
    {
        *(pArr + num - 2) = *(pArr + num - 2) ^ *(pArr + num - 1);
        *(pArr + num - 1) = *(pArr + num - 2) ^ *(pArr + num - 1);
        *(pArr + num - 2) = *(pArr + num - 2) ^ *(pArr + num - 1);
    }
    maxNumByRecur(pArr, num - 1);
}

int main02(void)
{
    int arr[10] = { 1, 2, 3, 4, 15, 18, 4, 3, 2, 1 };
    //for (int i = 0; i < 10 - 1; ++i)
    //{//冒泡算法
    //  if (*(arr + i) > *(arr + i + 1))
    //  {
    //      *(arr + i) = *(arr + i) ^ *(arr + i + 1);
    //      *(arr + i + 1) = *(arr + i) ^ *(arr + i + 1);
    //      *(arr + i) = *(arr + i) ^ *(arr + i + 1);
    //  }
    //}
    //printf("maxNum = %d \n", *(arr + 10 - 1));
    printf("maxNum = %d \n", maxNumByRecur(arr, 10));

    system("pause");
}

程序片段(05):01.大数乘法.c+02.大数乘法递归.c

内容概要:大数乘法

///01.大数乘法.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//01.大数乘法原理解析:
//                  1   2   3
//                  4   5   6
//--------------------
//                  6    12 18
//              5   10   15
//          4   8   12
//          4   13  28    27 18
//          5   6    0    8     8
//注:图形化方式进行解析
void largeNumMul(char * pMultiplicand, char * pMultiplicater, char * pResult)
{
    int candLen = strlen(pMultiplicand);
    int caterLen = strlen(pMultiplicater);

    int places = 0;
    for (int j = caterLen - 1, n = 0; j >= 0; --j, ++n)
    {
        if (0 == *(pMultiplicater + j))
        {
            continue;
        }
        int r1 = 0, r2 = 0;
        char * pTmpStr = (char *)calloc(2048, sizeof(char));
        int m = 0;
        for (int i = candLen - 1, m = 0; i >= 0; --i, ++m)
        {
            r1 = (*(pMultiplicand + j) - '0') * (*(pMultiplicater + i) - '0');
            r2 = *(pTmpStr + m + n) + r1;
            *(pTmpStr + m + n) = r2 % 10;//纵向累加
            *(pTmpStr + m + n + 1) = r2 / 10;//横向进位
        }
        for (places = 0, r2 = 0; places <= m + n + 1 || r2; ++places)
        {
            r1 = *(pResult + places) + *(pTmpStr + places) + r2;
            *(pResult + places) = r1 % 10;//纵向保留
            r2 = r1 / 10;//横向进位
        }
    }
    for (int k = places - 1; k >= 0; --k)
    {
        if (*(pResult + k))
        {
            for (int l = 0; l <= k / 2; ++l)
            {
                char tmpChr = *(pResult + l);
                *(pResult + l) = *(pResult + k - l);
                *(pResult + k - l) = tmpChr;
            }
            return;
        }
    }
    *(pResult + 0) = '0';
    return;
}

int main01(void)
{
    char multiplicand[1024] = { 0 };
    char multiplicater[1024] = { 0 };
    char result[2048] = { 0 };
    scanf("%s%s", multiplicand, multiplicater);
    largeNumMul(multiplicand, multiplicater, result);
    printf("%s * %s = %s \n", multiplicand, multiplicater, result);

    system("pause");
}

///02.大数乘法递归.c
#define _CRT_SECURE_NO_WARNINGS
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_SIZE 100

char str1[MAX_SIZE], str2[MAX_SIZE], str3[MAX_SIZE * 2];

void Init()
{
    for (int i = 0; i < MAX_SIZE * 2; i++)
        str3[i] = '0';
}

void CalcJ(int n, int m, int inc)
{
    if (m >= 0)
    {
        int tmp = (str2[n] - '0') * (str1[m] - '0') + inc + str3[m + n + 1] - '0';
        str3[m + n + 1] = tmp % 10 + '0';
        inc = tmp / 10;
        CalcJ(n, m - 1, inc);
    }
    else if (n >= 0)
    {
        if (inc > 0)
        {
            int tmp = str3[m + n + 1] - '0' + inc;
            str3[m + n + 1] = tmp % 10 + '0';
            inc = tmp / 10;
            CalcJ(n - 1, m, inc);
        }
    }
}

void Work(int n, int m)
{
    if (n == -1)
    {
        return;
    }
    else
    {
        CalcJ(n, m, 0);
        Work(n - 1, m);
    }
}

void Print()
{
    for (int i = 0; i < strlen(str3); i++)
    if (str3[i] != '\0')
        printf("%d", str3[i] - '0');
    printf("\n");
}

int main1()
{
    scanf("%s%s", str1, str2);
    Init();
    Work(strlen(str2) - 1, strlen(str1) - 1);
    Print();
    system("pause");
    return EXIT_SUCCESS;
}

程序片段(06):C99新语法.c

内容概要:C99新语法

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

//01.C99新语法之数组的静态初始化方式:
//  1.根据指定索引实现精确初始化
//  2.其中最大的那个索引代表着最后一个数组元素的位置
//  3.该初始化方式属于栈内存的静态初始化方式
//  4.未能初始化到的元素被默认初始化为0
int main01(void)
{
    int arr[] = { [0] = 1,[1] = 2,[2] = 3,[15] = 10 };
    printf("sizeof(arr) = %d \n", sizeof(arr));
    for (int i = 0; i < sizeof(arr) / sizeof(*(arr + 0)); ++i)
    {
        printf("%d \n", *(arr + i));
    }

    system("pause");
}

//02.C99新语法之静态指定初始化注意事项:
//  1.采用变量指针进行保存数组栈内存首地址的时候
//      需要明确静态初始化的解析类型
//  2.严格区分常量指针还是变量指针
//  注:free();函数只能指定回收堆内存空间
void testStaticArr()
{
    int * pArr = (int[]) { [1] = 3, [5] = 2 };
    printf("pArr = %p \n", pArr);
    //free(pArr);//free();函数不能回收栈内存
    for (int i = 0; i < 6; ++i)
    {
        printf("%d \n", *(pArr + i));
    }
}

int main02(void)
{
    testStaticArr();

    system("pause");
}

//03.C99新语法之结构体变量的指定初始化方式:
//  1.结构体变量的指定初始化方式
//  2.没有被指定初始化的内容会被按照变量内存块儿
//      的特点清为0
//注:结构体和数组的普通变量都可以直接采用指定初始化方式
//      进行初始化,无需明确解析类型(指针方式需要)
//04.C99新语法之布尔类型的变量:
//  用于存储逻辑值
struct MyStruct
{
    int num;
    float fl;
    double db;
    _Bool b;
} myStruct = { .num = 10,.fl = 10.9,.db = 19.8,.b = 0 };

//05.有关数组维度的省略特点:
//  所有数组,都可以省略其最高维度数(括号维度保留),用于表明该数组的类型
//  如果是指向数组的指针,就需要在省略最高维度之后的方括号前面添加(*pArr)
//  注:指向数组的指针(简称数组指针)-->这是一种标准数组的声明方式
int main03(void)
{
    printf("%d, %f, %lf, %d \n", myStruct.num, myStruct.fl, myStruct.db, myStruct.b);
    getchar();
    //指向结构体的指针-->变量指针-->需要明确解析方式-->可以静态初始化-->可以指定初始化
    struct MyStruct * pMyStruct = (struct MyStruct[]) { [0] = { .num = 10 ,.fl = 10.9 ,.db = 19.8,.b = 0 } ,
        [1] = { .num = 10 }
    };

    system("pause");
}

#define MYPRINT(...) printf(__VA_ARGS__);

//06.C99新语法之带参宏的定义方式:
//  1.带参宏的定义格式:
//      #define 带参宏名(...) 表达式(__VA_ARGS__)
//  2.解释:
//      (...):表示传递进来的可变参数
//      __VA__ARGS:代表可变参数的应用位置
//  注:三个点儿...-->采用-->__VA_ARGS进行整体替换
int main04(void)
{
    MYPRINT("%d, %s \n", 10, "Hello China!");

    system("pause");
}

//07.C99新语法之内联函数:
//  C语言当中的内联函数用于避免函数不断的进出栈
//  将该函数保留在特有的栈内存当中!(避免不断进出栈)
__inline void go()
{
    printf("gogogo \n");
}

int main05(void)
{
    go();
    printf("%p \n", go);

    system("pause");
}