学期（2022-2023-1） 学号（20221320） 《计算机基础与程序设计》第十四周学习总结

作业信息

教材学习内容总结

二进制文件和文本文件
文件的开和关闭
按字符读写文件
按格式读写文件
按数据块读写文件

教材学习中的问题和解决过程

• 问题1：文件处理方式的汇总
• 问题的解决方案：
  

代码调试中的问题和解决过程

• 问题1：
  用动态数组编程输入任意m个班学生（每班n个学生）的某门课的成绩，计算最高分，并指出具有该最高分成绩的学生是第几个班的第几个学生。其中，m和n的值由用户从键盘任意输入（不限定m和n的上限值）。
  输入提示信息：
  "Input array size m,n:"
  "Input %d*%d array:\n"
  输入格式："%d,%d"
  输出提示信息和格式："maxScore = %d, class = %d, number = %d\n"
• 问题1解决方案：

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

int main()
{
    int m,n,i,j;
    int max = 0;
    int x,y;
    printf("Input array size m,n:");
    scanf("%d,%d", &m,&n);
    printf("Input %d*%d array:\n", m,n);
    int* p = (int*)malloc(m*n*sizeof(int));
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
        {
            scanf("%d", p+i+j );
            if(max < *(p+i+j))
            {
                max = *(p+i+j);
                x = i+1;
                y = j+1;
            }
        }
    }
    free(p);
    p == NULL;
    printf("maxScore = %d, class = %d, number = %d\n", max, x, y);
}

• 问题2：
  按如下函数原型编程从键盘输入一个m行n列的二维数组，然后计算数组中元素的最大值及其所在的行列下标值。其中，m和n的值由用户键盘输入。已知m和n的值都不超过10。
  void InputArray(int *p, int m, int n);
  int FindMax(int *p, int m, int n, int *pRow, int pCol);
  输入提示信息：
  "Input m, n:"
  "Input %d%d array:\n"
  输入格式："%d,%d"
  输出提示信息和格式："max = %d, row = %d, col = %d\n"
  我的错误代码：

#include <stdio.h>
#include <stdlib.h>
void InputArray(int *p, int m, int n);
int  FindMax(int *p, int m, int n, int *pRow, int *pCol);
int main()
{
    int m,n,max,*p=NULL,*pRow=NULL,*pCol=NULL;
    printf("Input m, n:");
    scanf("%d,%d",&m,&n);
    if(m>10||n>10)
        exit(0);
    p=(int*)calloc(m*n,sizeof(int));
    if(p==NULL)
    {
        printf("No enough memory!\n");
        exit(1);
    }
    InputArray(p,m,n);
    max=FindMax(p,m,n,pRow,pCol);
    printf("max = %d, row = %d, col = %d\n",max,*pRow,*pCol);
    free(p);
    return 0;
}

void InputArray(int *p, int m, int n)
{
    printf("Input %d*%d array:\n",m,n);
    int i,j;
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
        {
            scanf("%d",&p[i*n+j]);
        }
    }
}
int  FindMax(int *p, int m, int n, int *pRow, int *pCol)
{
    int i,j,max=0;
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
        {
            if(max<p[i*n+j])
            {
                max=p[i*n+j];
                *pRow=i;
                *pCol=j;
            }
        }
    }
    return max;
}

问题：程序运行结果没有输出。

• 问题2解决方案：
  不一定要用动态内存分配

#include <stdio.h>
#define M 10
#define N 10
void InputMatrix(int *p, int m, int n);
int FindMax(int *p, int m, int n, int *pRow, int *pCol);
int main()
{	  		 	      
    int a[M][N], m, n, row, col, max;
    printf("Input m, n:");
    scanf("%d,%d", &m, &n);
    InputMatrix(*a, m, n);
    max = FindMax(*a, m, n, &row, &col);
    printf("max = %d, row = %d, col = %d\n", max, row, col);
    return 0;
}	  		 	      
/* 函数功能：输入m*n矩阵的值 */
void InputMatrix(int *p, int m, int n)
{	  		 	      
    int i, j;
    printf("Input %d*%d array:\n", m, n);
    for (i = 0; i < m; i++)
    {	  		 	      
        for (j = 0; j < n; j++)
        {	  		 	      
            scanf("%d", &p[i * n + j]);
        }
    }
}	  		 	      
/* 函数功能：在m*n矩阵中查找最大值及其所在的行列号 */
int FindMax(int *p, int m, int n, int *pRow, int *pCol)
{	  		 	      
    int i, j, max = p[0];
    *pRow = 0;
    *pCol = 0;
    for (i = 0; i < m; i++)
    {	  		 	      
        for (j = 0; j < n; j++)
        {	  		 	      
            if (p[i * n + j] > max)
            {	  		 	      
                max = p[i * n + j];
                *pRow = i;              /*记录行下标*/
                *pCol = j;              /*记录列下标*/
            }
        }
    }
    return max;
}	  		 

