程序片段(01):ReplaceAll.c

内容概要:ReplaceAll

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. //01.(删除+替换)所有指定字符串
  7. //  (双索引+双指针)-->(删除+替换)原理
  8. //  注:增加(拓展)+删除(压缩)+修改(压缩|不变|拓展)+查询(不变)
  9. void replaceAll(char ** ppSrcStr, char * pOldStr, char * pNewStr)
  10. {
  11.     char * pSrcStr = *ppSrcStr;//常量指针-->变量指针(同一本体)-->跨函数间接修改常量指针
  12.     int srcStrLen = strlen(pSrcStr);
  13.     int oldStrLen = strlen(pOldStr);
  14.     int newStrLen = strlen(pNewStr);
  15.     char * p1 = pSrcStr;
  16.     char * p2 = pSrcStr;
  17.     if (oldStrLen == newStrLen)
  18.     {
  19.         while (*p1 = *p2)
  20.         {
  21.             int find = 1;
  22.             for (int i = 0; i < oldStrLen; ++i)
  23.             {
  24.                 if ('\0' == *(p2 + i) || *(p2 + i) != *(pOldStr + i))
  25.                 {
  26.                     find = 0;
  27.                     break;
  28.                 }
  29.             }
  30.             if (!find)
  31.             {
  32.                 ++p2;
  33.                 ++p1;
  34.             }
  35.             else
  36.             {
  37.                 for (int i = 0; i < newStrLen; ++i)
  38.                 {
  39.                     *(p2 + i) = *(pNewStr + i);
  40.                 }
  41.             }
  42.         }
  43.     }
  44.     else if (oldStrLen < newStrLen)
  45.     {
  46.         while (*p1 = *p2)
  47.         {
  48.             int find = 1;
  49.             for (int i = 0; i < oldStrLen; ++i)
  50.             {
  51.                 if ('\0' == *(p2 + i) || *(p2 + i) != *(pOldStr + i))
  52.                 {
  53.                     find = 0;
  54.                     break;
  55.                 }
  56.             }
  57.             if (!find)
  58.             {
  59.                 ++p2;
  60.                 ++p1;
  61.             }
  62.             else
  63.             {
  64.                 int m = p2 - pSrcStr;
  65.                 int n = p1 - pSrcStr;
  66.                 pSrcStr = *ppSrcStr = (char *)_recalloc(*ppSrcStr, srcStrLen + newStrLen - oldStrLen + 1, sizeof(char));
  67.                 p2 = pSrcStr + m;
  68.                 p1 = pSrcStr + n;
  69.                 int moveLen = newStrLen - oldStrLen;
  70.                 for (char * p = p2 + strlen(p2); p >= p2; --p)
  71.                 {
  72.                     *(p + moveLen) = *p;
  73.                 }
  74.                 for (int i = 0; i < newStrLen; ++i)
  75.                 {
  76.                     *(p2 + i) = *(pNewStr + i);
  77.                 }
  78.             }
  79.         }
  80.     }
  81.     else
  82.     {
  83.         while (*p1 = *p2)
  84.         {
  85.             int find = 1;
  86.             for (int i = 0; i < oldStrLen; ++i)
  87.             {
  88.                 if ('\0' == *(p2 + i) || *(p2 + i) != *(pOldStr + i))
  89.                 {
  90.                     find = 0;
  91.                     break;
  92.                 }
  93.             }
  94.             if (!find)
  95.             {
  96.                 ++p2;
  97.                 ++p1;
  98.             }
  99.             else
  100.             {
  101.                 for (int i = 0; i < newStrLen; ++i)
  102.                 {//赋值有效字符串
  103.                     *(p2 + oldStrLen - newStrLen + i) = *(pNewStr + i);
  104.                 }
  105.                 p2 += oldStrLen - newStrLen;//跳过无效字符串
  106.             }
  107.         }
  108.     }
  109. }
  111. int main01(void)
  112. {
  113.     int srcStrLen = strlen("12345543211234554321");
  114.     char * pStr = (char *)malloc(srcStrLen + 1);
  115.     strcpy(pStr, "12345543211234554321");
  116.     printf("%s \n", pStr);
  117.     //replaceAll(&pStr, "12345", "ABCDE");
  118.     //replaceAll(&pStr, "123", "ABCDE");
  119.     replaceAll(&pStr, "12345", "ABC");
  120.     printf("%s \n", pStr);
  122.     system("pause");
  123. }

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

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

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main01(void)
  5. {
  6.     char * pInputStr = "abc12345hij1234321jkl1237ol";
  7.     char * pMaxNumStr = NULL;
  8.     int maxNumLen = 0;
  9.     char * pChr = pInputStr;//指向普通字符的指针
  10.     while (*pChr)
  11.     {
  12.         while (!('0' <= *pChr && *pChr <= '9'))
  13.         {
  14.             ++pChr;
  15.         }
  16.         char * pNum = pChr;//指向数字字符的指针
  17.         while ('0' <= *pChr && *pChr <= '9')
  18.         {
  19.             ++pChr;
  20.         }
  21.         if (pChr - pNum > maxNumLen)
  22.         {
  23.             maxNumLen = pChr - pNum;
  24.             pMaxNumStr = pNum;
  25.         }
  26.     }
  27.     printf("%d \n", maxNumLen);
  28.     for (int i = 0; i < maxNumLen; ++i)
  29.     {
  30.         putchar(*(pMaxNumStr + i));
  31.     }
  33.     system("pause");
  34. }

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

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

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int loopJudge(int * pArr, int num)
  5. {
  6.     for (int i = 0; i < num - 1; ++i)
  7.     {
  8.         if (*(pArr + i) > *(pArr + i + 1))
  9.         {
  10.             return 0;
  11.         }
  12.     }
  13.     return 1;
  14. }
  16. //01.递归的高级形式:
  17. //  通过逻辑运算符建立递归关系
  18. int recurJudge(int * pArr, int num)
  19. {
  20.     if (1 == num)//保证判定式成立
  21.         return *(pArr + 0) < *(pArr + 1);
  22.     //形成整体表达式
  23.     return *(pArr + num - 2) < *(pArr + num - 1) && recurJudge(pArr, num - 1);
  24. }
  26. int main01(void)
  27. {
  28.     int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  29.     //printf("%d \n", loopJudge(arr, 10));
  30.     printf("%d \n", recurJudge(arr, 10));
  32.     system("pause");
  33. }

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

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

  1. ///01.数组最大值.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. int maxNumByLoop(int * pArr, int num)
  6. {//打擂算法
  7.     int maxNum = *(pArr + 0);
  8.     for (int i = 1; i < num; ++i)
  9.         if (maxNum < *(pArr + i))
  10.             maxNum = *(pArr + i);
  11.     return maxNum;
  12. }
  14. int maxNumByRecur(int * pArr, int num, int maxValue)
  15. {
  16.     if (0 == num)//表达式恒成立
  17.     {
  18.         if (maxValue < *(pArr + 0))
  19.         {
  20.             maxValue = *(pArr + 0);
  21.         }
  22.         return maxValue;
  23.     }
  24.     if (maxValue < *(pArr + num - 1))
  25.     {//直接数组个数
  26.         maxValue = *(pArr + num - 1);
  27.     }
  28.     maxNumByRecur(pArr, num - 1, maxValue);
  29. }
  31. int main02(void)
  32. {
  33.     int arr[10] = { 1, 4, 5, 9, 18, 13, 2, 0, 12, 8 };
  34.     printf("maxValue = %d \n", maxNumByLoop(arr, 10));
  35.     printf("maxValue = %d \n", maxNumByRecur(arr, 10, 0));
  37.     system("pause");
  38. }
  1. ///02.冒泡求最大值.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. static int maxNumByRecur(int * pArr, int num)
  6. {//递归算法
  7.     if (1 == num)
  8.     {
  9.         if (*(pArr + 0) < *(pArr + 1))
  10.         {
  11.             *(pArr + 0) = *(pArr + 0) ^ *(pArr + 1);
  12.             *(pArr + 1) = *(pArr + 0) ^ *(pArr + 1);
  13.             *(pArr + 0) = *(pArr + 0) ^ *(pArr + 1);
  14.         }
  15.         return *(pArr + 0);
  16.     }
  17.     if (*(pArr + num - 2) < *(pArr + num - 1))
  18.     {
  19.         *(pArr + num - 2) = *(pArr + num - 2) ^ *(pArr + num - 1);
  20.         *(pArr + num - 1) = *(pArr + num - 2) ^ *(pArr + num - 1);
  21.         *(pArr + num - 2) = *(pArr + num - 2) ^ *(pArr + num - 1);
  22.     }
  23.     maxNumByRecur(pArr, num - 1);
  24. }
  26. int main02(void)
  27. {
  28.     int arr[10] = { 1, 2, 3, 4, 15, 18, 4, 3, 2, 1 };
  29.     //for (int i = 0; i < 10 - 1; ++i)
  30.     //{//冒泡算法
  31.     //  if (*(arr + i) > *(arr + i + 1))
  32.     //  {
  33.     //      *(arr + i) = *(arr + i) ^ *(arr + i + 1);
  34.     //      *(arr + i + 1) = *(arr + i) ^ *(arr + i + 1);
  35.     //      *(arr + i) = *(arr + i) ^ *(arr + i + 1);
  36.     //  }
  37.     //}
  38.     //printf("maxNum = %d \n", *(arr + 10 - 1));
  39.     printf("maxNum = %d \n", maxNumByRecur(arr, 10));
  41.     system("pause");
  42. }

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

