这里写自定义目录标题
- 数据结构题
- 本题要求编写程序,输入N个学生的MOOC成绩,统计优秀、合格证书的数量,以及没有获得证书的数量。
- 利用函数计算素数个数并求和:输入两个正整数 m 和n(m≤n),统计并输出m
- 猜数字游戏:先输入 2 个不超过 100 的正整数,分别是被猜数 mynumber 和允许猜测的最大次数 n,再输入你所猜的数 yournumber,与被猜数 mynumber 进行比较,
- 顺序表:在顺序表L中查找第一个值最大的元素,并删除该元素。
- 顺序表:在顺序表L中查找最后一个值最小的元素,在该位置上插入一个值为x的元素。
- 首先输入顺序表中元素的个数n,然后依次输入n个数据元素来创建一个顺序表L。
- 首先输入顺序表中元素的个数n,然后依次输入n个数据元素来创建一个顺序表L。
- 单链表:单链表的创建算法(头插法) 设有一个带头结点的链表,存储结构为
- 单链表上的基础操作之插入算法,请将函数int InsertElem( LinkList *head, int i, ElemType e),其中i为要插入元素的位序
- 其中data为整形数域,next为指针域,编写函数将带头结点的单链表L中的所有数据元素的平均值
- 单链表:将单链表中所有数据域小于1的元素删除
- 设单链表的表头指针为head,结点结构由data和next两个域构成,其中data是字符型,
- 已知线性表中的元素是无序的,元素序列为(10,40,50,90,60,78,99,86,43,21),
- 在带头结点的单链表中删除所有值为e的数据元素。
- 双链表及其他链式结构:递增有序的双链表中插入元素
- 题目中设计了一个数制转换算法SZZH,将十进制制数n转换为m进制数。
- 题目设计了链栈的进栈,出栈,求栈的深度,取栈顶元素算法,判断栈是否空的操作
- 数制转换,将十进制制数n转换为m进制数
数据结构题
本题要求编写程序,输入N个学生的MOOC成绩,统计优秀、合格证书的数量,以及没有获得证书的数量。
本题要求编写程序,输入N个学生的MOOC成绩,统计优秀、合格证书的数量,以及没有获得证书的数量。学生修读程序设计MOOC,85分及以上获得优秀证书,不到85分但是60分及以上获得合格证书,不到60分则没有证书,设计函数补全子片段int returned(int a[],int n,int b[3])。
输入格式:
输入在第一行中给出非负整数N,即学生人数。第二行给出N个非负整数,即这N位学生的成绩,其间以空格分隔。
输出格式:
在一行中依次输出优秀证书、合格证书、没有获得证书的数量,中间以空格分隔。请注意,最后一个数字后没有空格。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:7 输出1:2 3 2
85 59 86 60 84 61 45
输入2:4 输出2:3 1 0
91 100 88 75
—————————————————————————————————
#include<stdio.h>
int returned(int a[],int n,int b[3])
{
int i;
for(i=0;i<n;i++)
{
if(a[i]>=85)
b[0]++;
else if(a[i]>=60)
b[1]++;
else
b[2]++;
}
return 0;
}
int main(void)
{
int n,a[10000],i,b[3]= {0};
scanf(“%d”,&n);
if(n>=0)
for(i=0; i<n; i++)
scanf(“%d”,&a[i]);
returned(a,n,b);
printf(“%d %d %d”,b[0],b[1],b[2]);
}
利用函数计算素数个数并求和:输入两个正整数 m 和n(m≤n),统计并输出m
基本算法及优化:判断素数、求素数和
——————————————————————————————————
利用函数计算素数个数并求和:输入两个正整数 m 和n(m≤n),统计并输出m 和n之间的素数的个数以及这些素数的和。要求定义并调用函数 prime (m)判断 m 是否为素数。试编写相应程序。
素数就是只能被1和自身整除的正整数。注意:1不是素数,2是素数。
函数接口定义:
int prime( int p );
int PrimeSum( int m, int n );
其中函数prime当用户传入参数p为素数时返回1,否则返回0;函数PrimeSum返回区间[m,n]内所有素数的和。题目保证用户传入的参数m≤n。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:-1 10 输出1:Sum of ( 2 3 5 7 ) = 17
——————————————————————————————————
#include <stdio.h>
#include <math.h>
int prime( int p )
{
int i;
if(p<=1)
return 0;
for(i=2;i<=p/2;i++)
if(p%i0||p2)
return 0;
return 1;
}
int PrimeSum( int m, int n )
{
int sum=0,i;
for(i=0;i<=n;i++)
{
if(prime(i)==1)
sum=sum+i;
}
return sum;
}
int main() {
int m, n, p;
scanf(“%d %d”,&m,&n);
printf(“Sum of ( “);
for( p=m; p<=n; p++ ) {
if( prime§ != 0 )
printf(”%d “, p);
}
printf(”) = %d\n”, PrimeSum(m,n));
return 0;
}
猜数字游戏:先输入 2 个不超过 100 的正整数,分别是被猜数 mynumber 和允许猜测的最大次数 n,再输入你所猜的数 yournumber,与被猜数 mynumber 进行比较,
【程序题】
基本算法及优化:猜数字游戏
——————————————————————————————————
猜数字游戏:先输入 2 个不超过 100 的正整数,分别是被猜数 mynumber 和允许猜测的最大次数 n,再输入你所猜的数 yournumber,与被猜数 mynumber 进行比较,若相等,显示猜中,;若不等,显示与被猜数的大小关系(small、big), 最多允许猜 n 次。如果 1 次就猜出该数,提示“bingo!”;如果 3 次以内猜到该 数,则提示“lucky guess!” ;如果超过 3 次但不超过 n 次猜到该数,则提示“good guess!”;如果超过 n 次都没有猜到,则提示“game over”;如果在到达 n 次之 前,用户输入了一个负数,也输出“game over”,并结束程序。试编写相应程序。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:58 4 输出1:big
70 small
50 small
56 good guess!
58
——————————————————————————————————
#include<stdio.h>
int GuessNum(int mynub,int n)
{
int cnt=0,a;
do{
scanf(“%d”,&a);
cnt++;
if(a==mynub)
break;
else if(a>mynub)
printf(“big”);
else
printf(“small”);
}while(a!=mynub&&cnt<=n);
if(cnt>n)
printf(“game over”);
if(cnt<=1)
printf(“bingo!”);
else if(cnt<=3)
printf(“lucky guess!”);
else
printf(“goof gurdd!”);
return 0;
}
int main () {
int mynub,n,i
scanf(“%d %d”,&mynub,&n);
GuessNum(mynub,n);
return 0;
}
顺序表:在顺序表L中查找第一个值最大的元素,并删除该元素。
【程序题】
顺序表:在顺序表L中查找第一个值最大的元素,并删除该元素。
——————————————————————————————————
在顺序表L中查找第一个值最大的元素,并删除该元素。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:4 输出1:2,3,1,
2 5 3 1
——————————————————————————————————
#include<stdio.h>
#include<stdlib.h>
#define LISTINITSIZE 20
#define INCREAMENT 5
typedef int ElemType;
typedef struct
{
ElemType *elem;
int length;
int listsize;
} Seqlist;
void Initlist(Seqlist *L)
{
int n, i;
L->elem=(ElemType *)malloc(sizeof(ElemType)*LISTINITSIZE);
scanf(“%d”, &n);
for(i=0; i<n; i++)
{
scanf(“%d”, &L->elem[i]);
}
L->length=n;
L->listsize=LISTINITSIZE;
}
void Prtlist(Seqlist L)
{
int i;
for(i=0; i<L.length; i++)
{
printf("%d ",L.elem[i]);
}
}
void fun(Seqlist *L)
{
int i,t=L->elem[0],j;
for(i=0;ilength;i++){
if(telem[i]){
t=L->elem[i];
}
}
for(i=0;ilength;i++){
if(t==L->elem[i]){
j=i;
break;
}
}
for(i=L->length;j<i;j++){ L->elem[j]=L->elem[j+1];
}
L->length–;
}
int main(void)
{ Seqlist L;
Initlist(&L);
fun(&L);
Prtlist(L);
}
顺序表:在顺序表L中查找最后一个值最小的元素,在该位置上插入一个值为x的元素。
【程序题】
顺序表:在顺序表L中查找最后一个值最小的元素,在该位置上插入一个值为x的元素。
——————————————————————————————————
在顺序表L中查找最后一个值最小的元素,在该位置上插入一个值为x的元素。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1: 输出1:4 5 888 1 3
4
4 5 1 3
888
——————————————————————————————————
#include<stdio.h>
#include<stdlib.h>
#define LISTINITSIZE 20
#define INCREAMENT 5
typedef int ElemType;
typedef struct
{
ElemType *elem;
int length;
int listsize;
}Seqlist;
void Initlist(Seqlist *L)
{
int n, i;
L->elem=(ElemType *)malloc(sizeof(ElemType)*LISTINITSIZE);
scanf(“%d”, &n);
for(i=0;i<n;i++)
{
scanf(“%d”, &L->elem[i]);
}
L->length=n;
L->listsize=LISTINITSIZE;
}
void Prtlist(Seqlist L)
{
int i;
for(i=0;i<L.length;i++)
{
printf(“%d “,L.elem[i]);
}
}
void fun(Seqlist *L,ElemType x)
{
int i,j=0;
for (i=1;ilength;i++)
if (L->elem[i]<=L->elem[j])
j=i;
for (i=L->length;i>j;i–) L->elem[i]=L->elem[i-1];
L->elem[j]=x;
L->length++;
}
int main(void)
{
Seqlist L;
ElemType x;
Initlist(&L);
scanf(”%d”, &x);
fun(&L,x);
Prtlist(L);
}
首先输入顺序表中元素的个数n,然后依次输入n个数据元素来创建一个顺序表L。
程序题】
顺序表::在顺序表L中的第i个位置插入元素e。
——————————————————————————————————
首先输入顺序表中元素的个数n,然后依次输入n个数据元素来创建一个顺序表L。
请设计一个算法:实现在顺序表L中的第i个位置插入元素e。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1: 输出1:2 5 888 1 3
4
2 5 1 3
3,888
输入2: 输出1:888 11 22 33 44 55
5
11 22 33 44 55
1,888
——————————————————————————————————
#include<stdio.h>
#include<stdlib.h>
#define LISTINITSIZE 20
#define INCREAMENT 5
typedef int ElemType;
typedef struct
{
ElemType *elem;
int length;
int listsize;
} Seqlist;
void Initlist(Seqlist *L)
{
int n, i;
L->elem=(ElemType *)malloc(sizeof(ElemType)*LISTINITSIZE);
scanf(“%d”, &n);
for(i=0; i<n; i++)
{
scanf(“%d”, &L->elem[i]);
}
L->length=n;
L->listsize=LISTINITSIZE;
}
void Prtlist(Seqlist L)
{
int i;
for(i=0; i<L.length; i++)
{
printf("%d ",L.elem[i]);
}
}
int ListInsert(Seqlist *L,int i,ElemType e)
{
if (i<1||i>L->length||L->length>=LISTINITSIZE)
return false;
for(int j=L->length; j>=i; j–)
L->elem[j]=L->elem[j-1];
L->elem[i-1]=e;
L->length++;
return true;
}
int main(void)
{ Seqlist L;
int i,e;
Initlist(&L);
scanf(“%d,%d”,&i,&e);
ListInsert(&L,i,e);
Prtlist(L);
}
首先输入顺序表中元素的个数n,然后依次输入n个数据元素来创建一个顺序表L。
【程序题】
顺序表::顺序表中的元素逆序存放在当前表中。
——————————————————————————————————
首先输入顺序表中元素的个数n,然后依次输入n个数据元素来创建一个顺序表L。
请设计一个算法:本题要求编写程序,实现将顺序表中的元素逆序存放到当前顺序表。
输入格式:
输入第一行是顺序表长度n。接下来输入n个元素。
输出格式:
输出为将顺序表中元素逆序存放后的元素。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1: 输出1:4 5 2 3 1
5
1 3 2 5 4
输入2: 输出2:10 8 6 4 2 9 7 5 3 1
10
1 3 5 7 9 2 4 6 8 10
—————————————————————————————————
#include <stdio.h>
#include <stdlib.h>
#define LISTINITSIZE 20
#define INCREAMENT 5
typedef int ElemType;
typedef struct {
ElemType *elem;
int length;
int listsize;
} Seqlist;
void Initlist(Seqlist *L)
{
int n, i;
L->elem = (ElemType *)malloc(sizeof(ElemType) * LISTINITSIZE);
scanf(“%d”, &n);
for (i = 0; i < n; i++)
{
scanf(“%d”, &L->elem[i]);
}
L->length = n;
L->listsize = LISTINITSIZE;
}
void Prtlist(Seqlist L)
{
int i;
for (i = 0; i < L.length; i++)
{
printf("%d ", L.elem[i]);
}
}
void fun(Seqlist *L)
{
int k;
int i;
for(i=1;i<=L->length/2;i++){
k=L->elem[i-1];
L->elem[i-1]=L->elem[L->length-i];
L->elem[L->length-i]=k;
}
}
int main(void)
{
Seqlist L;
Initlist(&L);
fun(&L);
Prtlist(L);
}
单链表:单链表的创建算法(头插法) 设有一个带头结点的链表,存储结构为
【程序题】
单链表:单链表的创建算法(头插法)
设有一个带头结点的链表,存储结构为
Typedef struct Node
{
ElemType data;
Struct Node *next;
}linklist;
其中data为整形数域,next为指针域,编写函数创建一个带头结点的单链表
给指针p开辟结点空间的语句为:p = (LinkList *)malloc(sizeof(LinkList));
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:3 输出1:33,22,11,
11 22 33
输入2:5 输出2:55,44,33,22,11,
11 22 33 44 55
——————————————————————————————————
#include<stdio.h>
#include<malloc.h>
typedef struct node
{
int data;
struct node *next;
} LinkList;
LinkList *CreateList(int n)
{
int i;
LinkList *head,*p;
head=(LinkList *)malloc(sizeof(LinkList));
head->next=NULL;
for(i=0;i<n;i++){
p=(LinkList *)malloc(sizeof(LinkList));
scanf(“%d”,&(p->data));
p->next=head->next;
head->next=p;
}
return head;
}
void PrintList(LinkList *head)
{
LinkList *p = head->next;
while (p != NULL)
{
printf(“%d,”, p->data);
p = p->next;
}
}
int main()
{
LinkList *head;
int n;
scanf(“%d”, &n);
head = CreateList(n);
PrintList(head);
}
单链表上的基础操作之插入算法,请将函数int InsertElem( LinkList *head, int i, ElemType e),其中i为要插入元素的位序
【程序题】
单链表:单链表的插入算法
——————————————————————————————————
单链表上的基础操作之插入算法,请将函数int InsertElem( LinkList *head, int i, ElemType e),其中i为要插入元素的位序,插入位序的合法范围为1-6,e为要插入元素,函数返回值为操作成功(OK)与否(ERROR)。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:1 2 3 4 5 输出1:Success!
6 6 1,2,3,4,5,6,
输入2:1 2 3 4 5 输出2:Failed!
7 9 1,2,3,4,5,
#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
#define N 5
typedef int ElemType;
typedef struct node {
ElemType data;
struct node *next;
} LinkList;
LinkList *InitList() {
LinkList *head;
head = ( LinkList *)malloc( sizeof(LinkList));
head->next = NULL;
return head;
}
LinkList *CreateList(int n) {
int i;
LinkList *head, *p, *r;
head = ( LinkList *)malloc(sizeof(LinkList));
r = head;
for ( i = 1; i <= n; i++) {
p = ( LinkList *)malloc( sizeof( LinkList));
scanf(“%d”, &( p->data));
r->next = p;
r = p;
}
r->next = NULL;
return head;
}
void PrintLinkList(LinkList *head) {
LinkList *p;
p = head->next;
while ( p != NULL) {
printf(“%d,”, p->data);
p = p->next;
}
}
int InsertElem( LinkList *head, int i, ElemType e) {
int cnt=0;
LinkList *s,*p;
if(i<1)
return ERROR;
p=head;
while(cnt<i-1&&p!=NULL)
{
p=p->next;
cnt++;
}
if(p==NULL)
return ERROR;
s=(LinkList *)malloc(sizeof(LinkList));
s->data=e;
s->next=p->next;
p->next=s;
return OK;
}
int main() {
LinkList *head;
int i;
ElemType e;
head = CreateList(N);
scanf(“%d %d”, &i, &e);
if (!InsertElem( head, i, e))
printf(“Failed!\n”);
else
printf(“Success!\n”);
PrintLinkList(head);
}
其中data为整形数域,next为指针域,编写函数将带头结点的单链表L中的所有数据元素的平均值
【程序题】
单链表:求单链表的数据域的平均值
——————————————————————————————————
设有一个带头结点的链表,存储结构为
Typedef struct Node
{
ElemType data;
Struct Node *next;
}linklist;
其中data为整形数域,next为指针域,编写函数将带头结点的单链表L中的所有数据元素的平均值,请将double average(linklist *head)功能补充完整,最后输出结果要求保留两位小数.
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:4 输出1:15.00
15 15 15 15
输入2:6 输出2:5.67
2 8 9 6 3 6
输入3:9 输出3:55.00
11 22 33 44 55 66 77 88 99
——————————————————————————————————
#include<stdio.h>
#include<stdlib.h>
#define ok 1
#define error 0
typedef int ElemType;
typedef struct node
{
ElemType data;
struct node *next;
}linklist;
linklist *initlist()
{
linklist *head;
head=(linklist *)malloc(sizeof(linklist));
head->next=NULL;
return head;
}
linklist *createlist(int n)
{
int i;
linklist *head,*p,*r;
head=(linklist *)malloc(sizeof(linklist));
r=head;
for(i=1;i<=n;i++)
{
p=(linklist *)malloc(sizeof(linklist));
scanf(“%d”,&(p->data));
r->next=p;
r=p;
}
r->next=NULL;
return head;
}
double average(linklist *head)
{
double sum=0,aver=0;
int cnt=0;
linklist *p;
p=head->next;
while(p!=NULL){
sum+=p->data;
p=p->next;
cnt++;
}
aver=sum/cnt;
return aver;
}
int main(void)
{
linklist *L;
int i,n;
double ave;
scanf(“%d”,&n);
initlist();
L=createlist(n);
ave=average(L);
printf(“%.2lf”,ave);
}
单链表:将单链表中所有数据域小于1的元素删除
【程序题】
单链表:将单链表中所有数据域小于1的元素删除
——————————————————————————————————
设有一个代头结点的链表,存储结构为:
typedef struct Node
{
ElemType data;
Struct Node *next;
}linklist;
其中,data为数据域,next为指针域,编写程序将链表中的data域值小于1的所有节点删除,补全子函数void cutof(linklist *head)。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:5 输出1:1,2,3,4,5,
1 2 3 4 5
输入2:10 输出2:11,22,33,44,55,66,77,88,99,
11 22 33 44 55 -55 66 77 88 99
——————————————————————————————————
#include<stdio.h>
#include<stdlib.h>
#define ok 1
#define error 0
typedef int ElemType;
typedef struct node
{
ElemType data;
struct node *next;
}linklist;
linklist *initlist()
{
linklist *head;
head=(linklist *)malloc(sizeof(linklist));
head->next=NULL;
return head;
}
linklist *createlist(int n)
{
int i;
linklist *head,*p,*r;
head=(linklist *)malloc(sizeof(linklist));
r=head;
for(i=1;i<=n;i++)
{
p=(linklist *)malloc(sizeof(linklist));
scanf(“%d”,&(p->data));
r->next=p;
r=p;
}
r->next=NULL;
return head;
}
void cutof(linklist *head)
{
linklist *p,*q,*r,*t,*f;
int i=0,j=0;
q=(linklist *)malloc(sizeof(linklist));
q->next=NULL;
p=head;
while(p!=NULL){
p=p->next;
j++;
}
p=head->next;
t=q;
for(;i<j-1;i++){
if(p->data>=1){
r=(linklist *)malloc(sizeof(linklist));
r->data=p->data;
t->next=r;
t=r;
}
p=p->next;
}
t->next=NULL;
head->next=q->next;
}
void printflist(linklist *head)
{
linklist *p;
p=head->next;
if (head->next==NULL)
printf(“LinkList empty!”);
while(p!=NULL)
{
printf(“%d,”,p->data);
p=p->next;
}
}
int main(void)
{
linklist *L;
int i,n;
scanf(“%d”,&n);
initlist();
L=createlist(n);
cutof(L);
printflist(L);
}
设单链表的表头指针为head,结点结构由data和next两个域构成,其中data是字符型,
【程序题】
单链表:判断单链表是否中心对称
——————————————————————————————————
设单链表的表头指针为head,结点结构由data和next两个域构成,其中data是字符型,写出中心算法,判断该链表的前n个字符是否为中心对称,例如 xyx 和 xyyx 都是中心对称,请将函数int DuiChen(LinkList *head)补充完整,其中是中心对称返回1,不是返回0。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:3 输出1:True!
xyx
输入2:4 输出2:False!
xyxy
——————————————————————————————————
我的答案:
#include <stdio.h>
#define OK 1
#include <stdlib.h>
#include <malloc.h>
typedef struct node {
char data;
struct node *next;
} LinkList;
LinkList *InitList() {
LinkList *head;
head = (LinkList *)malloc(sizeof(LinkList));
head->next = NULL;
return head;
}
LinkList *CreateList(int n) {
int i;
LinkList *head, *p, *r;
head = (LinkList *)malloc(sizeof(LinkList));
r = head;
for (i = 1; i <= n; i++) {
p = (LinkList *)malloc(sizeof(LinkList));
scanf(“%c”, &(p->data ));
r->next = p;
r = p;
}
r->next = NULL;
return head;
}
void PrintList(LinkList *head) {
int cnt = 0;
LinkList *p = head->next ;
while (p != NULL) {
cnt++;
printf(“%c,”, p->data);
p = p->next ;
}
printf(“\n”);
printf(“该单链表的长度为: %d\n”, cnt);
}
int DuiChen(LinkList *head) {
LinkList *p,*q,*r,*t,*f;
int i=1,j=1;
q=(LinkList *)malloc(sizeof(LinkList));
q->next=NULL;
p=head;
while(p!=NULL){
p=p->next;
j++;
}
p=head->next;
for(;i<j-1;i++){
r=(LinkList *)malloc(sizeof(LinkList));
r->data=p->data;
r->next=q->next;
q->next=r;
p=p->next;
}
i=1;
int s=1;
p=head->next;
t=q->next;
for(;i<j-1;i++){
if(p->data==t->data){
s++;
}
p=p->next;
t=t->next;
}
if(s==j-1){
return 1;
}else{
return 0;
}
}
int main() {
LinkList *head;
int n;
scanf(“%d”, &n);
getchar();
head = CreateList(n);
if (DuiChen(head)) {
printf(“True!\n”);
} else {
printf(“False!\n”);;
}
}
已知线性表中的元素是无序的,元素序列为(10,40,50,90,60,78,99,86,43,21),
程序题】
单链表:删除区间元素
——————————————————————————————————
已知线性表中的元素是无序的,元素序列为(10,40,50,90,60,78,99,86,43,21),实现一个删除表中所有值小于max但大于min的元素算法,该线性表以带头结点的单链表的存储结构
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:10 99 输出1:10 99
输入2:89 100 输出2:10 40 50 60 78 86 43 21
输入3:100 89 输出3:10 40 50 60 78 86 43 21
——————————————————————————————————
我的答案:
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct node {
ElemType data;
struct node *next;
} LinkList;
LinkList *InitList() {
LinkList *head;
head=(LinkList *)malloc(sizeof(LinkList));
head->next=NULL;
return head;
}
LinkList *CreateList(int num[]) {
int i;
LinkList *head,*p,*r;
head=(LinkList *)malloc(sizeof(LinkList));
r=head;
for(i=0; i<10; i++) {
p=(LinkList *)malloc(sizeof(LinkList));
p->data=num[i];
r->next=p;
r=p;
}
r->next=NULL;
return head;
}
void printLinkList(LinkList *head) {
LinkList *p;
p = head->next;
while(p!=NULL) {
printf("%d ",p->data);
p = p->next;
}
}
void deleted(LinkList *head, int max,int min)
{
LinkList *p,*q,*r,*t,*f;
int i=0,j=0;
q=(LinkList *)malloc(sizeof(LinkList));
q->next=NULL;
p=head;
while(p!=NULL){
p=p->next;
j++;
}
p=head->next;
t=q;
for(;i<j-1;i++){
if(p->data<=min||p->data>=max){
r=(LinkList *)malloc(sizeof(LinkList));
r->data=p->data;
t->next=r;
t=r;
}
p=p->next;
}
t->next=NULL;
head->next=q->next;
}
int main(void) {
int max,min,temp;
int num[10]= {10,40,50,90,60,78,99,86,43,21};
LinkList *mylist;
scanf(“%d %d”,&max,&min);
if(min>max) {
temp=max;
max=min;
min=temp;
}
mylist=CreateList(num);
deleted(mylist,max,min);
printLinkList(mylist);
return 0;
}
在带头结点的单链表中删除所有值为e的数据元素。
程序题】
单链表:在带头结点的单链表中删除所有值为e的元素。
——————————————————————————————————
在带头结点的单链表中删除所有值为e的数据元素。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:5 输出1:1,2,3,4,5,
1 2 3 4 5
输入2:10 输出2:11,22,33,44,55,66,77,88,99,
11 22 33 44 55 -55 66 77 88 99
——————————————————————————————————
我的答案:
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct node
{
ElemType data;
struct node *next;
}Linklist;
void Prtlist(Linklist *head)
{
Linklist *p;
p=head->next;
while(p!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
}
Linklist *TCreatlist(int n)
{
int i;
Linklist *head,*p, *r;
head=(Linklist *)malloc(sizeof(Linklist));
r=head;
for(i=1;i<=n;i++)
{
p=(Linklist *)malloc(sizeof(Linklist));
scanf(“%d”, &p->data);
r->next=p;
r=p;
}
r->next=NULL;
return head;
}
void DeletElem(Linklist *h, ElemType e)
{
Linklist *p,*q,*r,*t,*f;
int i=0,j=0;
q=(Linklist *)malloc(sizeof(Linklist));
q->next=NULL;
p=h;
while(p!=NULL){
p=p->next;
j++;
}
p=h->next;
t=q;
for(;i<j-1;i++){
if(p->data!=e){
r=(Linklist *)malloc(sizeof(Linklist));
r->data=p->data;
t->next=r;
t=r;
}
p=p->next;
}
t->next=NULL;
h->next=q->next;
}
int main(void)
{
Linklist *head;
int n, x;
ElemType t;
scanf(“%d”, &n);
head=TCreatlist(n);
scanf(“%d”, &t);
DeletElem(head,t);
Prtlist(head);
}
双链表及其他链式结构:递增有序的双链表中插入元素
程序题】
双链表及其他链式结构:递增有序的双链表中插入元素
在递增有序的双链表中插入一个元素使之任然具有递增有序的性质。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:3 输出1:11 20 22 33
11 22 33
20
输入2:5 输出2:11 22 33 44 55 60
11 22 33 44 55
60
——————————————————————————————————
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct H
{
ElemType data;
struct H *next;
struct H *before;
}DulLinkList;
DulLinkList *Initialize(int a[],int n);
void prt(DulLinkList *head);
void insert(DulLinkList *head,int x);
int main()
{
int a[100];
int n,i,x;
DulLinkList *head;
scanf(“%d”,&n);
for(i=0; i<n; i++)
{
scanf(“%d”,&a[i]);
}
head=Initialize(a,n);
scanf(“%d”,&x);
insert(head,x);
prt(head);
return 0;
}
DulLinkList *Initialize(int a[],int n)
{
DulLinkList *p,*head,*r;
int i=0;
head=(DulLinkList *)malloc(sizeof(DulLinkList));
if(head==NULL)
{
printf(“ERROR\n”);
exit(1);
}
head->before=NULL;
head->next=NULL;
r=head;
for(i=0; i<n; i++)
{
p=(DulLinkList *)malloc(sizeof(DulLinkList));
p->data=a[i];
r->next=p;
p->before=r;
r=p;
}
r->next=NULL;
return head;
}
void prt(DulLinkList *head)
{
DulLinkList *p;
p=head->next;
while(p!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
printf(“\n”);
}
void insert(DulLinkList *head,int x)
{
DulLinkList *p,*q,*s;
p=head->next;
if(x<=p->data){
s=(DulLinkList *)malloc(sizeof(DulLinkList));
s->data=x;
head->next=s;
s->before=head;
s->next=p;
p->before=s;
}else{
while(p!=NULL&&x>p->data){
p=p->next;
}
if(p==NULL){
p=head->next;
while(p->next!=NULL){
p=p->next;}
s=(DulLinkList *)malloc(sizeof(DulLinkList));
s->data=x;
p->next=s;
s->before=p;
s->next=NULL;
}else{
q=p->before;
s=(DulLinkList *)malloc(sizeof(DulLinkList));
s->data=x;
q->next=s;
s->before=q;
s->next=p;
p->before=s;
}}
}
2
【程序题】
双链表及其他链式结构:双链表的创建算法(尾插法)
请设计一个算法实现用尾插法创建一个双链表。调用已写好的函数printlist将该双链表从前向后打印双链表中的元素一遍,然后再从后向前打印双链表中的元素一遍。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:3 输出1:11 22 33 33 22 11
11 22 33
输入2:5 输出2:11 22 33 44 55 55 44 33 22 11
11 22 33 44 55
——————————————————————————————————
驱动程序:
#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
typedef int Elemtype;
typedef struct node
{
Elemtype data;
struct node *next,*before;
}dullinklist;
dullinklist *createlist(int n)
{
}
void printlist(dullinklist *head)
{
dullinklist *pre,*p;
pre=head;
p=head->next;
while(p!=NULL)
{
printf("%d ",p->data);
pre=p;
p=p->next;
}
while(pre!=head)
{
printf("%d ",pre->data);
pre=pre->before;
}
}
int main()
{
dullinklist *head;
int n;
scanf(“%d”,&n);
head=createlist(n);
printlist(head);
}
请下载下面附件中的程序,并将其拷贝到DEVC++补全子函数。
双链表的创建(尾插法).txt
我的答案:
#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
typedef int Elemtype;
typedef struct node
{
Elemtype data;
struct node *next,*before;
}dullinklist;
dullinklist *createlist(int n)
{
dullinklist *head,*p,*q,*r;
int i;
head=(dullinklist *)malloc(sizeof(dullinklist));
head->next=NULL;
p=head;
for(i=1;i<=n;i++){
q=(dullinklist *)malloc(sizeof(dullinklist));
scanf(“%d”,&(q->data));
p->next=q;
q->before=p;
p=q;
}
p->next=NULL;
return head;
}
void printlist(dullinklist *head)
{
dullinklist *pre,*p;
pre=head;
p=head->next;
while(p!=NULL)
{
printf("%d ",p->data);
pre=p;
p=p->next;
}
while(pre!=head)
{
printf("%d ",pre->data);
pre=pre->before;
}
}
int main()
{
dullinklist *head;
int n;
scanf(“%d”,&n);
head=createlist(n);
printlist(head);
}
3
【程序题】
双链表及其他链式结构:双循环链表的创建算法(尾插法)
请设计一个算法实现用尾插法创建一个双循环链表。调用已写好的函数printlist将该双循环链表中的元素从前向后打印一遍,然后再从后向前打印一遍。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1:3 输出1:11 22 33 33 22 11
11 22 33
输入2:5 输出2:11 22 33 44 55 55 44 33 22 11
11 22 33 44 55
——————————————————————————————————
驱动程序:
#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
typedef int Elemtype;
typedef struct node
{
Elemtype data;
struct node *next,*before;
}dullinklist;
dullinklist *createlist(int n)
{
}
void printlist(dullinklist *head)
{
dullinklist *p;
p=head->next;
while(p!=head)
{
printf("%d ",p->data);
p=p->next;
}
p=head->before;
while(p!=head)
{
printf("%d ",p->data);
p=p->before;
}
}
int main()
{
dullinklist *head;
int n;
scanf(“%d”,&n);
head=createlist(n);
printlist(head);
}
请下载下面附件中的程序,并将其拷贝到DEVC++补全子函数。
双循环链表的创建(尾插法) (1).txt
我的答案:
#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
typedef int Elemtype;
typedef struct node
{
Elemtype data;
struct node *next,*before;
}dullinklist;
dullinklist *createlist(int n)
{
dullinklist *head,*p,*q,*r;
int i;
head=(dullinklist *)malloc(sizeof(dullinklist));
head->next=head;
p=head;
for(i=1;i<=n;i++){
q=(dullinklist *)malloc(sizeof(dullinklist));
scanf(“%d”,&(q->data));
p->next=q;
q->before=p;
p=q;
}
p->next=head;
head->before=p;
return head;
}
void printlist(dullinklist *head)
{
dullinklist *p;
p=head->next;
while(p!=head)
{
printf("%d ",p->data);
p=p->next;
}
p=head->before;
while(p!=head)
{
printf("%d ",p->data);
p=p->before;
}
}
int main()
{
dullinklist *head;
int n;
scanf(“%d”,&n);
head=createlist(n);
printlist(head);
}
4
【程序题】
双链表及其他链式结构:删除双链表中第i个结点
——————————————————————————————————————————————————
题目中输入一个n,然后输入n个值,随后在输入需要删除的位置(注意双链表的打印的时候是向前向后打印,具体实例请参见测试样例),请补全DeleteElem(DulLinkList *head,int i)
函数所缺失的部分来实现这个算法。
——————————————————————————————————————————————————
测试用例
——————————————————————————————————————————————————
输入1:
5
11 22 33 44 55
2
输出1:
11 33 44 55 55 44 33 11
输入2:
7
49 38 97 76 13 27 45
0
输出2:
49 38 97 76 13 27 45 45 27 13 76 97 38 49
——————————————————————————————————————————————————
驱动程序:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ERROR 0
#define OK 1
typedef int ElemType;
typedef struct node
{
ElemType data;
struct node *next,*before;
}DulLinkList;
DulLinkList *CreatList(int n)
{
int i;
DulLinkList *head,*p,*r;
head=(DulLinkList *)malloc(sizeof(DulLinkList));
head->before=NULL;
r=head;
for(i=1;i<=n;i++){
p=(DulLinkList *)malloc(sizeof(DulLinkList));
scanf(“%d”,&(p->data));
r->next=p;
p->before=r;
r=p;
}
r->next=NULL;
return head;
}
int DeleteElem(DulLinkList *head,int i)
{
int j=0;
DulLinkList *p,*q;
if(i<1)
{
return ERROR;
}
p=head;
while(p->next!=NULL&&j<i-1)
{
p=p->next;
j++;
}
if(p->next==NULL)
{
return ERROR;
}
q=p->next;
return OK;
}
void PrintList(DulLinkList *head)
{
DulLinkList *pre,*p;
pre=head;
p=head->next;
while(p!=NULL)
{
printf("%d ",p->data);
pre=p;
p=p->next;
}
while(pre!=head)
{
printf("%d ",pre->data);
pre=pre->before;
}
}
int main(void)
{
DulLinkList *L;
int i,n;
scanf(“%d”,&n);
L=CreatList(n);
scanf(“%d”,&i);
DeleteElem(L,i);
PrintList(L);
}
双链表的删除.txt
我的答案:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ERROR 0
#define OK 1
typedef int ElemType;
typedef struct node
{
ElemType data;
struct node *next,*before;
}DulLinkList;
DulLinkList *CreatList(int n)
{
int i;
DulLinkList *head,*p,*r;
head=(DulLinkList *)malloc(sizeof(DulLinkList));
head->before=NULL;
r=head;
for(i=1;i<=n;i++){
p=(DulLinkList *)malloc(sizeof(DulLinkList));
scanf(“%d”,&(p->data));
r->next=p;
p->before=r;
r=p;
}
r->next=NULL;
return head;
}
int DeleteElem(DulLinkList *head,int i)
{
int j=0;
DulLinkList *p,*q;
if(i<1)
{
return ERROR;
}
p=head;
while(p->next!=NULL&&j<i-1)
{
p=p->next;
j++;
}
if(p->next==NULL)
{
return ERROR;
}
q=p->next;
p->next=q->next;
q->next->before=p;
return OK;
}
void PrintList(DulLinkList *head)
{
DulLinkList *pre,*p;
pre=head;
p=head->next;
while(p!=NULL)
{
printf("%d ",p->data);
pre=p;
p=p->next;
}
while(pre!=head)
{
printf("%d ",pre->data);
pre=pre->before;
}
}
int main(void)
{
DulLinkList *L;
int i,n;
scanf(“%d”,&n);
L=CreatList(n);
scanf(“%d”,&i);
DeleteElem(L,i);
PrintList(L);
}
5
【程序题】
双链表及其他链式结构:求双链表的长度
——————————————————————————————————————————————————
题目中输入一个n,然后输入n个值,在createlist()中已挑选出了这n个值中满足条件的元素创建了一个双链表。请你写一个求双链表长度的算法,在主函数调用该算法求出双链表的长度来。
——————————————————————————————————————————————————
测试用例
——————————————————————————————————————————————————
输入1:
5
11 22 33 44 55
输出1:
4
输入2:
10
10 9 8 7 6 5 4 3 2 1
输出2:
6
——————————————————————————————————————————————————
驱动程序:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ok 1
#define error 0
typedef int ElemType;
typedef struct node
{
ElemType data;
struct node *next;
struct node *before;
}dullinklist;
dullinklist *createlist(int n)
{
int i,x;
dullinklist *head, *p, *r;
head= (dullinklist *)malloc(sizeof(dullinklist));
head->before=NULL;
r=head;
for(i=1;i<=n;i++)
{
scanf(“%d”,&x);
if(x%7!=0 && x%3!=0)
{
p=(dullinklist *)malloc(sizeof(dullinklist));
p->data=x;
r->next=p;
p->before=r;
r=p;
}
}
r->next=NULL;
return head;
}
int ListLength(dullinklist *head)
{
}
int main(void)
{
dullinklist *myhead;
int n,mylen;
scanf(“%d”,&n);
myhead=createlist(n);
mylen=ListLength(myhead);
printf(“%d”,mylen);
}
求双链表的长度.txt
我的答案:
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define ok 1
#define error 0
typedef int ElemType;
typedef struct node
{
ElemType data;
struct node *next;
struct node *before;
}dullinklist;
dullinklist *createlist(int n)
{
int i,x;
dullinklist *head, *p, *r;
head= (dullinklist *)malloc(sizeof(dullinklist));
head->before=NULL;
r=head;
for(i=1;i<=n;i++)
{
scanf(“%d”,&x);
if(x%7!=0 && x%3!=0)
{
p=(dullinklist *)malloc(sizeof(dullinklist));
p->data=x;
r->next=p;
p->before=r;
r=p;
}
}
r->next=NULL;
return head;
}
int ListLength(dullinklist *head)
{
int i=0;
dullinklist *p;
p=head->next;
while(p!=NULL){
if((p->data)%7!=0 && (p->data)%3!=0){
i++;}
p=p->next;
}
return i;
}
int main(void)
{
dullinklist *myhead;
int n,mylen;
scanf(“%d”,&n);
myhead=createlist(n);
mylen=ListLength(myhead);
printf(“%d”,mylen);
}
题目中设计了一个数制转换算法SZZH,将十进制制数n转换为m进制数。
程序题】
栈:顺序栈的基本操作及数制转换问题
——————————————————————————————————
题目中设计了一个数制转换算法SZZH,将十进制制数n转换为m进制数。这个算法中调用了顺序栈的一些基本操作,由于某程序员使用的是别人栈的基本操作,里面丢了一些语句(已经标出了位置,共有4处),请你补全这些基本语句。
——————————————————————————————————
测试用例:
输入:分别输入十进制数n,代转进制数m
——————————————————————————————————
输入1:100,16 输出1:64
输入2:97,2 输出1:1100001
——————————————————————————————————
我的答案:
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
typedef int ElemType;
#define STACK_INITSIZE 8
#define STACK_INCREAMENT 2
typedef struct node
{
ElemType *elem;
int top;
int stacksize;
} SeqStack;
int InitStack(SeqStack *S)
{
S->elem=(ElemType *)malloc(sizeof(ElemType)*STACK_INITSIZE);
if(!(S->elem))
return ERROR;
S->stacksize=STACK_INITSIZE;
S->top=0;
return OK;
}
int Push(SeqStack *S,ElemType e)
{
ElemType *newbase,newspacesize;
if(S->top>=S->stacksize-1)
{
newspacesize=(S->stacksize+STACK_INCREAMENT)*sizeof(ElemType);
newbase=(ElemType *)realloc(S->elem,newspacesize);
if(!newbase)
return ERROR;
S->elem=newbase;
S->stacksize+=STACK_INCREAMENT;
}
S->elem[S->top]=e;
/语句1,请补充/S->top++;
return OK;
}
int Pop(SeqStack *S,ElemType *e)
{
if(S->top<=0)
return ERROR;
*e=/语句2,请补充/S->elem[S->top-1];
S->top–;
return OK;
}
int StackEmpty(SeqStack *S)
{
if(/语句3,请补充/S->top==0)
return 1;
else
return 0;
}
void SZZH(int n,int m)
{
int n1,ys,e;
SeqStack S;
InitStack(&S);
n1=n;
while(n1>0)
{
ys=n1%m;
/语句4,请补充/Push(&S,ys);
n1=n1/m;
}
while(!StackEmpty(&S))
{
Pop(&S,&e);
if(e<=9)
printf(“%d”,e);
else
printf(“%c”,‘A’+e-10);
}
printf(“\n”);
}
int main()
{
int n,m;
scanf(“%d,%d”,&n,&m);
SZZH(n,m);
}
题目设计了链栈的进栈,出栈,求栈的深度,取栈顶元素算法,判断栈是否空的操作
【程序题】
栈:链栈的基本操作
——————————————————————————————————
题目设计了链栈的进栈,出栈,求栈的深度,取栈顶元素算法,判断栈是否空的操作。
首先输入想入栈的元素个数n,然后输入n个元素。输出时先输出栈顶元素,再输出栈的深度,最后输出栈内元素。里面
丢了一些语句(已经标出位置,共5处)请补全这些语句。
——————————————————————————————————
测试用例:
——————————————————————————————————
输入1: 输出1:5
6 6
1 2 3 4 5 6 5 6 4 3 2 1
输入2: 输出2:22
4 4
11 33 55 22 22 55 33 11
输入3: 输出3:1
5 5
6 3 9 0 1 1 0 9 3 6
——————————————————————————————————
我的答案:
#include<stdio.h>
#include<stdlib.h>
typedef struct LinkStackNode
{
int data;
LinkStackNode *next;
}LinkStackNode,*LinkStack;
void InitLinkStack(LinkStack *S)
{
*S=(LinkStackNode *)malloc(sizeof(LinkStackNode));
(*S)->next=NULL;
}
void Push(LinkStack S,int x)
{
LinkStackNode *p;
p=(LinkStackNode *)malloc(sizeof(LinkStackNode));
p->data=x;
p->next=S->next;
S->next=p;
}
int Pop(LinkStack S,int *x)
{
LinkStackNode *p;
if(S->next!=NULL)
{
p=S->next;
S->next=p->next;
*x=p->data;
free§;
return 1;
}
return 0;
}
int GetTop(LinkStack S,int *x)
{
if(S->next!=NULL)
{
*x=S->next->data;
return 1;
}
return 0;
}
int StackDepth(LinkStack S)
{
LinkStackNode *p;
int count = 0;
p=S->next;
while(p!=NULL)
{
++count;
p=p->next;
}
return count;
}
int StackEmpty(LinkStack S)
{
if(S->next==NULL)
return 1;
else
return 0;
}
int main()
{
LinkStack S;
InitLinkStack(&S);
int i,n,t,x,a[20];
scanf(“%d”,&n);
for(i=0;i<n;i++)
{
scanf(“%d”,&a[i]);
Push(S,a[i]);
}
GetTop(S,&x);
printf(“%d\n”,x);
printf(“%d\n”,StackDepth(S));
while(!StackEmpty(S))
{
Pop(S,&x);
printf("%d ",x);
}
return 0;
}
数制转换,将十进制制数n转换为m进制数
【程序题】
栈:依据栈的基本操作写一个数制转换算法
——————————————————————————————————
数制转换,将十进制制数n转换为m进制数
——————————————————————————————————
测试用例:
输入:分别输入十进制数n,代转进制数m
——————————————————————————————————
输入1:100 16 输出1:64
——————————————————————————————————
我的答案:
#include<stdio.h》
#include<malloc.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
typedef int ElemType;
#define STACK_INITSIZE 8
#define STACK_INCREAMENT 2
typedef struct node
{
ElemType *elem;
int top;
int stacksize;
}SeqStack;
int InitStack(SeqStack *S)
{
S->elem=(ElemType *)malloc(sizeof(ElemType)*STACK_INITSIZE);
if(!(S->elem))
return ERROR;
S->stacksize=STACK_INITSIZE;
S->top=0;
return OK;
}
int Push(SeqStack *S,ElemType e)
{
ElemType *newbase,newspacesize;
if(S->top>=S->stacksize-1)
{
newspacesize=(S->stacksize+STACK_INCREAMENT)*sizeof(ElemType);
newbase=(ElemType *)realloc(S->elem,newspacesize);
if(!newbase)
return ERROR;
S->elem=newbase;
S->stacksize+=STACK_INCREAMENT;
}
S->elem[S->top]=e;
S->top++;
return OK;
}
int Pop(SeqStack *S,ElemType *e)
{
if(S->top<=0)
return ERROR;
*e=S->elem[S->top-1];
S->top–;
return OK;
}
int StackEmpty(SeqStack *S)
{
if(S->top<=0)
return 1;
else
return 0;
}
void SZZH(int n,int m)
{
int n1,ys,e;
SeqStack S;
InitStack(&S);
n1=n;
while(n1>0) {
ys=n1%m;
Push(&S,ys);/语句4,请补充/;
n1=n1/m;
}
while(!StackEmpty(&S)) {
Pop(&S,&e);
if(e<=9)
printf(“%d”,e);
else
printf(“%c”,‘A’+e-10);
}
printf(“\n”);
}
int main(){
int n,m;
scanf(“%d%d”,&n,&m);
SZZH(n,m);
}