• 问题3：
  用二维数组的列指针作为函数实参，实现矩阵转置。按如下函数原型编程计算并输出m×n阶矩阵的转置矩阵。其中，m和n的值由用户从键盘输入。已知m和n的值都不超过10。
  void Transpose(int *a, int *at, int m, int n);
  void InputMatrix(int *a, int m, int n);
  void PrintMatrix(int *at, int n, int m);
  输入提示信息："Input m, n:"
  输入格式："%d,%d"
  输出提示信息和格式："The transposed matrix is:\n"
  系统反应的问题：
  

• 问题3解决方案：

#include <stdio.h>
#include <stdlib.h>
#define M 10
#define N 10
void Transpose(int *a, int *at, int m, int n);
void InputMatrix(int *a, int m, int n);
void PrintMatrix(int *at, int n, int m);
int main()
{
    int m,n;
    int A[M][N],AT[N][M];
    printf("Input m, n:");
    scanf("%d,%d",&m,&n);
    if(m>10||n>10)
        exit(0);
    InputMatrix(*A,m,n);
    Transpose(*A,*AT,m,n);
    PrintMatrix(*AT,n,m);
    return 0;
}

void Transpose(int *a, int *at, int m, int n)
{
    int i,j;
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
        {
            at[j*m+i]=a[i*n+j];
        }
    }
}

void InputMatrix(int *a, int m, int n)
{
    int i,j;
    printf("Input %d*%d matrix:\n",m,n);
    for(i=0;i<m;i++)
    {
        for(j=0;j<n;j++)
        {
            scanf("%d",&a[i*n+j]);
        }
    }
}
void PrintMatrix(int *at, int n, int m)
{
    int i,j;
    printf("The transposed matrix is:\n");
    for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            printf("%d\t",at[i*m+j]);
        }
        printf("\n");
    }
}

• 问题4：
  编程用链表方法实现堆栈数据结构。堆栈（Strack）是指这样一段内存，它可以理解为一个筒结构，先放进筒中的数据被后放进筒中的数据“压住”，只有后放进筒中的数据都取出后，先放进去的数据才能被取出，称为“后进先出”。堆栈的长度可随意增加。堆栈结构可用链表实现。设计一个链表结构需包含两个成员：一个存放数据，一个为指向下一个节点的指针。当每次有一个新数据要放入堆栈时，称为“压入堆栈”，这时动态建立一个链表的节点，并连接到链表的结尾；当每次从堆栈中取出一个数据时，称为“弹出堆栈”，这意味着从链表的最后一个节点中取出该节点的数据成员，同时删除该节点，释放该节点所占的内存。
  请将下面程序补全。
  这种情况一般是某个地方没有加换行符

typedef struct stack
{
    int data;
    struct stack *next;
} STACK;
STACK *head, *pr;
int nodeNum = 0;                            /* 堆栈节点数寄存器 */
STACK *CreateNode(int num);
STACK *PushStack(int num);
int PopStack(void);
int main()
{
    int pushNum[5] = {111, 222, 333, 444, 555}, popNum[5], i;
    for (i = 0; i < 5; i++)
    {
        PushStack(pushNum[i]);
        printf("Push %dth Data:%d\n", i + 1, pushNum[i]);
    }
    for (i = 0; i < 5; i++)
    {
        popNum[i] = PopStack();
        printf("Pop %dth Data:%d\n", 5 - i, popNum[i]);
    }
    return 0;
}
/* 函数功能：生成一个新的节点，并为该节点赋初值，返回指向新的节点的指针 */
STACK *CreateNode(int num)
{
    STACK *p;
    ......
    return p;
}
/*  函数功能：将整型变量num的值压入堆栈，返回指向链表新节点的指针 */
STACK *PushStack(int num)
{
    ......
    return pr;
}
/*  函数功能：将当前栈顶的数据弹出堆栈，返回从堆栈中弹出的数据 */
int PopStack(void)
{
    STACK *p = head;
    int result;
    ......
    return result;
}

