C程序设计语言（二）流控制，函数与程序结构

3. 流控制 4. 函数与程序结构

这个部分讲解C语言语句使用的时候，给出了很多C语言函数，实现了日常可能遇到的功能需求，从中可以感受到C语言的简洁之美，摘录如下

• C语言程序一般由许多小的函数组成，而不是由少量大的函数组成

• 折半查找函数, if 语句的用法

• 折半查找充分利用数组已经排好序这个有用的信息，相较于遍历查找，效率提升很多
  
  • 普通查找复杂度是O(N)
  • 折半查找复杂度是O(logN)
• 折半查找必须熟练掌握，很有用

/* BinarySearch 函数：在已经排好序的数组v[]中查找某个元素x */
int binarysearch(int x, int v[], int n)
{
    int low;
    int high;
    int mid;
    low = 0;
    high = n - 1;
    while(low <= high)
    {
        mid = (low + high) / 2;
        if (x > v[mid])
            low = mid + １；
        else if (x < v[mid])
            high = mid - 1;
        else
            return mid;
    }
    return -1;
}

• 统计数字，空白字符及其他字符，switch语句的用法

#include <stdio.h>
int main()
{
    int c;
    int i;
    int nwhite;
    int nother;
    int ndigit[10];

    nwhite = nother = 0;
    for (i = 0; i < 10; i++)
        ndigit[i] = 0;

    while((c = getchar()) != EOF)
    {
        switch(c) 
        {
            case '0': case '1': case '2': case '3': case '4':
            case '5': case '6': case '7': case '8': case '9':
                ndigit[c - '0']++;
                break;
            case ' ':
            case '\t':
            case '\n':
                nwhite++;
                break;
            default:
                nother++;
                break;
        }
    }
    printf("digits = ");
    for (i = 0; i < 10; i++)
        printf(" %d", ndigit[i]);
    printf(", white space = %d, other = %d\n", nwhite, nother);
    retur 0;
}

• shell排序，for循环语句
• shell排序插入排序的一种，关于插入排序请参考插入排序与选择排序
• 关于排序这里不展开，比较难，需要单独整理一篇，这里关注语言本身

/* shellsort函数：按递增顺序对v[]进行排序*/
void shellsort(int v[], int n)
{
    int gap;
    int i, j;
    int temp;

    for(gap = n / 2; gap > 0; gap /= 2)
        for(i = gap; i < n; i++)
            for (j = i - gap; j >= 0 && v[j] > v[j + gap]; j -= gap)
            {
                temp = v[j]
                v[j] = v[j + gap];
                v[j + gap] = temp;
            }
}

• 字符串倒置函数，逗号运算符的使用
• 简洁，s[strlen(s)]是字符串结尾标志’\0’，这个位置之前的元素头尾互换

#include <string.h>
/* reverse函数： 倒置字符串s中各个字符的位置*/
void reverse(shar s[])
{
    int c, i, j;
    for (i = 0, j = strlen(s) - 1; i < j; i++, j--)
    {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}

• 整数转换程字符串的函数，do while语句的使用

#include <string.h>
/* itoa函数：将数字n转换成字符串并保存到s中 */
void itoa(int n, char s[])
{
    int i, sign;

    if ((sign = n ) < 0)
        n = -n;

    i = 0;
    do{
        s[i++] = n % 10 + '0';
    }while((n /= 10) > 0);
    if (sign < 0)
        s[i++] = '-';

    reverse(s);
}

• 删除字符串尾部的空格，制表符和换行符，break的使用
• 从尾部向头部遍历，找到第一个非空字符，加上结束符即可

#include <string.h>
/* trim函数：删除字符串尾部的空格，制表符和换行符 */
int trim(char s[])
{
    int n;
    for (n = strlen(s) - 1; n >= 0; n--)
        if (s[n] != ' ' && s[n] != '\t' && s[n] != '\n')
            break;
    s[n + 1] = '\0';
    return n;
}

• 在字符串中搜索子串的函数

/* strindex函数：返回t在s中的位置，未找到返回-1 */
int strindex(char s[], char t[])
{
    int i, j, k;
    for (i = 0; s[i] != '\0', i++)
    {
        for(j = i, k = 0; t[k] != '\0' && s[j] == t[k]; j++, k++)
            ;
        if (k > 0 && t[k] == '\0')
            return i;
    }
    return -1;
}

• 在main内部声明函数，这样不好，但是没错

void main()
{
    int sum, atoi(char []);
    ...
}

• 函数的作用域

  • 作用域：名字的作用域指可以使用改名字的部分
  • 函数作用域，从函数声明开始到本文件结束
  • 通过头文件方式在文件开头声明函数
  • static 类型的函数，作用域是本c文件，其他文件不可见

• 递归

  • 程序理解的难点，程序设计的爽点
  • 自己调用自己
  • 递归不会节省空间
  • 递归不会节省时间
  • 递归可以使代码简洁，方便处理ADT（抽象数据类型）中的树等递归结构

#include <stdio.h>
/* printd函数：打印十进制数 */
void printd(int n)
{
    if (n < 0)
    {
        putchar('-')
        n = -n;
    }
    if (n / 10)
        printd(n / 10);
    putchar(n % 10 + '0');
}

• 预处理
  
  • #include include可以嵌套，即被include的文件内部还要include别的文件
  • #define
    
    • 太长的话可以分行，用\
    • 作用域，本行到文件结束
    • 可以带参数 #define max(A, B) ((A) > (B)) ? (A) : (B)
    • #undef
    • 扩展成带双引号的字符串 #define dprint(expr) printf(#expr ” = %g\n”, expr)
    • 连接扩展 #define paste(front, back) front ## back
    • 防止重复包含的处理方式
      
      • #if defined
      • #ifndef, #ifdef
      • #if xxx
      • #else, #endif

#if !defined(HDR)
#define HDR
/* hdr.h 头文件 */
...
#endif