2023期末真题

1. 2023 期末 第一题 顺序表(8+7=15分）

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

#define OK 1
#define ERROR 0
#define MAXSIZE 100 //顺序表可能达到的最大长度

typedef int Status; //Status是函数返回值类型，其值是函数结果状态代码
typedef int ElemType; //ElemType为可定义的数据类型，此处设为int类型

typedef struct
{
    ElemType *elem; //存储空间的基地址
    int length; //线性表当前长度
}SqList;

//顺序表的初始化（构造一个空的顺序表L） 
Status InitList_Sq(SqList *L)
{
    L->elem=(ElemType*)malloc(sizeof(ElemType)*MAXSIZE); //为顺序表分配一个大小为MAXSIZE的数组空间
    if(!L->elem)
        return ERROR; //存储分配失败
    L->length=0; //空表长度置为0
    return OK;
}

//创建长度为n的顺序表
Status CreateList_Sq(SqList *L, int n)
{
    if(n<=0||n>MAXSIZE)
        return ERROR;
    int i;
    for(i=0;i<n;i++)
    {
        scanf("%d", &L->elem[i]);
    }
    L->length=n;
    return OK;
}

//删除线性表L中所有在[a,b]范围内的数据元素，其中a,b均为整数，且a<b
//要求算法时间复杂度为O(n)且空间复杂度为O(1)
Status DeleteItem(SqList *L,int a,int b)
{
    //请补全代码
    if(a >= b)	
	{
		printf("SqList delete range error.");
		return ERROR;
	} 
	int i = 0, k = 0;

	for(i = 0;i < L->length;i ++)
	{
		if(L->elem[i] >b || L->elem[i] < a)
		{
			L->elem[k ++] = L->elem[i];
		}
	}
	L->length = k;
	return OK;
	 


}

//输出顺序表L中的全部元素 
void PrintList_Sq(SqList L)
{
    int i;
    for(i=0;i<L.length;i++)
    {
        printf("%d ", L.elem[i]);
    }
    printf("\n");
}


int main()
{
//请补全代码
	int n;
	scanf("%d",&n);
	if(n <= 0 || n > MAXSIZE)
	{
		printf("SqList length error.");
		return ERROR;
	}
	SqList L;
	InitList_Sq(&L);
	CreateList_Sq(&L, n);
	
	int a, b;
	scanf("%d %d",&a, &b);
	if(DeleteItem(&L, a, b) == OK)
		PrintList_Sq(L);
	
	return 0;
}

2. 2023 期末第二题 单链表基本操作与应用（5+10=15分）

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

//函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE 0
//新建函数类型，表示函数运行结果
typedef int Status;

/*动态单链表的结构体定义*/ 
//定义结构体
typedef int ElemType;
typedef struct LNode
{
    ElemType data; //数据域
    struct LNode* next; //指针域
}LNode, *LinkList;

Status InitList(LinkList *L)
{
    int x,i;
    *L = (LinkList)malloc(sizeof(LNode));
    if(*L == NULL)
    {
        printf("memory malloc failure\n");
        return ERROR;
    }
    (*L)->next = NULL;
        //根据键盘值构造链表
    LinkList r;
    r = *L;
    for(i=0; ;i++)
    {
        scanf("%d",&x);
        if(x == -1)
            break;
        LinkList p = (LinkList)malloc(sizeof(LNode));
        if(!p) 
        {
            printf("initial failure\n");
            return ERROR;
        }
        p->data = x;
        p->next = NULL;
        r->next = p;
        r = p;
    }
    return OK;

}

Status DestoryList(LinkList *L)
{
    LinkList p;
    while(*L) //当L为空时循环结束
    {
        p = (*L)->next; //p指向下一个结点
        free(*L); //释放L
        *L = p;
    }
    return OK;
}

Status ListEmpty(LinkList L)
{
    return (L->next == NULL);
}

Status ClearList(LinkList L) 
{
    LinkList p, q;
    p = L->next; //p指向链表第一个结点
    while (p) //当p指向空时循环结束
    {
        q = p->next;
        free(p);
        p = q;
    }
    L->next = NULL; //头结点指针域为空
    return OK;
}

int ListLength(LinkList L)
{
   //补全代码
    int total = 0;
	LinkList p = L->next;
    while(p)
    {
    	total ++;
    	p = p->next;
	}
	return total;


}


Status ListTraverse(LinkList L)
{
    LinkList p = L->next;
    while (p) //当p为空时结束循环
    {
        printf("%d ",p->data); 
        p = p->next;
    }
    printf("\n");
    return OK;
}

Status ListOperate(LinkList *L)
{

 //补全代码
 	LinkList p = (*L);
	if(ListEmpty(*L))
	{
		LinkList r;
		r = (LinkList)malloc(sizeof(LNode));
		if(!r)	return ERROR;
		r->data = 0;
		LinkList s;
		s = (LinkList)malloc(sizeof(LNode));
		if(!s)	return ERROR;
		s->data = 0;
		p->next = r;
		r->next = s;
		s->next = NULL;
		return 0;
	}
	int max = p->next->data, min = p->next->data;
	while(p->next)
	{
		if(p->next->data > max)
		{
			max = p->next->data;
		}
		else if(p->next->data < min)
		{
			min = p->next->data;
		}
		p = p->next;
	 }
 	LinkList r;
	r = (LinkList)malloc(sizeof(LNode));
	if(!r)	return ERROR;
	r->data = min;
	r->next = p->next;
	p->next = r;
	
	LinkList s;
	s = (LinkList)malloc(sizeof(LNode));
	if(!s)	return ERROR;
	s->data = max;
	s->next = (*L)->next;
	(*L)->next = s;

	return 1; 
	 

}

int main()
{
    //初始化链表
    LinkList L;
    if (InitList(&L) == ERROR)
    {
        return 0;
    }
    ListTraverse(L);//对应第一行打印输出
    int len = ListLength(L);
    printf("%d\n",len);//对应第二行打印输出
    ListOperate(&L);
    ListTraverse(L);//对应第三行打印输出
    DestoryList(&L);
    return 0;
}

3. 2023 期末-第三题 队列（5+10=15分）

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define null 0
#define OK 1
#define ERROR 0
#define MAXSIZE 100
 
typedef struct{
    int *base;
    int front;
    int rear;
}SqQueue;
 
 
 
 //初始化循环队列
void InitQueue(SqQueue *Q){
     
    Q->base=(int *)malloc(MAXSIZE*sizeof(int));
    Q->front=0;
    Q->rear=0;
    
}
 
 
 //求队列长度
int QueueLength(SqQueue *Q)
{
 
    //★★★请补全代码
    return  (Q->rear - Q->front + MAXSIZE) % MAXSIZE;

 
}
 
 
int  EnQueue(SqQueue *Q,  int e) // 入队列
{
    if((Q->rear+1)%MAXSIZE==Q->front)
        return ERROR;
         
    Q->base[Q->rear]=e;
    Q->rear=(Q->rear+1)%MAXSIZE;
    return OK;
 
}
 
int DeQueue(SqQueue *Q,int *e) // 出队列
{
    if(Q->front==Q->rear)
        return ERROR;
    *e=Q->base[Q->front];
    Q->front=(Q->front+1)%MAXSIZE;
    return OK;

}

int GetHead(SqQueue *Q,int *e) // 取队头元素值
{
    if(Q->front==Q->rear)
        return ERROR;
    *e=Q->base[Q->front];
    return OK;
} 
 
int Baoshu(SqQueue *Q)
{
	while(QueueLength(Q) > 1)
	{
		int bianhao ;
		GetHead(Q, &bianhao);
			
	    int i;
	    for(i = 1;i < MAXSIZE;i ++)
	    {
	    	int e;
	
			DeQueue(Q, &e);
	
			if(i == bianhao)	
			{
				printf("%d ",e);
				Baoshu(Q);
			}
			
			else	
			{
				EnQueue(Q, e);
			}
		}
	}
	return Q->base[Q->front];	
	
}
 
int main()
{
    int n;
    int i;
    int j;
    SqQueue Q;
    InitQueue(&Q);
    scanf("%d",&n);
    for(i=1;i<=n;i++)
        EnQueue(&Q, i);
    j=Baoshu(&Q);
    printf("\n");
    printf("%d ",j);
    return 0;
}

4. 2023 期末第四题 排序（7+8=15分）

#include <stdio.h>
 
//冒泡排序
void bubbleSort(int arr[], int n) 
{
//★★★请补全代码
	int i, j;
	for(i = 0 ;i < n - 1; i ++)
	 {
	 	for(j = 0 ;j < n - i - 1;j ++)
	 	{
	 		if(arr[j] < arr[j + 1])
			 {
			 	int temp = arr[j];
			 	arr[j] = arr[j +1];
				 arr[j + 1] = temp; 
			  } 
		 }
	 }
    
}
 
//简单选择排序
void selectionSort(int arr[], int n) 
{
//★★★请补全代码
	int i ,j;
	for(i = 0; i < n;i ++)
	{
		int min = arr[i],min_n = i;
		for(j = i ; j < n;j ++)
		{
			if(arr[j] < min)
			{
				min = arr[j];
				min_n = j;
			}
		}
		if(min_n != i)
		{
			arr[min_n] = arr[i];
			arr[i] = min;
		}
	}
    
}

//打印数组 
void printfArray(int arr[], int n) {
    bubbleSort(arr, n);
    printf("Array by bubbleSort are: ");
    int i;
    for(i=0; i< n; i++){
        printf("%d ", arr[i]);
    }
    printf("\n");
    selectionSort(arr, n);
    printf("Array by selectionSort are: ");
    for(i=0; i< n;i++){
        printf("%d ", arr[i]);
    }       
    printf("\n");
       
}
 
 
int main() {
    int arr[100];
    int n, k, i;
    scanf("%d", &n);
 
    for (i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }
 
    printfArray(arr, n);
 
    return 0;
}

5. 2023 期末第五题 二叉树遍历和应用（7+7+6=20分）

#include <stdio.h>

#include <malloc.h>

#include <stdlib.h>

#define OVERFLOW 0

#define OK 1

typedef struct node         //二叉树结点类型的定义

{

       char data;

       struct node *lchild; //定义结点的左孩子指针

       struct node *rchild; //定义结点的右孩子指针

} BinTNode, *BTNode;

 

BinTNode *CreateBinTree()  //输入二叉树的先序遍历序列，创建二叉链表

{

       BinTNode *t;

       char ch;

       ch = getchar();

       if (ch == '0')             //如果读入0，创建空树

             t = NULL;

       else

       {

             t = (BinTNode *)malloc(sizeof(BinTNode)); //申请根结点*t空间

             if(!t) exit(OVERFLOW);

             t->data = ch;                                  //将结点数据ch放入跟结点的数据域

             t->lchild = CreateBinTree();                        //建左子树

             t->rchild = CreateBinTree();                        //建右子树

       }

       return t;

}

 



void preorder(BTNode t)   //对二叉树进行先序遍历。提示：打印采用 %3c

{

       if (t != NULL)

       {

             printf("%3c", t->data);  //打印节点数据

             preorder(t->lchild);   //先序遍历左子树

             preorder(t->rchild);   //先序遍历右子树

       }

}

 

void inorder(BTNode t) //对二叉树进行中序遍历。提示：打印采用 %3c

{

       //★★★请补全代码
    if(t)
	{
		inorder(t->lchild);
		printf("%3c",t->data);
		inorder(t->rchild);
	 } 

 
}
//二叉树的叶子结点数

int Leaf(BTNode t) 
{
       //★★★请补全代码
    if(!t)	return 0;
    
	else if(t->rchild == NULL && t->lchild == NULL)	return 1;
    
    else
		return Leaf(t->lchild) + Leaf(t->rchild);

}

 

//二叉树的最大值

int Max(BTNode t) 
{

       //★★★请补全代码
    if(!t)	return 0;
    int submax = Max(t->rchild) > Max(t->lchild) ? Max(t->rchild) : Max(t->lchild);
    return submax > t->data ? submax: t->data;

}

 

int main()

{

       BTNode t = NULL;

       //int TreeHeight;

       t = CreateBinTree();

       preorder(t);                             //调用二叉树先序遍历函数

       printf("\n");

       inorder(t);                              //调用二叉树中序遍历函数

       printf("\n");

       printf("%d\n", Leaf(t));

       printf("%c\n", Max(t));

 

}

6.期末第六题 应用题-社交网络下谣言传播分析(一) （5+5=10分）

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 20  //最大顶点数

typedef struct ArcNode
{
    int adjvex;  //该边所连接的顶点的位置（即该顶点的数组下标）
    struct ArcNode *nextarc;  //指向下一条边的指针
    int info;  // 边的权值
} ArcNode;

typedef struct VNode
{
    int data;  //顶点信息
    ArcNode *firstarc;  //指向第一条依附该顶点的边的指针
} VNode, AdjList[MAX_VERTEX_NUM];

typedef struct ALGraph
{
    AdjList vertices;
    int vexnum, arcnum;  //图的当前顶点数和弧数
} ALGraph;

// 建立关系网的邻接表数据存储结构
void CreateUDN(ALGraph *G)
{
    // 请补全以下代码
    scanf("%d %d",&G->vexnum, &G->arcnum);
	int i;
	for(i = 1;i <= G->vexnum ;i ++)
	{
		G->vertices[i].data = i;
		G->vertices[i].firstarc = NULL;	
	}
		
	for(i = 0 ;i < G->arcnum ;i ++)
	{
		int v1, v2,weight;
		getchar();
		scanf("%d %d %d",&v1, &v2, &weight);
		
		ArcNode *p1;
		p1 = (ArcNode*)malloc(sizeof(ArcNode));
		if(!p1)	return ;
		p1->adjvex = v2;
		p1->info = weight;
		p1->nextarc = G->vertices[v1].firstarc;
		G->vertices[v1].firstarc = p1;
		
		ArcNode *p2;
		p2 = (ArcNode*)malloc(sizeof(ArcNode));
		if(!p2)	return;
		p2->adjvex = v1;
		p2->info = weight;
		p2->nextarc = G->vertices[v2].firstarc;
		G->vertices[v2].firstarc = p2;
	 } 

}

/* 统计顶点的边的权值之和 */
/* 输入参数为图和待统计的顶点编号 */
/* 函数返回值为该顶点的边权值之和  */
int VexCount(ALGraph G, int v)
{
    // 请补全以下代码
	ArcNode *p = G.vertices[v].firstarc;
	int sum = 0;
	while(p)
	{
		sum += p->info;
		p = p->nextarc;
	}
	return sum;
}

int main()
{
    ALGraph G;
    int choice;
    static int count = 0;
    CreateUDN(&G);

	int i;
    for(i=0; i<G.vexnum; i++)
    {
        printf("%d ", VexCount(G, i+1));
    }
    printf("\n");
    return 0;
}

7.2023 期末第六题 应用题-社交网络下谣言传播分析(二) （5+5=10分）

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERTEX_NUM 20  //最大顶点数
#define TH 4  // 信任度阈值
#define OVERFLOW -1
#define ERROR 0
#define OK 1

typedef int Status;
typedef int QElemType;
// 邻接矩阵
typedef struct ArcCell
{
    unsigned int weight;  //权值
}AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

// 无向网
typedef struct MGraph
{
    AdjMatrix arcs;  //邻接矩阵
    int vexnum, arcnum;  //顶点数，弧数
}MGraph;

// 链队列结点
typedef struct QNode
{
    int data;
    struct QNode *next;
}QNode, *QueuePtr;

typedef struct
{
   QueuePtr front,rear; /* 队头、队尾指针 */
}LinkQueue;

int visited[MAX_VERTEX_NUM]; // 顶点是否被访问过
int credit[MAX_VERTEX_NUM]; // 顶点的信用值
int times[MAX_VERTEX_NUM]; // 顶点收到谣言时间

Status InitQueue(LinkQueue *Q)
{ /* 构造一个空队列Q */
    (*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));
    if(!(*Q).front)
        exit(OVERFLOW);
    (*Q).front->next=NULL;
    return OK;
}