内容概要:大数乘法

  1. ///01.大数乘法.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  7. //01.大数乘法原理解析:
  8. //                  1   2   3
  9. //                  4   5   6
  10. //--------------------
  11. //                  6    12 18
  12. //              5   10   15
  13. //          4   8   12
  14. //          4   13  28    27 18
  15. //          5   6    0    8     8
  16. //注:图形化方式进行解析
  17. void largeNumMul(char * pMultiplicand, char * pMultiplicater, char * pResult)
  18. {
  19.     int candLen = strlen(pMultiplicand);
  20.     int caterLen = strlen(pMultiplicater);
  22.     int places = 0;
  23.     for (int j = caterLen - 1, n = 0; j >= 0; --j, ++n)
  24.     {
  25.         if (0 == *(pMultiplicater + j))
  26.         {
  27.             continue;
  28.         }
  29.         int r1 = 0, r2 = 0;
  30.         char * pTmpStr = (char *)calloc(2048, sizeof(char));
  31.         int m = 0;
  32.         for (int i = candLen - 1, m = 0; i >= 0; --i, ++m)
  33.         {
  34.             r1 = (*(pMultiplicand + j) - '0') * (*(pMultiplicater + i) - '0');
  35.             r2 = *(pTmpStr + m + n) + r1;
  36.             *(pTmpStr + m + n) = r2 % 10;//纵向累加
  37.             *(pTmpStr + m + n + 1) = r2 / 10;//横向进位
  38.         }
  39.         for (places = 0, r2 = 0; places <= m + n + 1 || r2; ++places)
  40.         {
  41.             r1 = *(pResult + places) + *(pTmpStr + places) + r2;
  42.             *(pResult + places) = r1 % 10;//纵向保留
  43.             r2 = r1 / 10;//横向进位
  44.         }
  45.     }
  46.     for (int k = places - 1; k >= 0; --k)
  47.     {
  48.         if (*(pResult + k))
  49.         {
  50.             for (int l = 0; l <= k / 2; ++l)
  51.             {
  52.                 char tmpChr = *(pResult + l);
  53.                 *(pResult + l) = *(pResult + k - l);
  54.                 *(pResult + k - l) = tmpChr;
  55.             }
  56.             return;
  57.         }
  58.     }
  59.     *(pResult + 0) = '0';
  60.     return;
  61. }
  63. int main01(void)
  64. {
  65.     char multiplicand[1024] = { 0 };
  66.     char multiplicater[1024] = { 0 };
  67.     char result[2048] = { 0 };
  68.     scanf("%s%s", multiplicand, multiplicater);
  69.     largeNumMul(multiplicand, multiplicater, result);
  70.     printf("%s * %s = %s \n", multiplicand, multiplicater, result);
  72.     system("pause");
  73. }
  1. ///02.大数乘法递归.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #define MAX_SIZE 100
  9. char str1[MAX_SIZE], str2[MAX_SIZE], str3[MAX_SIZE * 2];
  11. void Init()
  12. {
  13.     for (int i = 0; i < MAX_SIZE * 2; i++)
  14.         str3[i] = '0';
  15. }
  17. void CalcJ(int n, int m, int inc)
  18. {
  19.     if (m >= 0)
  20.     {
  21.         int tmp = (str2[n] - '0') * (str1[m] - '0') + inc + str3[m + n + 1] - '0';
  22.         str3[m + n + 1] = tmp % 10 + '0';
  23.         inc = tmp / 10;
  24.         CalcJ(n, m - 1, inc);
  25.     }
  26.     else if (n >= 0)
  27.     {
  28.         if (inc > 0)
  29.         {
  30.             int tmp = str3[m + n + 1] - '0' + inc;
  31.             str3[m + n + 1] = tmp % 10 + '0';
  32.             inc = tmp / 10;
  33.             CalcJ(n - 1, m, inc);
  34.         }
  35.     }
  36. }
  38. void Work(int n, int m)
  39. {
  40.     if (n == -1)
  41.     {
  42.         return;
  43.     }
  44.     else
  45.     {
  46.         CalcJ(n, m, 0);
  47.         Work(n - 1, m);
  48.     }
  49. }
  51. void Print()
  52. {
  53.     for (int i = 0; i < strlen(str3); i++)
  54.     if (str3[i] != '\0')
  55.         printf("%d", str3[i] - '0');
  56.     printf("\n");
  57. }
  59. int main1()
  60. {
  61.     scanf("%s%s", str1, str2);
  62.     Init();
  63.     Work(strlen(str2) - 1, strlen(str1) - 1);
  64.     Print();
  65.     system("pause");
  66.     return EXIT_SUCCESS;
  67. }

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

