2023期中考试

1. 2023春期中机考第一题 顺序表（7+8 = 15分)

#include <stdio.h>
​
#include <stdlib.h>
​
#define OK 1
​
#define ERROR 0
​
​
​
typedef struct
​
{
​
    int *elem;
​
    int length;
​
    int listsize;
​
} sqlist;
​
​
​
//初始化一个空的顺序表
​
int initlist(sqlist *l)
​
{
​
    l->elem = (int *)malloc(100 * sizeof(int));
​
    if (!l->elem)
​
        return ERROR;
​
    l->length = 0;
​
    l->listsize = 100;
​
    return OK;
​
}
​
​
​
//根据长度为n的数组x，创建顺序表L   
​
//如果成功返回OK，否则返回ERROR
​
int insertlist(sqlist *l, int a[], int n)
​
{
    int i; 
    for (i = 0; i < n; i++)
​
    {
​
        l->elem[i] = a[i];
​
    }
​
    l->length = n;
​
    return OK;
​
}
​
​
​
//将顺序表a中大于t的元素存入顺序表b中
​
void getb(sqlist *b, sqlist a, int t)
​
{
​
    //★★★请补全代码
    int i = 0,j = 0;
    for(;i < a.length;i ++)
    {
        if(a.elem[i] > t)   
        {
            b->elem[j + b->length] = a.elem[i]; 
            j ++;
        }
    } 
    b->length += j;
​
​
​
​
​
​
​
}
​
​
​
// 将b中的元素逆置，并打印输出逆置后b中所有元素
​
void  reverselist(sqlist *b)
​
{
​
    //★★★请补全代码
    int i = 0;
    for(;i * 2 < b->length;i ++)
    {
        int temp = b->elem[i];
        b->elem[i] = b->elem[b->length - i - 1];
        b->elem[b->length - i - 1] = temp;      
    }
​
}
​
​
​
int main()
​
{
​
    sqlist a,b;
​
    initlist(&a);
​
    initlist(&b);
​
    int x[100];
​
    int n,i;
​
    scanf("%d", &n);
​
    for (i = 0; i < n; i++)
​
    {
​
        scanf("%d", &x[i]);
​
    }
​
    insertlist(&a, x, n);
​
    int t;
​
    scanf("%d", &t);
​
    getb(&b, a, t);
​
    reverselist(&b);
    
    for(i = 0;i < b.length;i ++)
    {
        printf("%d ",b.elem[i]);
    }
​
    return 0;
​
}

2. 2023春期中机考第二题 链表（5+7+8=20分）