Status QueueEmpty(LinkQueue Q)
{ /* 若Q为空队列,则返回TRUE,否则返回FALSE */
    return(Q.front==Q.rear);
}

Status EnQueue(LinkQueue *Q,QElemType e)
{ /* 插入元素e为Q的新的队尾元素 */
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    if(!p) /* 存储分配失败 */
        exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    (*Q).rear->next=p;
    (*Q).rear=p;
    return OK;
}

Status DeQueue(LinkQueue *Q,QElemType *e)
{ /* 若队列不空,删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
    QueuePtr p;
    if((*Q).front==(*Q).rear)
        return ERROR;
    p=(*Q).front->next;
    *e=p->data;
    (*Q).front->next=p->next;
    if((*Q).rear==p)
        (*Q).rear=(*Q).front;
    free(p);
    return OK;
}

/* 建立社交网络 */
void CreateUDN(MGraph *G)
{
    scanf("%d %d",&G->vexnum, &G->arcnum);
    int i, j;
    //初始化邻接矩阵 
    for(i = 0; i < G->vexnum; i++)
    {
        for(j = 0; j < G->vexnum; j++)
        {
            G->arcs[i][j].weight = 0;
        }
    }
    
    for(i = 0; i < G->arcnum ;i ++)
    {
        int v1, v2, weight;
        getchar();
        scanf("%d %d %d",&v1, &v2, &weight);
        G->arcs[v1 - 1][v2 - 1].weight = weight;
        G->arcs[v2 - 1][v1 - 1].weight = weight;
    }
}

/* 广度优先搜索网络，计算谣言传播路径、信任度、传播时间 */
/* 参数：邻接矩阵图；传播谣言的顶点编号 */
void BFSGraph(MGraph G, int v)
{
    int i, j;
    LinkQueue Q; // 辅助队列
    InitQueue(&Q);
    for(i = 0; i < G.vexnum; i++)
    {
        visited[i] = 0;
        credit[i] = 0;
        times[i] = 0; 
    }
    visited[v] = 1;
    credit[v] = 0;
    times[v] = 1;
    printf("%d ", v + 1);
    EnQueue(&Q, v);

    while(!QueueEmpty(Q))
    {
        int u;
        DeQueue(&Q, &u);

        for(j = 1; j < G.vexnum; j++)
        {
            if(G.arcs[u][j].weight != 0 && !visited[j])
            {
                credit[j] += G.arcs[u][j].weight;
                
                if (credit[j] >= TH)
                {
                    visited[j] = 1;
                    times[j] = times[u] + 1;
                    EnQueue(&Q, j);
                    printf("%d ", j + 1);
                }
            }
        }
    }
}

int main()
{
    MGraph G;
    int i,j;
    /* 生成网络 */
    CreateUDN(&G);
    /* 输出邻接矩阵 */
    for(i=0; i< G.vexnum; i++){
        for(j=0; j< G.vexnum; j++)
            printf("%d ", G.arcs[i][j].weight);
        printf("\n");
    }
    /* 广度优先遍历遍历网络 */
    BFSGraph(G, 0);
	printf("\n");
    /* 输出各顶点的谣言信任度 */
    for(i = 0; i< G.vexnum; i++)
    {
        printf("%d ", credit[i]);
    }
    printf("\n");
    /* 输出各顶点的谣言传播时间 */
    for(i = 0; i< G.vexnum; i++)
    {
        printf("%d ", times[i]);
    }
    printf("\n");
    return 0;
}