程序设计入门-C语言基础知识-翁恺-第六周：数组-详细笔记（六）

目录

• 第六章：数组
  • 6-1 数组
  • 6-2 数组计算
  • 6.3 课后习题

第六章：数组

6-1 数组

题目：让用户输入一组整数以-1结束输入，算出这组数的平均值，而且输出大于平均值的数。

• 咱们须要记录用户全部输入的数字才能在判断出平均值后输出大于平均值的数，这里要用到一个新的数据类型数组。

程序实现：

#ifndef biggerThanAvg_h 
#define biggerThanAvg_h

#include <stdio.h>
void biggerThanAvg(void);
#endif


#include "biggerThanAvg.h"

void biggerThanAvg(void)
{
 int x;
 double sum = 0;
 double avg = 0;
 int cnt = 0;
 int number[100];
 printf("请输入一些整数以-1结束：");
 scanf("%d", &x);
    

 while (x != -1)
 {
  number[cnt] = x;
  sum += x;
  cnt++;
  scanf("%d", &x);
 }

 if (cnt > 0)
 {
  avg = sum / cnt;
  printf("%f\n", avg);
  for (int i = 0; i < cnt; i++)
  {

   if (number[i] > avg)
   {
    printf("%d\n", number[i]);
   }
  }
 }
}


#include <stdio.h>
#include "biggerThanAvg.h"

int main(int argc, char *argv[])
{
 biggerThanAvg();
 return 0; 
}

测试样例：

请输入一些整数以-1结束：1 2 3 4 5 6 7 8 9 -1
5.000000
6
7
8
9

--------------------------------
Process exited after 9.368 seconds with return value 0

定义数组

• <类型> 变量名称[元素数量];
• int grades[100];
• double weight[20];
• 元素数量必须是整数
• C99以前：元素数量必须是编译时刻肯定的字面量、常量

数组

• 是一种容器（放东西的东西），特色是：
  • 其中全部的元素具备相同的数据类型
  • 一旦建立，不能改变大小
  • （数组中的元素在内存中是连续依次排列的）

数组的单元

• 数组的每一个单元就是数组类型的一个变量
• 使用数组时放在[]中的数字叫作下标或索引，下标从0开始计数：
  • grades[0]
  • grades[99]
  • average[5]

有效的下标范围

• 编译器和运行环境都不会检查数组下标是否越界，不管是对数组单元作读仍是写
• 一旦程序运行，越界数组可能形成问题，致使程序崩溃
  • segmentation fault
• 可是也可能运气好，没形成严重的后果
• 因此这是程序员的责任来保证程序只使用有效的下标值：[0,数组的大小 - 1]

使用数组程序的对应操做

1. 数组大小
2. 定义数组
3. 初始化数组
4. 数组参与运算
5. 遍历数组输出

6-2 数组计算

数组初始化

• 数组的集成初始化
  • int a[] = {2,4,5,7,3,4,5,6,7};
• 集成初始化时的定位C99 ONLY
  • int a[10] = {
    [0] = 2, [2] = 3, 6,
    ]
• 用[n]在初始化数据中给出定位
• 没有定位的数据接在前面的位置后面，好比6就接在3的位置
• 其余位置的值补零
• 也能够不给出数组大小让编译器算
• 特别适合初始数据稀疏的数组

数组的大小

• sizeof给出整个数组所占据的内容的大小，单位是字节
  • sizeof(a)/sizeof(a[0])
• sizeof(a[0])给出数组中单个元素的大小，因而相除就获得了数组的单元个数
• 这样的代码，一旦修改数组中初始的数据，不须要修改遍历的代码

数组的赋值

• 数组遍历自己不能被赋值
• 要把一个数组的全部元素交给另外一个数组，必须采用遍历
  • for (i=0; i<length; i++){ b[i] = a[i]; }

遍历数组

• 一般都是使用for循环，让循环变量i从0到小于数组的长度，这样循环体内最大的i正好是数组最大的有效下标
• 常见的错误是：
  • 循环结束条件是小于等于数组长度，或；
  • 离开循环后，继续用i的值来作数组元素的下标

*数组传参

• 数组做为函数参数时，每每必须再用另外一个参数来传入数组的大小
• 数组在做为函数参数时：
  • 不能在[]中给出数组的大小
  • 不能再利用sizeof来计算数组元素个数