#include <stdio.h>
​
#include <stdlib.h>
​
#define ERROR -1
​
#define OK 1
​
​
​
typedef struct Lnode
​
{
​
    int data;
​
    struct Lnode *next;
​
}LNode,*LinkList;
​
​
​
// 创建带头结点的单链表
​
int CreateList(LinkList *L)
​
{
​
    *L=(LinkList)malloc(sizeof(LNode));
​
    if((*L)==NULL)
​
    {
​
        printf("Memory failure\n");
​
        return ERROR;
​
    }
​
    (*L)->next=NULL;
​
    LinkList r;
​
    r=*L;
​
    int x;
​
    int i;
​
    for(i=0; ; i++)
​
    {
​
        scanf("%d",&x);
​
        if(x==-1)
​
        break;
​
        LNode *p=(LinkList)malloc(sizeof(LNode));
​
        if(!p) 
​
        {
​
            printf("Initialization failure");
​
            return ERROR;
​
        }
​
        p->data=x;
​
        p->next= NULL;
​
        r->next=p;
​
        r=p;
​
    }
​
    return OK;
​
}
​
​
​
//打印单链表
​
void ListPrint(LinkList L)
​
{
​
    LNode *p;
​
    for(p=L->next;p!=NULL;p=p->next)
​
    {
​
        printf("%d ",p->data);
​
    }
​
}
​
​
​
//求单链表长度
​
int ListLength(LinkList L)
​
{
​
    //★★★请补全代码
    int len = 0;
     LinkList p = L->next;
     while(p)
     {
        len ++;
        p = p->next;
     }
    return len;
​
​
​
​
​
​
}
​
​
​
//删除单链表的倒数第x个元素, 参数length为单链表长度，
​
//如果操作成功，返回OK，否则返回ERROR
​
int DeleteX(LinkList  *L,int length, int x)
​
{
    
    if(x > ListLength(*L))
    {
        printf("\nThe x value is not valid");
        return 0;
    }
​
    //★★★请补全代码
    int i = 0;
    LinkList p = (*L);
    while(p->next && i < length - x)
    {
        p = p->next;
        i ++;
    }
    LinkList s = p->next;
    p->next = s->next;
    free(s);
    return OK;
​
​
​
​
​
​
​
}
​
​
​
//单链表元素求和，并将累加和添加到单链表尾部
​
//如果操作成功，返回OK，否则返回ERROR
​
int AppendSumToList(LinkList *L)
​
{
​
    //★★★请补全代码
    int sum = 0;
    LinkList p = (*L);
    while(p->next)
    {
        sum += p->next->data;
        p = p->next;
    }
    LinkList s;
    s = (LinkList)malloc(sizeof(LNode));
    if(!s)  return ERROR;
    s->data = sum;
    s->next = NULL;
    p->next = s;
    return 1;
    
​
​
​
​
​
​
} 
​
​
​
int main()
​
{
​
    int length;
​
    int x;
​
    LinkList L;
​
    CreateList(&L);
​
    scanf("%d",&x);
    
​
​
    printf("The original linked list is：");
​
    ListPrint(L);
​
    printf("\nThe length of list is：");
​
    length=ListLength(L);
​
    printf("%d ",length);
    
​
​
    DeleteX (&L,length, x);
​
    printf("\nAfter deleting the element, the linked list is: ");
​
    ListPrint(L);
​
    printf("\nAfter inserting the sum, the new list is: ");
​
    AppendSumToList(&L);
​
    ListPrint(L);
​
    return 0;
​
}

3. 2023春期中机考第三题 链队列（7+8=15分）

#include <stdio.h>
​
#include <stdlib.h>
​
#define OK 1
​
#define ERROR 0
​
#define OVERFLOW 0
​
​
​
typedef char ElemType;
​
typedef int Status;
​
typedef struct QNode
​
{
​
    ElemType data;
​
    struct QNode *next;
​
}QNode,*queuePtr;   
​
​
​
typedef struct
​
{
​
    queuePtr front; //指向链队列的头
​
    queuePtr rear;  //指向链队列的尾 
​
}LinkQueue;
​
​
​
//队列初始化
​
Status InitQueue(LinkQueue *q)
​
{
​
   q->front=q->rear=(queuePtr)malloc(sizeof(QNode));  //创建头节点 头指针指向头节点
​
   if(!q->front)  //创建失败
​
   {
​
       return ERROR;
​
   }
​
   q->front->next=NULL;
​
   return OK;
​
}
​
​
​
//判断队列是否为空
​
Status QueueEmpty(LinkQueue Q)
​
{
​
    if(Q.front==Q.rear)
​
        return OK;
​
    else
​
        return ERROR;
​
}// QueueEmpty
​
​
​
int QueueLength (LinkQueue Q)
​
{
​
    int i;
​
    queuePtr p;
​
    p = Q.front->next;   //p指向队头
​
    i=1;
​
    while(p!=Q.rear)  //遍历链队列,统计结点数
​
    {
​
        i++;
​
        p=p->next;
​
    }
​
    return i;
​
}// QueueLength
​
​
​
//获得队首元素
​
Status GetHead(LinkQueue q,ElemType *e)
​
{
​
    if(q.front == q.rear)
​
        return ERROR;
​
    *e = q.front->next->data;
​
    return OK;
​
}
​
​
​
//入队
​
Status EnQueue(LinkQueue *q,ElemType e)
​
{
​
    queuePtr p=(queuePtr)malloc(sizeof(QNode)); //为新元素分配空间
​
    if(!p) return ERROR; 
​
    p->data=e;
​
    p->next=NULL;
​
    q->rear->next=p; //为尾指针的next重新赋值 将元素插入表尾
​
    q->rear=p;  //重新定位尾指针
​
    return OK;
​
}
​
​
​
//删除元素
​
Status DeQueue(LinkQueue *q,ElemType *e)
​
{
​
    if(q->front == q->rear) return ERROR; //此时队列为空
​
    queuePtr p = q->front->next;  
​
    *e=p->data;  //删除是队首元素
​
    q->front->next=p->next;
​
    if(q->rear == p)
​
        q->rear=q->front;
​
    free(p);
​
    return OK;
​
}
​
​
​
//清空链队列，如果成功，返回OK，否则返回ERROR
​
Status ClearQueue (LinkQueue *Q)
​
{
​
    //★★★请补全代码
    if(!Q->front)   return ERROR;
    free(Q->front);
    Q->front = Q->rear = 0;
    return OK; 
​
​
​
​
​
​
​
}// ClearQueue
​
​
​
//输出队列
​
Status PrintQueue(LinkQueue q)
​
{
​
    queuePtr p;
​
    p = q.front->next;
​
    while(p)
​
    {
​
        printf("%c ",p->data);
​
        p=p->next;
​
    }
​
    return OK;
​
}
​
​
​
//解密游戏
​
void DecryptGame(LinkQueue *Q)
​
{
​
    //★★★请补全代码
    LinkQueue S;
    InitQueue(&S);
    
    while(!QueueEmpty(*Q))
    {
        char temp;
        DeQueue(Q,&temp);
        EnQueue(&S,temp);
        if(!QueueEmpty(*Q))
        {
            DeQueue(Q,&temp);
            EnQueue(Q,temp);
        }
    } 
​
    PrintQueue(S);
​
 
​
​
​
}
​
​
​
int main()
​
{
​
    LinkQueue Q;
​
    InitQueue(&Q);
​
    int i;
​
    char a;
​
    for(i=0;i<10;i++)
​
    {
​
        scanf("%c",&a);
​
        EnQueue(&Q,a);
​
    }
​
    DecryptGame(&Q);
​
    printf("\n");
​
    ClearQueue(&Q);
​
    return 0;
​
}