内容概要:C99新语法

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. //01.C99新语法之数组的静态初始化方式:
  5. //  1.根据指定索引实现精确初始化
  6. //  2.其中最大的那个索引代表着最后一个数组元素的位置
  7. //  3.该初始化方式属于栈内存的静态初始化方式
  8. //  4.未能初始化到的元素被默认初始化为0
  9. int main01(void)
  10. {
  11.     int arr[] = { [0] = 1,[1] = 2,[2] = 3,[15] = 10 };
  12.     printf("sizeof(arr) = %d \n", sizeof(arr));
  13.     for (int i = 0; i < sizeof(arr) / sizeof(*(arr + 0)); ++i)
  14.     {
  15.         printf("%d \n", *(arr + i));
  16.     }
  18.     system("pause");
  19. }
  21. //02.C99新语法之静态指定初始化注意事项:
  22. //  1.采用变量指针进行保存数组栈内存首地址的时候
  23. //      需要明确静态初始化的解析类型
  24. //  2.严格区分常量指针还是变量指针
  25. //  注:free();函数只能指定回收堆内存空间
  26. void testStaticArr()
  27. {
  28.     int * pArr = (int[]) { [1] = 3, [5] = 2 };
  29.     printf("pArr = %p \n", pArr);
  30.     //free(pArr);//free();函数不能回收栈内存
  31.     for (int i = 0; i < 6; ++i)
  32.     {
  33.         printf("%d \n", *(pArr + i));
  34.     }
  35. }
  37. int main02(void)
  38. {
  39.     testStaticArr();
  41.     system("pause");
  42. }
  44. //03.C99新语法之结构体变量的指定初始化方式:
  45. //  1.结构体变量的指定初始化方式
  46. //  2.没有被指定初始化的内容会被按照变量内存块儿
  47. //      的特点清为0
  48. //注:结构体和数组的普通变量都可以直接采用指定初始化方式
  49. //      进行初始化,无需明确解析类型(指针方式需要)
  50. //04.C99新语法之布尔类型的变量:
  51. //  用于存储逻辑值
  52. struct MyStruct
  53. {
  54.     int num;
  55.     float fl;
  56.     double db;
  57.     _Bool b;
  58. } myStruct = { .num = 10,.fl = 10.9,.db = 19.8,.b = 0 };
  60. //05.有关数组维度的省略特点:
  61. //  所有数组,都可以省略其最高维度数(括号维度保留),用于表明该数组的类型
  62. //  如果是指向数组的指针,就需要在省略最高维度之后的方括号前面添加(*pArr)
  63. //  注:指向数组的指针(简称数组指针)-->这是一种标准数组的声明方式
  64. int main03(void)
  65. {
  66.     printf("%d, %f, %lf, %d \n", myStruct.num, myStruct.fl, myStruct.db, myStruct.b);
  67.     getchar();
  68.     //指向结构体的指针-->变量指针-->需要明确解析方式-->可以静态初始化-->可以指定初始化
  69.     struct MyStruct * pMyStruct = (struct MyStruct[]) { [0] = { .num = 10 ,.fl = 10.9 ,.db = 19.8,.b = 0 } ,
  70.         [1] = { .num = 10 }
  71.     };
  73.     system("pause");
  74. }
  76. #define MYPRINT(...) printf(__VA_ARGS__);
  78. //06.C99新语法之带参宏的定义方式:
  79. //  1.带参宏的定义格式:
  80. //      #define 带参宏名(...) 表达式(__VA_ARGS__)
  81. //  2.解释:
  82. //      (...):表示传递进来的可变参数
  83. //      __VA__ARGS:代表可变参数的应用位置
  84. //  注:三个点儿...-->采用-->__VA_ARGS进行整体替换
  85. int main04(void)
  86. {
  87.     MYPRINT("%d, %s \n", 10, "Hello China!");
  89.     system("pause");
  90. }
  92. //07.C99新语法之内联函数:
  93. //  C语言当中的内联函数用于避免函数不断的进出栈
  94. //  将该函数保留在特有的栈内存当中!(避免不断进出栈)
  95. __inline void go()
  96. {
  97.     printf("gogogo \n");
  98. }
  100. int main05(void)
  101. {
  102.     go();
  103.     printf("%p \n", go);
  105.     system("pause");
  106. }