• 问题4的解决方案：

#include <stdio.h>
 
typedef struct stack
{
    int data;
    struct stack *next;
} STACK;
 
STACK *head, *pr;
int nodeNum = 0;                            /* 堆栈节点数寄存器 */
 
STACK *InitStack (void);
STACK *CreateNode(int num);
STACK *PushStack(int num);
int PopStack(void);
 
int main(void)
{
    int pushNum[5] = {111, 222, 333, 444, 555}, popNum[5], i;
    for (i = 0; i < 5; i++)
    {
        PushStack(pushNum[i]);
        printf("Push %dth Data:%d\n", i + 1, pushNum[i]);
    }
    for (i = 0; i < 5; i++)
    {
        popNum[i] = PopStack();
        printf("Pop %dth Data:%d\n", 5 - i, popNum[i]);
    }
    return 0;
}
 
/* 函数功能：生成一个新的节点，并为该节点赋初值，返回指向新的节点的指针 */
STACK *CreateNode(int num)
{
    STACK *p;
    p = (STACK *)malloc (sizeof (STACK));
 
    if (p == NULL)
    {
        printf ("Error!");
 
        exit (1);
    }
 
    p -> data = num;
    p -> next = NULL;
 
    return p;
}
/*  函数功能：将整型变量num的值压入堆栈，返回指向链表新节点的指针 */
STACK *PushStack(int num)
{
    if (nodeNum == 0)
    {
        head = CreateNode (num);
 
        pr = head;
    }
    else
    {
        pr -> next = CreateNode (num);
        pr = pr -> next;
 
    }
 
    nodeNum ++;
 
    return pr;
}
/*  函数功能：将当前栈顶的数据弹出堆栈，返回从堆栈中弹出的数据 */
int PopStack(void)
{
    STACK *p = head;
 
    int result;
 
    while (1)
    {
        if (p -> next == NULL)
        {
            break;
        }
        else
        {
            pr = p;
            p = p -> next;
 
            nodeNum --;
        }
    }
 
    pr -> next = NULL;
 
    result = p -> data;
 
    free (p);
 
    return result;
}

• 问题5：
  13个人围成一圈，从第1个人开始顺序报号1、2、3，凡报到3的人退出圈子。找出最后留在圈子里的人原来的序号。要求用结构体编程实现。
  输出提示 "出圈成员及顺序：" 格式 "%3d"
  输出提示 "\n最后的成员是：" 格式 "%3d"

程序的运行示例如下：
出圈成员及顺序： 3 6 （后面以此类推，抱歉这里的输出结果保密，暂不公开，注意最后一个人是不出圈的哦）
最后的成员是： （抱歉这里的输出结果保密，暂不公开）
我的思路错误：只局限于结构体，并没有想到用链表来解决问题

• 问题5解决方案：

#include <stdio.h>
#include <stdlib.h>
 
struct Person{                                   //定义结构体
    int num;
    struct Person *next;
};
int main()
{
    struct Person per[13];                              //定义结构体变量数组
    int i;
    for (i=0; i<13; i++){                        //此循环给13个人标注序号，1对应第一个人，以此类推，同时实现循环链表，当到达链表最后一个时，地址指向开头。
        per[i].num=i+1;
        if (i==12) per[i].next=&per[0];
        else per[i].next=&per[i+1];
    }
    struct Person *p,*p1;
    for (p=per, i=1; p->next!=p; p=p->next){    //循环报号，当每次报到第3个人时，next指针直接跳过下一个变量，指向下下个变量，当next指针指向自己时结束循环。
        i++;
        if (i==3){
            p1=p->next;
            printf("%d ", p1->num);
            p->next=p->next->next;
            i=1;
 
        }
    }
    printf("\nThe number is %d\n", p->num);       //输出结果
    system("pause");
    return 0;
}

运行结果：

上周考试错题总结

无

其他（感悟、思考等）

无

学习进度条