4. 2023春 期中考试 第四题 顺序栈（5+10=15分）

#include<stdio.h>
​
#include<stdlib.h>
​
#define OK 1
​
#define ERROR 0
​
#define OVERFLOW -2
​
#define MAXSIZE  100
​
​
​
typedef int Status;
​
typedef int SElemType;
​
typedef struct{
​
    SElemType *base;
​
    SElemType *top;
​
    int stacksize;
​
}SqStack;
​
​
​
//顺序栈的初始化
​
Status InitStack(SqStack *S){ 
​
    S->base = (SElemType *)malloc(MAXSIZE * sizeof(SElemType));
​
    if(!S->base)
​
        return ERROR;
​
    S->top = S->base;
​
    S->stacksize = MAXSIZE;
​
    return OK;
​
}
​
​
​
Status Push(SqStack *S,SElemType e)
{
​
    //★★★请补全代码
    if(S->top - S->base >= S->stacksize)    return ERROR;
    *(S->top ++) = e;
    return OK;
​
​
}
​
​
​
//顺序栈的出栈
​
Status Pop(SqStack *S,SElemType *e){
​
    if(S->base == S->top)
​
        return ERROR;
​
    *e = *(--S->top);
​
    return OK;
​
}
​
​
​
​
​
// 将一个十进制数转换为二进制数，并打印输出
​
// 要求使用堆栈来实现，如果未用堆栈，答题无效
​
​
​
int main()
​
{
​
    //★★★请补全代码
    int n;
    scanf("%d",&n);
    if(n <= 0)
    {
        printf("Input error!");
        return 0;
    }
    
    SqStack S;
    InitStack(&S);
    
    while(n)
    {
        int x = n%2;
        Push(&S,x);
        n = (n - x) / 2;
    }
    
    while(S.base != S.top)
    {
        int e;
        Pop(&S,&e);
        printf("%d",e);
    }
    return 0;
}
​

5. 2023春 期中考试 第五题 字符串 (7+8=15分)

