C 语言答疑-02#

数组能够解决的基本问题#

• 给出 $N$ 个数，计算它们的平均数

#include <stdio.h>
int main()
{
    int n, sum = 0, x;
    scanf("%d", &n);
    for(int i=1; i<=n; i++)
    {
        scanf("%d", &x);
        sum += x;
    }
    printf("%lf", (double)sum / n);
    return 0;
}

注意到不需要记录每一个输入的数

• 给出 $N$ 个数（$N \le 100$），输出所有大于平均数的数

#include <stdio.h>
const int maxn = 105;
int main()
{
    int n, sum = 0;
    int a[maxn]; //定义数组
    double avg;
    scanf("%d", &n);
    for(int i=1; i<=n; i++)
    {
        scanf("%d", &a[i]); //读入数组
        sum += a[i];
    }
    avg = (double)sum / n;
    for(int i=1; i<=n; i++) //遍历数组
    {
		if(a[i] > avg) printf("%d ", a[i]); //输出数组元素
    }
    return 0;
}

要记录很多数字，需要使用数组存储

数组的定义#

/*
 * 一维数组
 */
<变量类型> <变量名称>[元素数量];

int numbers[100];
double numberss[100];
for(int i=1; i<=n; i++)
	scanf("%d", numbers[i]);
/*
 * 二维数组
 */
<变量类型> <变量名称>[第一维长度][第二维长度];

int numbers[100][100];

• 元素数量必须是整数
• C99 标准之前，定义数组时元素数量应是常量或用宏定义实现
• C99 标准之后，在函数定义数组时元素的数量可以是变量，但全局变量数组定义的元素数量仍只能使用宏定义

数组的集成初始化#

• 一维数组

  int a[1050] = {0, 1, 1, 2, 3, 5, 8, 13,};
  
  int a[] = {0, 1, 1, 2, 3, 5, 8, 13,};
  
  int a[1050] = { [1] = 1, 1, 2, 3, 5, 8, 13,};

• 二维数组

  int a[105][105] =
  {
      {0, 1, 1, 2, 3, 5, 8, 13,},
      {0, 1, 2, 4, 8, 16, 32, 64,},
  };
  int b[][4] =
  {
      {0, 1, 2, 3,},
      {0, 2, 4, 6,},
  };

• 二维数组第二维长度必须被定义

• 将变量作为数组定义的元素数量并作集成初始化的注意事项

  以下定义方式在 C 语言中可以通过编译

  #include <stdio.h>
  #define maxn 100
  int main()
  {
      int a[maxn] = {0, 1, 2, 3,};
      return 0;
  }
  
  ------------------------------
  
  #include <stdio.h>
  int main()
  {
      int a[100] = {0, 1, 2, 3,};
      return 0;
  }
  
  ------------------------------
  
  #include <stdio.h>
  int main()
  {
      const int maxn = 100;
      int a[maxn] = {0, 1, 2, 3,};
      return 0;
  }
  
  ------------------------------
  
  #include <stdio.h>
  int main()
  {
      int maxn = 100;
      int a[maxn] = {0, 1, 2, 3,};
      return 0;
  }

  以下定义方式在 C 语言中无法通过编译，但是在 C++中可以

  #include <stdio.h>
  const int maxn = 100;
  int main()
  {
      int a[100] = {0, 1, 2, 3,};
      return 0;
  }
  
  -------------------------------
  
  #include <stdio.h>
  int main()
  {
      const int maxn = 100;
      int a[100] = {0, 1, 2, 3,};
      return 0;
  }

数组的赋值#

• 错误示范

  int a[1050] = {0, 1, 2, 3, 4, 5,};
  int b[1050];
  b = a;

• 正确示范

  int a[1050] = {0, 1, 2, 3, 4, 5,};
  int b[1050];
  for(int i=0; i<=5; i++)
      b[i] = a[i];

数组的遍历#

• 将数组从头至尾验视一次

• 一般使用for循环进行数组遍历