20160219.CCPP体系详解(0029天)的更多相关文章

  1. 20160129.CCPP体系详解(0008天)

    程序片段(01):函数.c+call.c+测试.cpp 内容概要:函数 ///函数.c #include <stdio.h> #include <stdlib.h> //01. ...

  2. 20160226.CCPP体系详解(0036天)

    程序片段(01):01.多线程.c+02.多线程操作.c 内容概要:多线程 ///01.多线程.c #include <stdio.h> #include <stdlib.h> ...

  3. 20160208.CCPP体系详解(0018天)

    程序片段(01):main.c 内容概要:PointWithOutInit #include <stdio.h> #include <stdlib.h> //01.野指针详解: ...

  4. 20160206.CCPP体系详解(0016天)

    代码片段(01):.指针.c+02.间接赋值.c 内容概要:内存 ///01.指针 #include <stdio.h> #include <stdlib.h> //01.取地 ...

  5. 20160205.CCPP体系详解(0015天)

    程序片段(01):01.杨辉三角.c 内容概要:杨辉三角 #include <stdio.h> #include <stdlib.h> #define N 10 //01.杨辉 ...

  6. 20160204.CCPP体系详解(0014天)

    程序片段(01):define.h+data.h&data.c+control.h&control.c+view.h&view.c+AI.h&AI.c+main.c 内 ...

  7. 20160203.CCPP体系详解(0013天)

    程序片段(01):数组.c+02.数组初始化语法.c 内容概要:数组 ///01.数组.c #include <stdio.h> #include <stdlib.h> //0 ...

  8. 20160128.CCPP体系详解(0007天)

    以下内容有所摘取,进行了某些整理和补充 论浮点数的存储原理:float浮点数与double浮点数的二进制存储原理–>阶码 浮点数转二进制 1.整数int类型和浮点数float类型都是占用4个字节 ...

  9. 20160127.CCPP体系详解(0006天)

    程序片段(01):msg.c 内容概要:线程概念 #include <stdio.h> #include <stdlib.h> #include <Windows.h&g ...