#include <stdio.h>   
​
#include <stdlib.h>   
​
​
​
#define ERROR 0
​
#define OK 1
​
#define TRUE 1
​
#define FALSE 0
​
#define MAXSIZE 20
​
​
​
typedef struct
​
{
​
    char *ch;       //若串非空,则按串长分配存储区
​
    int  length;    //串长度
​
}HString;
​
​
​
int InitString(HString *T) 
​
{
​
    T->ch=(char*)malloc(sizeof(char)*MAXSIZE);
​
    if(!T->ch)
​
        return ERROR;
​
    T->length=0;
​
    return OK;
​
}
​
​
​
//将字符数组chars赋值到串T
​
//如果操作成功，返回OK，否则返回ERROR
​
int StrAssign(HString *T,char *chars)
​
{
​
//★★★请补全代码
    int i = 0;
    for(;chars[i] !='\0';i++)
    {
    }
    if(!i)
    {
        T->ch = NULL;
        T->length = 0;
    }
    else
    {
        int j = 0;
        for(j = 0;chars[j] != '\0';j ++)
        {
            T->ch[j] = chars[j];
            T->length ++;
        }
        
    }
    return OK;
​
​
}
​
​
​
   
​
// 比较字符串大小
​
//（1）如果两个串长度相等，且每一个相应位置上的字符都一样，则结果为0；
​
//（2）如果两个串长度不相等，则则以第一个不相同的字符作为基准，返回第一个不相同的字符ASCII差值；
​
//（3）如果两个串长度不相等，且所有相应位置上的字符都一样，则返回两个字符串的长度之差。
​
int StrCompare(HString S,HString T)
​
{
​
  //★★★请补全代码
  int i = 0;
  while(i < S.length && i < T.length)
  {
        if(S.ch[i] != T.ch[i])  return (S.ch[i] - T.ch[i]);
        i++; 
  }
  return S.length - T.length;
​
​
​
}//StrCompare    
​
​
​
int main()
​
{
​
    HString S;
​
    HString T;
​
    char mainstr[20];
​
    char substr[10];
​
    int index;
​
    InitString(&S);
​
    InitString(&T);
​
    gets(mainstr);
​
    gets(substr);
​
    StrAssign(&S,mainstr);
​
    StrAssign(&T,substr);
​
    printf("%d\n",StrCompare(S,T));
​
    return 1;
​
}

6. 2023春 期中考试 第六题 综合题（一） (7分)

#define MAXINTSIZE 512 /* 最大整数长度 */
​
#include<stdio.h>
​
#include<stdlib.h>
​
​
​
#define ERROR 0
​
#define OK 1
​
typedef int Status;
​
​
​
typedef struct Node
​
{
​
    int data;
​
    struct Node *next;
​
} LNode;
​
typedef LNode *LinkList;
​
​
​
/* 用头插法建立单链表 */
​
Status CreateList(LinkList *L, char *chars)
​
{
​
     //★★★请补全代码
    LinkList p = (*L);
    int i = 0;
    for(;chars[i] != '\0';i ++)
    {
        LNode *r;
        r = (LinkList)malloc(sizeof(LNode));
        if(!r)  return ERROR;
        r->data = chars[i] - '0';
        r->next = p->next;
        p->next = r;
        //p = r;
    }
    return OK;
​
​
​
}
​
​
​
int ListLength_L(LinkList L){
​
    LinkList p;
​
    int i=0;             
​
    p=L->next;        //p指向第一个结点
​
    while(p){         //遍历单链表,统计结点数
​
        i++;
​
        p=p->next;
​
    } 
​
    return i;                             
​
}// ListLength_L
​
​
​
Status  InversePrint(LinkList p){
​
   //逆序打印不带头结点的单链表的元素    
​
   if(!p) return OK;
   
   //printf("%d",p->data);
​
   InversePrint(p->next);
​
   printf("%d",p->data);
​
   return OK;
​
}// 
​
​
​
int main()
​
{
​
    int len;
​
    char str[MAXINTSIZE+1];
​
    LinkList L;
​
    scanf("%s", str);
    
    L = (LinkList)malloc(sizeof(LNode));
​
    CreateList(&L, str);
​
    len=ListLength_L(L);
​
    printf("the length of the integer is %d\n", len);
​
    InversePrint(L->next);
​
    printf("\n");
​
    return 0;
​
}
​

​

7. 2023春 期中考试 第六题 综合题（二） (7+6=13分)