• 一些遍历数组的例子

  • 数组的遍历赋值

    for(int i=1; i<=n; i++)
        b[i] = a[i];

  • 数组的遍历初始化

    for(int i=1; i<=n; i++)
       a[i] = 0;

  • 遍历数组查找元素

    for(int i=1; i<=n; i++)
    {
        if(key == a[i])
        {
            ans = i;
            break;
        }
    }

  • 输出比平均值大的数

    for(int i=1; i<=n; i++)
    {
        if(a[i] > avg)
        {
            printf("%d ", a[i]);
        }
    }

  • 输出数组中所有值

    for(int i=1; i<=n; i++)
    {
        printf("%d ", a[i]);
    }

数组作为函数的参数#

• 对于一维数组，不能在[]中给出数组的大小

• 无法再利用sizeof()函数给出数组的大小

• 往往需要再传入一个变量来描述数组大小

  int search(int key, int a[], int len)
  {
      int ans = -1;
      for(int i=1; i<=len; i++)
      {
          if(a[i] == key)
          {
              ans = i;
              break;
          }
      }
      return ans;
  }

字符串简介#

char s[100];

char str[100] = "Hello World!!!";

char s[100];
scanf("%s", s);
printf("%s", s);

数组其他注意事项#

• 数组是一种容器，有如下特点：

  • 一个数组中所有元素类型相同
  • 数组一旦定义，不能改变大小
  • 任意维度的数组在内存中的排列是连续的

• 数组中的每一个单元是数组类型的一个变量，使用数组时[]中的数字称为下标或索引，下标从$0$开始计数

• 一个拥有$n$个元素的数组，下标的范围是$[0, n-1]$，以大于等于$n$的下标访问数组可能会造成数组越界导致程序崩溃，但是编译器在编译时并不会检查数组是否越界，因此务必保证程序只使用有效下标访问数组

• 创建数组时，应给予冗余的数组元素个数，如

  #include <cstdio>
  const int maxn = 1050; //对于1e3的数据范围，给予额外50个元素
  int main()
  {
      int n;
      int a[maxn];
      scanf("%d", &n);
      for(int i=1; i<=n; i++)
          scanf("%d", &a[i]);
      return 0;
  }

  因数组越界而扣分所造成的损失比计算机内部多几个int所造成的内存消耗严重得多（

数组的应用#

整数是怎么表达的——原码，反码，补码#

• 没什么目的，只是为了方便计算

各数据类型的表达范围与自然溢出#

• int类型有 32 位，表达范围为$[-2^{31}, 2^{31}-1]$
• unsigned int数据范围是$[0, 2^{32}-1]$

各数据类型的输入输出#

浮点数#

• 令人头疼的精度问题

  #include <stdio.h>
  
  int main()
  {
      if(1.1 + 0.1 == 1.2)
          printf("YES!!!");
      else
          printf("NO!!!");
      return 0;
  }

  以上程序输出的是NO

• 1.1 + 0.1为什么不等于1.2

  0.1转化为二进制的结果是一个循环小数:
  0.00011001100110011001100110011001100110011001100110011010
  double类型在二进制下的精度是53位有效数字，超出部分四舍五入
  
  同理将1.1转化为二进制:
  1.0001100110011001100110011001100110011001100110011010
  
  二者相加
   	0.00011001100110011001100110011001100110011001100110011010
  +	1.0001100110011001100110011001100110011001100110011010
  ---------------------------------------------------------------
   	1.0011001100110011001100110011001100110011001100110100
  
  
  
  将结果转化为十进制：
  1.20000000000000018
  
  将1.2转化为二进制：
  1.0011001100110011001100110011001100110011001100110011
  
  与1.1+0.1的二进制结果:
  1.0011001100110011001100110011001100110011001100110100
  相比较
  
  二者不同

• 解决方案

  #include <stdio.h>
const double eps = 1e-6;
  double eps(double x)
  {
      return x < 0 ? -x : x;
  }
  int main()
  {
      if((abs(1.1 + 0.1 - 1.2) < eps)
          printf("YES!!!");
      else
          printf("NO!!!");
      return 0;
  }