二维数组的初始化
int a[][5] ={
{0,1,2,3,4},
{2,3,4,5,6}
}

• 列数是必须给出的，行数能够由编译器来数
• 每行一个{}，逗号分隔
• 最后的逗号能够存在，有古老的传统
• 若是省略，表示补零
• 也能够用定位（* C99 ONLY）

6.3 课后习题

一、题目内容： 题目内容：
一个多项式能够表达为 x 的各次幂与系数乘积的和，好比：
2χ 6 +3χ 5 +12χ 3 +6χ+20
如今，你的程序要读入两个多项式，而后输出这两个多项式的和，也就是把对应的幂上的系
数相加而后输出。
程序要处理的幂最大为 100。
输入格式:
总共要输入两个多项式，每一个多项式的输入格式以下：
每行输入两个数字，第一个表示幂次，第二个表示该幂次的系数，全部的系数都是整数。第
一行必定是最高幂，最后一行必定是 0 次幂。
注意第一行和最后一行之间不必定按照幂次下降顺序排列；若是某个幂次的系数为 0，就不
出如今输入数据中了；0 次幂的系数为 0 时仍是会出如今输入数据中。
输出格式：
从最高幂开始依次降到 0 幂，如：
2x6+3x5+12x3-6x+20
注意其中的 x 是小写字母 x，并且全部的符号之间都没有空格，若是某个幂的系数为 0 则
不须要有那项。
输入样例：
6 2
5 3
3 12
1 6
0 20
6 2
5 3
2 12
1 6
0 20
输出样例：
4x6+6x5+12x3+12x2+12x+40

题目分析：

• 求和其实就是将相同幂的常数项相加。
• 要处理的最大的幂为100个
• 能够用一个长度为100数组arr来存储两个多项式D1和D2的结果。
• 用户第一次输入 0 n 表明第一个多项式结束，第二次输入 0 n表明第二个多项式结束
• 咱们用arr[0]表示多项式的系数为0的这个项的系数，1表示系数为1这个项的系数依此类推
• 用户每输入一个多项式，根据幂次m将系数累加到对应的arr[m]中，直到用户输入完全部的多项式。
• 最后从最高的系数开始输出整个多项式，若是某个幂次系数为0则不作输出，系数为0的幂次表明这个幂次下没有多项式。所以咱们在作累加时须要记录最高的系数，以便输出。

程序实现：

#include <stdio.h>
#include "sumOfPolynomial.h";

int main(int argc, char *argv[])
{
 sumOfPolynomial();
 return 0;
}


#ifndef sumOfPolynomial_h
#define sumOfPolynomial_h

#include <stdio.h>
void sumOfPolynomial(void);
#endif

#include "sumOfPolynomial.h"

void sumOfPolynomial(void)
{
    int arr[100] = {0};
    int polynomialIndex = 0; //为2时终止循环
    int power = 0; //幂次
    int coefficient = 0; //系数
    int maxPower = 0; //最高幂
    int i;
    printf("请输入两个多项式，幂次和系数以空格分开，幂次从高到低最后一项是0次幂：\n");
    //输入累加求和
    do
    {
        scanf("%d %d", &power, &coefficient);
        if (power == 0)
        {
            polynomialIndex++;
        }
        if (power > maxPower)
        {
            maxPower = power;
        }
        arr[power] += coefficient;

    } while (polynomialIndex < 2);

    //输出结果
    for (i = maxPower; i > -1; i--)
    {
        if (arr[i] > 0)
        {
            if (i == 0)
            {
                printf("%d", arr[i]);
            }
            else
            {
                if (i == 1)
                {
                    printf("%dx", arr[i]);
                }
                else
                {
                    printf("%dx%d", arr[i], i);
                }
            }
        }
        //不是最后一项且下一项的系数大于0才拼接加号
        if (i > 0 && arr[i - 1] > 0)
        {
            printf("+");
        }
    }
    printf("\n");
}

测试样例：

请输入两个多项式，幂次和系数以空格分开，幂次从高到低最后一项是0次幂：
6 2
5 3
3 12
1 6
0 20
6 2
5 3
3 12
1 6
2 3
0 20
4x6+6x5+24x3+3x2+12x+40

--------------------------------
Process exited after 40.41 seconds with return value 0