#include<stdio.h>
​
#include<stdlib.h>
​
​
​
#define ERROR 0
​
#define OK 1
​
​
​
typedef int Status;
​
​
​
typedef struct Node
​
{
​
    int data;
​
    struct Node *next;
​
} LNode;
​
typedef LNode *LinkList;
​
​
​
Status InitList(LinkList *L)
​
{
​
    *L = (LinkList)malloc(sizeof(LNode));
​
    if (*L == NULL)
​
        return ERROR;
​
    (*L)->next = NULL;
​
    return OK;
​
}
​
// 单链表表示的大整数与整数相乘
​
//自己的代码
//int int_mult(LinkList *L, int base) 
//{
//  
//  int carry = 0;
//  LNode *p = (*L);
//  LNode *pre = NULL;
//  
//  while(p)
//  {
//      p->data = p->data * base + carry;
//      carry = p->data / 10;
//      p->data = p->data % 10;
//      pre = p;
//      p = p->next;
//  }
//  
//  if(!p && carry)
//  {
//      p = (LinkList)malloc(sizeof(LNode));
//      if(!p)  return ERROR;
//      p->data = carry;
//      p->next = NULL;
//      pre->next = p;
//  }
//  return OK;
//}
​
// 单链表表示的大整数与整数相乘
​
int int_mult(LinkList *L, int base) {
    int carry = 0;
    LinkList p = *L; // 从链表头开始遍历
    LinkList pre = NULL; // 记录当前节点的前一个节点，为后面进行尾插新节点提供前驱
​
    // 遍历链表
    while (p || carry != 0) {
        if (!p) {
            // 如果 p 为空，创建一个数据为 0 的新节点
            LNode *r = (LinkList)malloc(sizeof(LNode));
            if (r == NULL)
                return ERROR; // 如果内存分配失败，则返回错误
            r->data = 0;
            r->next = NULL;
​
            // 将新节点插入到链表末尾
            if (pre) {
                pre->next = r;
            } else {
                *L = r; // 如果链表为空，则将新节点设为链表头
            }
            p = r; // 更新 p 为新插入的节点
        }
​
        // 将当前数字乘以基数，并加上进位
        p->data = p->data * base + carry;
        carry = p->data / 10; // 更新下一轮迭代的进位
        p->data %= 10; // 更新当前数字
​
        pre = p; // 更新前一个节点为当前节点
        p = p->next; // 移动到链表中的下一个节点
    }
    
    return OK; // 如果乘法运算成功，则返回 OK
}
​
​
​
//统计计算结果中0-9出现个数    
​
void CountNum(LinkList L, int *num)
​
{
​
//★★★请补全代码
    LinkList p = L->next;
    while(p)
    {
        num[p->data]  ++;
        p = p->next;
     } 
​
}
​
​
​
Status InversePrint(LinkList p){
​
   //逆序打印不带头结点的单链表的元素    
​
   if(!p) return OK;
​
   InversePrint(p->next);
​
   printf("%d",p->data);
​
   return OK;
​
}// 
​
​
​
int main()
​
{
​
    int a,n; /* a为底数(0<a<9)，n为指数 */
​
    int len=0;
​
    int num[10]; /* 用于统计计算结果中0-9出现次数 */
​
    LinkList p;
​
    LinkList L;
​
    InitList(&L);
​
    scanf("%d%d",&a,&n);
​
    int i;
​
    for(i=0; i<10; i++)
​
        num[i]=0;        
​
    /* 生成表头节点并放入1 */
​
    p=(LinkList)malloc(sizeof(LNode));
​
    if(p==NULL) return ERROR;
​
    p->data=1;
​
    p->next=NULL;
​
    L->next=p;
​
    /* 反复调用乘a操作n次 */
​
    for(i=0; i<n; i++)
​
        int_mult(&L, a);
​
​
​
    /* 打印计算结果 */
​
    InversePrint(L->next);
​
    printf("\n");
​
    /* 统计计算结果中0-9出现个数 */
​
    CountNum(L, num);
​
    for(i=0; i<10; i++){
​
        printf("the number of %d is: %d\n", i, num[i]);
​
        len+=num[i];
​
    }
​
    printf("the length of the result is %d\n", len);
​
    return 0;
​
}

​
​