随机推荐

  1. 二 Djano模型层之模型字段选项

    字段选项 以下参数是全部字段类型都可用的,而且是可选的 null 如果为True,Django将在数据库中将空值存储为NULL.默认值为False 对于字符串字段,如果设置了null=True意味着& ...

  2. [SPOJ 4155]OTOCI

    Description 题库链接 给你 \(n\) 个节点,让你兹磁以下操作,维护一棵树: 动态加边: 修改点权: 询问路径上点权和. \(1\leq n\leq 30000\) Solution 好 ...

  3. POJ2449 Remmarguts' Date

    "Good man never makes girls wait or breaks an appointment!" said the mandarin duck father. ...

  4. 【HNOI2017】影魔

    题目描述 影魔,奈文摩尔,据说有着一个诗人的灵魂.事实上,他吞噬的诗人灵魂早已成千上万.千百年来,他收集了各式各样的灵魂,包括诗人.牧师.帝王.乞丐.奴隶.罪人,当然,还有英雄. 每一个灵魂,都有着自 ...

  5. 【BZOJ1483】【HNOI2009】梦幻布丁

    题意:n个连续的点,有若干种颜色,每个颜色会因为某些操作变为另一种颜色,动态查询颜色段数. 解题思路:对每个颜色开一棵平衡树启发式合并应该是最裸的想法,但是我们有更优的! 考虑对每个颜色利用链表储存它 ...

  6. hdu 1890 splay树

    Robotic Sort Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Tot ...

  7. 一则利用内核漏洞获取root权限的案例【转】

    转自:https://blog.csdn.net/u014089131/article/details/73933649 目录(?)[-] 漏洞描述 漏洞的影响范围 漏洞曝光时间 漏洞产生的原因 漏洞 ...

  8. 缓冲区(buffer)与缓存(cache)

    下面介绍缓冲区的知识. 一.什么是缓冲区 缓冲区(buffer),它是内存空间的一部分.也就是说,在内存空间中预留了一定的存储空间,这些存储空间用来缓冲输入或输出的数据,这部分预留的空间就叫做缓冲区, ...

  9. eclipse创建web项目修改路径

  10. 使用Fiddler改变线上js文件的引用路径

    一般的项目开发都是先在本地环境开发,测试环境中完成测试,最后再提交到线上环境. 但是由于版本构建工具有时出现bug或者一些缓存的因素导致测试环境代码可能和线上不一样,这是多么蓝瘦的事情.此处说的是在原 ...