请输入两个多项式，幂次和系数以空格分开，幂次从高到低最后一项是0次幂：
2 6
0 0
3 6
0 0
6x3+6x2

--------------------------------
Process exited after 21.46 seconds with return value 0

二、题目内容：
给定一个 n*n 矩阵 A。矩阵 A 的鞍点是一个位置（i，j），在该位置上的元素是第 i 行上的
最大数，第 j 列上的最小数。一个矩阵 A 也可能没有鞍点。
你的任务是找出 A 的鞍点。
输入格式:
输入的第 1 行是一个正整数 n, （1<=n<=100），而后有 n 行，每一行有 n 个整数，同
一行上两个整数之间有一个或多个空格。
输出格式：
对输入的矩阵，若是找到鞍点，就输出其下标。下标为两个数字，第一个数字是行号，第二
个数字是列号，均从 0 开始计数。
若是找不到，就输出
NO
题目所给的数据保证了不会出现多个鞍点。
输入样例：
4
1 7 4 1
4 8 3 6
1 6 1 2
0 7 8 9
输出样例：
2 1

题目分析：

• 既然是一个n*n的矩阵，咱们能够用一个二维数组arr[n][n]来存储这个矩阵。
• 鞍点是i行上最大的数，j列上最小的数。
• 获取一行中最大的数num，再判断num是否该列最小的数若是是则为此矩阵的一个鞍点，不然继续判断下一行。

程序实现：

#include <stdio.h>
#include "getSaddlePointOfMatrix.h"

int main(int argc, char *argv[])
{
 getSaddlePointOfMatrix();
 return 0;
}

#ifndef getSaddlePointOfMatrix_h
#define getSaddlePointOfMatrix_h

#include <stdio.h>
#include <limits.h>
void getSaddlePointOfMatrix(void);
int getMaxNumberColIndexByRow(int arr[4][4], int rowIndex, int colCount);
int getMinNumberByCol(int arr[4][4], int colIndex, int rowCount);
#endif
#include "getSaddlePointOfMatrix.h"
//获取一行中最大值的列坐标
int getMaxNumberColIndexByRow(int arr[4][4], int rowIndex, int colCount)
{
    int maxNumber = INT_MIN;//int最小值
    int maxColIndex = 0;
    int i;
    for (i = 0; i < colCount; i++)
    {
        if (arr[rowIndex][i] > maxNumber)
        {
            maxNumber = arr[rowIndex][i];
            maxColIndex = i;
        }
    }
    return maxColIndex;
}
//获取一列中最小的值
int getMinNumberByCol(int arr[4][4], int colIndex, int rowCount)
{
    int minNumber = INT_MAX;//int最大值
    int i;
    for (i = 0; i < rowCount; i++)
    {
        if (arr[i][colIndex] < minNumber)
        {
            minNumber = arr[i][colIndex];
        }
    }
    return minNumber;
}

void getSaddlePointOfMatrix(void)
{
    int i, j;
    int rowIndex, colIndex;
    int maxRowNumber = 0;
    int minColNumber = 0;
    int n = 4;
    int isHaveSaddlePoint = 0;
    int arr[4][4] = {
        {1, 7, 4, 1},
        {4, 8, 3, 6},
        {1, 6, 1, 2},
        {0, 7, 8, 9}};

    //判断每一行的最大值是否为该列的最小值
    for (i = 0; i < n; i++)
    {
        colIndex = getMaxNumberColIndexByRow(arr, i, n);
        maxRowNumber = arr[i][colIndex];
        minColNumber = getMinNumberByCol(arr, colIndex, n);
        if (maxRowNumber == minColNumber)
        {
            isHaveSaddlePoint = 1;
            rowIndex = i;
            break;
        }
    }

    if (isHaveSaddlePoint)
    {
        printf("%d %d\n", rowIndex, colIndex);
    }
    else
    {
        printf("NO\n");
    }
}

tips:这里为了方便测试将数组写死在程序了，你能够试着把这个改成用户输入。

** 思考**

• 是否也能够先求每一列的最小数，让后判断该数是不是所在行最大的数呢？
• 这里的算法复杂度O=n₂ ，是否有算法复杂度为logn的算法呢？
• 这里只求了一个鞍点，若是有多个鞍点时如何改进咱们的算法使得能够计算多个鞍点呢？

测试样例：

2 1

--------------------------------
Process exited after 0.1303 seconds with return value 0