实习题目6_结构体2
（完整版）结构体与联合体习题与参考答案
（完整版）结构体与联合体习题与参考答案第八章结构体与联合体选择题1、若程序中有以下的说明和定义：struct abc{ int x;char y; } 花括号后少了分号。
struct abc s1,s2;则会发生的情况是______。
A) 编译时错B) 程序将顺序编译、连接、执行C) 能顺序通过编译、连接、但不能执行D) 能顺序通过编译、但连接出错2、有以下程序段struct st{ int x; int *y;}*pt;int a[]={1,2};b[]={3,4};struct st c[2]={10,a,20,b};pt=c;以下选项中表达式的值为11的是A) *pt->y B) pt->x C) ++pt->x D) (pt++)->x3、有以下说明和定义语句struct student{ int age; char num[8];};struct student stu[3]={{20,"200401"},{21,"200402"},{19,"200403"}};struct student *p=stu;以下选项中引用结构体变量成员的表达式错误的是______。
A) (p++)->num B) p->num C) (*p).num D) stu[3].age4、设有如下枚举类型定义enum language{Basic=3,Assembly=6,Ada=100,COBOL,Fortran};枚举量Fortran的值为______。
A) 4 B) 7 C) 102 D) 1035、以下叙述中错误的是_________。
A)可以通过typedef增加新的类型B)可以用typedef将已存在的类型用一个新的名字来代表C)用typedef定义新的类型名后，原有类型名仍有效D)用typedef可以为各种类型起别名，但不能为变量起别名6、有以下程序段typedef struct NODE{ int num; struct NODE *next;} OLD;以下叙述中正确的是A)以上的说明形式非法B) NODE是一个结构体类型C) OLD是一个结构体类型D) OLD是一个结构体变量7、以下选项中不能正确把cl定义成结构体变量的是______。
结构体练习题
结构体练习题：第1 题：计算日期的差值（1）编写一函数，计算两个日期之间的时间差，并将其值返回。
日期以年、月、日表示。
“时间差”以天数表示。
注意考虑日期之间的闰年。
函数的输入参数为日期1和日期2，函数的返回值为时间差，单位为天数。
（2）编写一程序，在主函数中输入两个日期,调用上述函数计算两个日期之间的时间差，并将结果输出。
为了计算简便，假设用户输入的日期1总是早于日期2。
参考代码：#include<stdio.h>struct date{int year;int month;int day;};int isLeap(int year);int dif(struct date a, struct date b);void main(){struct date a, b;printf("请输入日期1（空格分隔，年月日）:\n");scanf("%d%d%d", &a.year, &a.month, &a.day);printf("请输入日期2（空格分隔，年月日，晚于日期1）:\n");scanf("%d%d%d", &b.year, &b.month, &b.day);printf("相差天数为:");printf(" %d 天\n", dif(a, b));}int isLeap(int year) //判断一个年份是否是闰年的函数{if(year%400==0 || (year%4==0 && year%100!=0))return 1;elsereturn 0;}int dif(struct date a, struct date b){int i;long day=0, day1=0, day2=0;intd[2][13]={{0,31,28,31,30,31,30,31,31,30,31,30,31},{0,31,29,31,30,31,30,3 1,31,30,31,30,31}};// day变量为年份a到年份b前一年的年份总天数for(i=a.year; i<b.year; i++)if(isLeap(i))day += 366;elseday += 365;// day1变量为年份a年初到当天的年内总天数for(i=1; i<a.month; ++i)day1 += d[isLeap(a.year)][i];day1 += a.day;// day1变量为年份b年初到当天的年内总天数for(i=1; i<b.month; ++i)day2 += d[isLeap(b.year)][i];day2 += b.day;return day + day2 - day1;}参考截图：第2 题：结构体数组应用请定义一个描述学生基本信息的结构，包括姓名，学号，籍贯，身份证号，年龄，家庭住址，性别，联系方式等。
计算机二级 结构体
结构体类型数组
定义： 定义： struct student {
int no; char name[15]; char sex; float score[10]; float aver; } stu[20], stu1, stu2;
引用： 引用：stu[i].no stu[i].name stu[i].score[j] 具有20个元素的结构体 数组stu
初始化： 初始化： struct student {
int no; char name[15]; char sex; float aver; } stu[20]={{111, “Wan”, ‘m’, 89.5}, {222, “Liu”, ‘f’, 78.5}, ……};
结构体类型指针
1、定义方法 、 struct 结构体类型名 *结构体指针变量名
struct student { int no; char name[15]; int score[10]; float aver; } stu[20], stu1, *p1, *p2; 基类型为结构体类型的指针变量 p1=&stu1; // p1指向结构体变量stu1 p2=stu; // p2指向结构体数组stu的第0个元素，即stu[0] p2++; // p2指向结构体数组stu的第1个元素，即stu[1]
第14章 章
结构体、共用体和用户 结构体、 定义类型
用typedef说明一种新类型 说明一种新类型
typedef 类型名 标识符-----用标识符来表示已存在的类型名 例如：typedef int INTERGER INTERGER m，n； 等价于int m，n； typedef char *CHARP; CHARP p； 等价于char * p； 注意：一般习惯将新的类型名用大写字母表示。
实验结构体实验报告
}
cout<<"姓名"<<'\t'<<"生日"<<'\t'<<"电话"<<endl;
for(i=0;i<n;i++)
{
cout<<a[i].name<<'\t'
<<a[i].bir.year<<"/"<<a[i].bir.month<<"/"<<a[i].bir.day<<"/"<<'\t'
<<a[i].tel<<endl;
{
i=1;
}
else
i=0;
for(j=0;j<p->month;j++)
{
n=n+b[i][j];
}
n=n+p->day;
return n;
}
主要标识符说明：(源程序中主要标识符含义说明)
声明结构体类型nian，包括年（整型）、月份（整型）、天（整型）
struct nian
{
int year;
int month;
cin>>a.month ;
cout<<"请输入第几日"<<endl;
cin>>a.day;
n=find(p);
cout<<"你输入的日期为"<<a.year <<"/"<<a.month<<"/"<<a.day<<endl;
c++结构体题目
c++结构体题目
C++结构体题目是指涉及C++语言中结构体（struct）特性的题目，通常出现在编程练习、考试或竞赛中。
结构体是C++中的一种复合数据类型，它可以包含多个不同类型的数据成员，并且可以定义成员函数来操作这些数据。
以下是三道示例C++结构体题目：
1.定义一个结构体表示一个矩形，包含长（length）和宽（width）两个成员
变量，并实现一个函数计算矩形的面积。
2.定义一个结构体表示一个点，包含横坐标（x）和纵坐标（y）两个成员变
量，并实现一个函数计算两点之间的距离。
3.定义一个结构体表示一个学生，包含姓名（name）、年龄（age）和成绩
（score）三个成员变量，并实现一个函数按照成绩对学生进行排序。
总的来说，C++结构体题目是考察对C++语言中结构体特性的理解和应用能力的题目。
通过解决这类题目，可以提高对结构体的使用技巧和程序设计的思维能力。
C语言结构体习题及答案知识讲解
{
printf("%c,%d\n",kw[3].Key[0], kw[3].ID);
}
A) i,3B) n,3C)f,4D)l,4
7．定义以下结构体类型
structstudent
{
char name[10];
int score[50];
float average;
}stud1;
则stud1占用内存的字节数是【 】。
} x[4]={{2008,10,1, "guangzhou"}, {2009,12,25, "Tianjin"}};
语句
printf("%s,%d,%d,%d",x[0].name,x[1].birthday.year);的输出结果为【】。
A)guangzhou,2009B)guangzhou,2008
C)printf("%s\n",class[3].name);
D)printf("%s\n",class[0].name);
10.定义以下结构体数组
struct date
{ int year;
int month;
int day; };
struct s
{ struct date birthday;
char name[20];
struct c
{ int x;
int y;
}s[2]={1,3,2,7};
语句printf("%d",s[0].x*s[1].x)的输出结果为【】
A) 14B)6C)2D) 21
5．运行下列程序段，输出结果是【】
struct country
C语言结构体面试题
C语言结构体面试题及答案汇总以下是10道C语言结构体面试题和答案：1.什么是结构体？答案：结构体是一种用户自定义的数据类型，可以包含多个不同类型的数据成员。
2.结构体在C语言中有哪些作用？答案：结构体在C语言中主要用于将不同类型的数据组合成一个整体，以便更好地管理和使用。
3.结构体的定义方式是什么？答案：结构体的定义方式是使用“struct”关键字，后面跟着结构体的名称，然后是花括号中的数据成员列表。
4.如何定义一个结构体变量？答案：定义一个结构体变量需要使用“struct”关键字，后面跟着结构体的名称，然后是变量名。
5.如何访问结构体中的成员？答案：可以通过点运算符“.”来访问结构体中的成员。
例如，如果有一个名为“person”的结构体变量，其中有一个名为“name”的成员，则可以通过“”来访问该成员。
6.结构体中的成员可以是哪些类型？答案：结构体中的成员可以是任何基本数据类型，如int、char、float等，也可以是其他结构体类型。
7.结构体中的成员默认是什么类型的？答案：结构体中的成员默认是按顺序排列的，如果没有明确指定，则默认按照基本数据类型的顺序排列。
8.如何修改结构体的成员顺序？答案：可以使用“#pragma pack”指令来修改结构体的成员顺序。
例如，“#pragma pack(push, 1)”可以将结构体的成员顺序设置为按字节对齐。
9.结构体可以嵌套吗？答案：是的，结构体可以嵌套。
可以在一个结构体中定义另一个结构体类型的成员。
10.结构体和数组有什么区别？答案：结构体是一种用户自定义的数据类型，可以包含多个不同类型的数据成员；而数组是一种线性数据结构，用于存储相同类型的数据元素。
编程题5-(结构体)
结构体编程题类型：1、结构体：查找统计 (3/4)2、结构体：查找排序 (1/1)3、结构体：链表 (0/1)方法：1、结构体数组和链表试题的类型,常见的有查找指定条件的值、求最大〔小〕值、排序等。
方法与一般数组的相同。
注意事项：1、.结构体〔数组〕和链表变量不同于一般变量〔数组〕的地方就只在于“名字有点长”。
〔用成员运算符或->运算符〕。
一、结构体：查找统计．学生的记录由学号和成绩组成,N名学生的数据已在主函数中放入结构体数组s中,请编写函数fun,它的功能是:把指定分数范围内的学生数据放在b所指的数组中,分数范围内的学生人数由函数值返回.例如:输入的分数范围是60和69,则应当把分数在60到69的学生数据进行输出,包含60分和69分的学生数据.主函数中将把60放在low中把69放在high中.#include<stdio.h>#define N 16typedef struct{char num[10];int s;}STREC;int fun(STREC *a,STREC *b,int l,int h){int i,j,n;for(i=0,j=0,n=0;i<N;i++){if(a[i].s>=l && a[i].s<=h){b[j]=a[i];j++;n++;}}return n;}main(){STREC s[N]={{"GA005",85},{"GA003",76},{"GA002",69},{"GA004",85},{"GA001",96},{"GA007",72},{"GA008",64},{"GA006",87},{"GA015",85},{"GA013",94},{"GA012",64},{"GA014",91},{"GA011",90},{"GA017",64},{"GA018",64},{"GA016",72}};STREC h[N];int i,n,low,high,t;printf("Enter 2 integer number low & high : ");scanf("%d%d",&low,&high);if(high<low){t=high;high=low;low=t;}n=fun (s,h,low,high);printf ("The student's data between %d--%d:\n",low,high);for (i=0;i<n;i++)printf ("%s %4d\n",h[i].num,h[i].s);printf ("\n");}1.2.已知学生的记录由学号和学习的成绩构成，N名学生的数据已存人a结构体数组中。
结构体练习题
算并输出每个人的学号和平均成绩。
2.已知链表结点结构如下，假设动态链表已经建立,请编写删除给定学号的结点的函数。
(只编写删除子函数即可)3.编写函数实现动态链表的建立。
链表结点结构如下,要求在主函数中将你所建立的链表输出到屏幕上。
4.有10个学生,每个学生的信息包括学号、姓名、3门课的成绩，从键盘输入10个学生数据存入结构体数组中,要求输出个人总分最高的学生的信息(包括学号、姓名、3门课成绩、总分)。
5.链表的结点数据类型如下：struct node{int data;struct node *next;};链表的建立和输出函数如下，编写将第i个结点删除的函数，并完善主函数，调试运行整个程序。
struct node *creat(){ int x;struct node *h,*s,*r;h=(struct node *)malloc(sizeof(struct node));r=h;scanf("%d",&x);while(x!=-1){ s=(struct node*)malloc(sizeof(struct node));s->data=x;r->next=s;r=s;scanf("%d",&x);}r->next=NULL;return h;}void print(struct node *h) //打印函数{ struct node *p;p=h->next;if(p==NULL)printf("list is empty!");else{ while(p!=NULL){ printf("%4d",p->data);p=p->next;}}}并输出其平均成绩。
7.试利用指向结构体的指针编制一程序,实现输入三个学生的学号、数学期中和期末成绩,然后计算其平均成绩并输出成绩表。
c语言结构体试题及答案
c语言结构体试题及答案1. 定义一个结构体，包含学生的姓名、学号和成绩。
```cstruct Student {char name[50];int id;float score;};```2. 编写一个函数，计算结构体数组中所有学生的平均成绩。
```cfloat calculateAverageScore(struct Student students[], int size) {float sum = 0.0;for (int i = 0; i < size; i++) {sum += students[i].score;}return sum / size;}```3. 给定一个结构体数组，编写一个函数，返回成绩最高的学生。
```cstruct Student* findHighestScoreStudent(struct Student students[], int size) {struct Student* highest = students;for (int i = 1; i < size; i++) {if (students[i].score > highest->score) {highest = &students[i];}}return highest;}```4. 编写一个函数，将结构体数组中的学生信息打印出来。
```cvoid printStudents(struct Student students[], int size) { for (int i = 0; i < size; i++) {printf("Name: %s, ID: %d, Score: %.2f\n", students[i].name, students[i].id, students[i].score);}}```5. 如何定义一个结构体，其中包含另一个结构体类型的成员？```cstruct Inner {int a;float b;};struct Outer {struct Inner inner;char c[100];};```6. 编写一个函数，交换两个结构体变量的值。
c语言实践试题及答案
c语言实践试题及答案一、选择题1. C语言中，用于定义变量的关键字是：A. varB. letC. intD. define答案：C2. 下列哪个选项是合法的C语言常量？A. 0.1E2B. 1.2eC. 1.2ED. 1.2e-3.5答案：A3. 在C语言中，用于定义一个结构体的关键字是：A. structB. unionC. enumD. typedef答案：A4. 下列哪个选项不是C语言中的运算符？A. %B. &&C. ::D. =答案：C5. 在C语言中，哪个函数用于将字符串转换为浮点数？A. atoiB. atofC. itoaD. sprintf答案：B二、填空题1. 在C语言中，声明一个整型变量的语句是 ________。
答案：int variable_name;2. C语言中，用于定义一个数组的语句是 ________。
答案：type array_name[size];3. C语言中，用于定义一个指针的语句是 ________。
答案：type *pointer_name;4. C语言中，用于执行条件判断的语句是 ________。
答案：if (condition) { /* code */ }5. C语言中，用于执行循环的语句是 ________。
答案：for (initialization; condition; increment) { /* code */ }三、简答题1. 请简述C语言中函数的定义和调用过程。
答案：函数定义包括函数的返回类型、函数名、参数列表和函数体。
函数调用则是在程序中使用函数名和参数列表来执行函数。
2. 解释C语言中指针和引用的区别。
答案：指针是一个变量，存储另一个变量的内存地址。
引用是变量的别名，不能改变其指向，且必须在声明时初始化。
四、编程题1. 编写一个C语言程序，计算并输出1到100之间所有偶数的和。
答案：```c#include <stdio.h>int main() {int sum = 0;for (int i = 1; i <= 100; i++) {if (i % 2 == 0) {sum += i;}}printf("Sum of even numbers from 1 to 100 is: %d\n", sum);return 0;}```。
结构体和共用体 参考答案
实验八构造体及其应用班级：**：**：成绩：一．实验目的1、掌握构造体数据类型的定义和使用。
2、掌握构造体数组的定义和使用。
3、掌握链表的根本概念，熟练掌握单链表的创立、插入、删除和遍历操作。
二．使用的设备和仪器：计算机+Windows *P +Visual C++6.0三．实验内容及要求1、定义一个描述时间的构造体类型Time〔包括时、分、秒〕，然后定义一个该构造体类型的变量，按24小时制输入时间信息，然后按12小时制输出〔区分AM和PM〕。
例如，输入的时间是22:10:30；输出：PM 10:10:30。
2、定义描述学生信息〔**、**、成绩〕的构造体数组。
1〕定义输入学生信息的函数Input；2〕定义输出学生信息的函数Output；3〕定义按**进展查找的函数Search，假设找到，则输出该学生的信息；如果没找到，则输出"该学生不存在〞。
3、建立一个由3个学生〔包括**、**、成绩〕组成的静态链表，然后，输出该链表中各结点的数据。
4、动态建立一个学生信息〔包括**、**、成绩〕的链表，**输入-1时表示完毕，然后输出该链表中各结点的数据。
选作题：5、在第2题的根底上修改函数Search，假设找到，则返回该学生的信息；否则，返回一个内容为空的构造变量。
6、有N个候选人，每个选民只能投一票，要求编写一个模拟10个选民进展投票的程序，先后输入被选人的名字，最后按照选票由高到低输出投票结果。
7、在第3题的根底上，定义一个链表查找函数，对所输入的**进展查找，如果找到，则输出该学生的信息；如果没找到，则输出"该学生不存在〞。
四．实验步骤1、程序代码：*include<stdio.h>struct Time{int h,m,s;};void Input(Time *pt);void Output12(Time t);void main(){Time t;Input(&t);Output12(t);}void Input(Time *pt){printf("Input hour:minute:second:");scanf("%d:%d:%d",&pt->h,&pt->m,&pt->s);}void Output12(Time t){printf("The Time is:");if(t.h<12)printf("AM %d:%d:%d\n",t.h,t.m,t.s);elseprintf("PM %d:%d:%d\n",t.h-12,t.m,t.s);}运行结果：2、程序代码：*include<stdio.h>*include<string.h>*define N 3struct Student{char num[10];char name[10];double score;};void Input(Student *p){int i;for(i=0;i<N;i++)scanf("%s%s%lf",(p+i)->num,(p+i)->name,&(p+i)->score ); }void Output(Student *p){int i;for(i=0;i<N;i++)printf("num=%s name=%s score=%lf\n",(p+i)->num,(p+i)->name,(p+i)->score );}void Search(Student *p,char *nm){for(int i=0;i<N;i++){if(strcmp((p+i)->num,nm)==0){printf("num=%s name=%s score=%lf\n",(p+i)->num,(p+i)->name,(p+i)->score );break;}}if(i==N)printf("该学生不存在！\n");}void main(){Student stu[N];printf("请输入%d个学生的信息〔**、**、成绩〕:\n",N);Input(stu);printf("学生的信息为：\n");Output(stu);char nm[10];printf("请输入要查找的学生的**：");scanf("%s",nm);printf("查找结果：\n");Search(stu,nm);}运行结果：3、程序代码：*include<stdio.h>*define N 3struct student{char num[10];char name[10];double score;student *ne*t;};void main(){student stu1={"001","zhangsan",89},stu2={"002","lisi",99},stu3={"004","wangwu",70};student *head,*p;head=&stu1;stu1.ne*t=&stu2;stu2.ne*t=&stu3;stu3.ne*t=NULL;p=head;while(p!=NULL){printf("num:%s,name:%s,socre:%.2lf\n",p->num,p->name,p->score);p=p->ne*t;}}运行结果：4、程序代码：*include<stdio.h>*include<malloc.h>*include<string.h>*define N 3struct student{char num[10];char name[10];double score;student *ne*t;};void main(){student *head,*p,*s;head=NULL;printf("请输入学生信息，包括**和**〔**输入-1，表示完毕〕：\n");s=(student*)malloc(sizeof(student));scanf("%s%s%d",s->num,s->name,&s->score);s->ne*t=NULL;while(strcmp(s->num,"-1")!=0){if(head==NULL)head=s;elsep->ne*t=s;p=s;s=(student*)malloc(sizeof(student));scanf("%s%s%d",s->num,s->name,&s->score);s->ne*t=NULL;}p=head;while(p!=NULL){printf("%s,%s,%d\n",p->num,p->name,p->score);p=p->ne*t;}free(s);}运行结果：选做题：5、程序代码：*include<stdio.h>*include<string.h>*define N 3struct Student{char num[10];char name[10];double score;};void Input(Student *p){int i;for(i=0;i<N;i++)scanf("%s%s%lf",(p+i)->num,(p+i)->name,&(p+i)->score );}void Output(Student *p){int i;for(i=0;i<N;i++)printf("num=%s name=%s score=%lf\n",(p+i)->num,(p+i)->name,(p+i)->score ); }Student Search(Student *p,char *nm){Student ept_stu={",",0};for(int i=0;i<N;i++){if(strcmp((p+i)->num,nm)==0)return *(p+i);}return ept_stu;}void main(){Student stu[N];printf("请输入%d个学生的信息〔**、**、成绩〕:\n",N);Input(stu);printf("学生的信息为：\n");Output(stu);char nm[10];printf("请输入要查找的学生的**：");scanf("%s",nm);printf("查找结果：\n");Student t=Search(stu,nm);printf("num=%s name=%s score=%lf\n",t.num,,t.score); }运行结果：6、程序代码：*include<stdio.h>*include<string.h>*define N 3struct person{char name[20];int count;};void main(){person leader[N]={"HJT",0,"W",0,"*JP",0};char lname[20];person t;int i,j;printf("候选人为：\n");for(i=0;i<N;i++)printf("%s ",leader[i].name );printf("\n请开场投票：\n");for(i=1;i<=10;i++){scanf("%s",lname);for(j=0;j<N;j++){if(strcmp(lname,leader[j].name )==0)leader[j].count ++;}}for(i=0;i<N-1;i++)for(j=i+1;j<N;j++){if(leader[j].count>leader[j].count){t=leader[j]; leader[j]=leader[i]; leader[i]=t;}}printf("最后的投票结果为：\n");for(i=0;i<N;i++){printf("%s:%d\n",leader[i].name ,leader[i].count );}}运行结果：7、程序代码：*include<stdio.h>*include<string.h>struct Student{int num;char name[20];double score;Student *ne*t;};void PrintList(Student *head);void Search(Student *head);void main(){Student s1={1001,"Lily",100};Student s2={1002,"Lucy",90};Student s3={1003,"Ada",70};Student *head;head=&s1; s1.ne*t =&s2; s2.ne*t =&s3; s3.ne*t =NULL;PrintList(head);Search(head);}void PrintList(Student *head){printf("The List are:\n");Student *p=head;while(p!=NULL){printf("num=%d name=%s score=%lf\n",p->num ,p->name ,p->score );p=p->ne*t ;}}void Search(Student *head){char nm[20];printf("请输入要查找的**：");scanf("%s",nm);Student *p=head;while(p!=NULL){if(strcmp(p->name,nm)==0)break;p=p->ne*t ;}if(p!=NULL)printf("查找的结果为：num=%d name=%s score=%lf\n",p->num ,p->name ,p->score );elseprintf("该学生不存在！\n");}运行结果：五、实验总结。
(完整word版)数据结构单元2练习参考答案
单元练习2一．判断题（下列各题，正确的请在前面的括号内打√；错误的打╳）（×）（1）线性表的链式存储结构优于顺序存储。
（×）（2）链表的每个结点都恰好包含一个指针域。
（√）（3）在线性表的链式存储结构中，逻辑上相邻的两个元素在物理位置上并不一定紧邻。
（×）（4）顺序存储方式的优点是存储密度大，插入、删除效率高。
（×）（5）线性链表的删除算法简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。
（×）（6）顺序表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。
（√）（7）线性表链式存储的特点是可以用一组任意的存储单元存储表中的数据元素。
（√）（8）线性表采用顺序存储，必须占用一片连续的存储单元。
（×）（9）顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。
（ㄨ）（10）插入和删除操作是数据结构中最基本的两种操作，所以这两种操作在数组中也经常使用。
二．填空题（1）顺序表中逻辑上相邻的元素在物理位置上必须相连。
（2）线性表中结点的集合是有限的，结点间的关系是一对一关系。
（3）顺序表相对于链表的优点是：节省存储和随机存取。
（4）链表相对于顺序表的优点是：插入、删除方便。
（5）采用顺序存储结构的线性表叫顺序表。
（6）顺序表中访问任意一个结点的时间复杂度均为O(1)。
（7）链表相对于顺序表的优点是插入、删除方便；缺点是存储密度小。
（8）在双链表中要删除已知结点*P，其时间复杂度为O(1)。
（9）在单链表中要在已知结点*P之前插入一个新结点，需找到*P的直接前趋结点的地址，其查找的时间复杂度为 O(n) 。
（10）单链表中需知道头指针才能遍历整个链表。
（11）线性表中第一个结点没有直接前趋，称为开始结点。
（12）在一个长度为n的顺序表中删除第i个元素，要移动n-i 个元素。
（13）在一个长度为n的顺序表中，如果要在第i个元素前插入一个元素，要后移n- i +1 个元素。
c++入门题库 结构体
c++入门题库结构体C++中的结构体是一种用户自定义的数据类型，用于存储不同数据类型的元素。
结构体可以包含不同类型的数据，例如整数、浮点数、字符、数组、指针等，这使得结构体在C++中非常灵活和强大。
首先，让我们来看一下结构体的定义和声明。
在C++中，结构体通过关键字`struct`进行定义。
例如，我们可以定义一个表示学生信息的结构体如下：C++。
struct Student {。
int id;string name;int age;};在这个例子中，我们定义了一个名为`Student`的结构体，它包含了三个成员变量，`id`、`name`和`age`，分别表示学生的学号、姓名和年龄。
接下来，让我们来看一些关于结构体的常见操作。
我们可以使用结构体来创建具体的对象，然后访问和修改结构体的成员变量。
例如，我们可以这样创建一个`Student`对象并对其成员变量进行赋值：C++。
Student student1;student1.id = 1; = "Alice";student1.age = 20;除了简单地定义和使用结构体外，结构体还可以作为函数的参数和返回值。
这意味着我们可以将结构体作为一个整体传递给函数，或者从函数中返回一个结构体。
例如，我们可以定义一个函数来打印学生的信息：C++。
void printStudentInfo(Student student) {。
cout << "ID: " << student.id << ", Name: " << << ", Age: " << student.age << endl;}。
另外，结构体还可以嵌套在其他结构体中，从而构建更复杂的数据结构。
这种嵌套结构体的方式可以很好地组织和管理数据。
结构体格式问题回答
结构体格式
回答：
结构体是一种数据类型，是由不同类型的数据成员集合而成的数据结构。
结构体的数据成员可以是不同的数据类型，包括基本类型和自定义类型。
结构体通常用于组织和处理具有一定相关性的数据。
结构体的格式通常如下：
struct 结构体名
{
数据类型1 成员名1;
数据类型2 成员名2;
…
数据类型n 成员名n;
};
其中，结构体名为自定义的名称，可以根据实际需要进行命名；数据类型可以是任意类型，包括基本类型和自定义类型；成员名是结构体内部的变量名称，用于访问结构体成员数据。
在使用结构体时，可以通过以下方式进行定义和初始化：
1. 定义结构体变量：
struct 结构体名变量名;
2. 初始化结构体变量：
struct 结构体名变量名 = {成员1值, 成员2值, …, 成员n值};
或者
struct 结构体名变量名 = {.成员名1 = 成员1值, .成员名2 = 成员2值, …, .成员名n = 成员n值};
结构体变量的访问可以通过“.”操作符实现，例如：
变量名.成员名
可以使用结构体来管理复杂的信息，例如电脑系统中的进程信息就可以通过结构体来进行管理。
总之，结构体是一种非常常见的数据类型，特别是在大型程序开发中
尤为重要。
掌握结构体的使用方法，能够帮助我们更好地组织和处理数据。
数据结构实习题目
⏹n（n>20）的阶乘⏹【问题描述】⏹大数运算——计算n的阶乘（n>=20）。
⏹【基本要求】⏹（1）数据的表示和存储；⏹（1.1）累积运算的中间结果和最终的计算结果的数据类型要求是整型——这是问题本身的要求；⏹（1.2）试设计合适的存储结构，要求每个元素或结点最多存储数据的3位数值。
⏹（2）数据的操作及其实现：⏹基于设计的存储结构实现乘法操作，要求从键盘上输入n值，在屏幕上显示最终计算结果。
⏹【测试数据】⏹（1）n＝20，n！＝2432902008176640000⏹（2）n＝30，n！＝265252859812191058636308480000000⏹#include "stdafx.h"⏹#include <iostream>⏹#include<iomanip>⏹using namespace std;⏹template <class T>⏹class Chain;⏹template <class T>⏹class ChainNode⏹{⏹friend Chain<T>;⏹private:⏹T data;⏹ChainNode<T> *link;⏹};⏹template<class T>⏹class Chain⏹{⏹public:⏹Chain() {first = 0;} //构造函数⏹~Chain(); //析构函数⏹bool IsEmpty() const {return first == 0;} //判断链表是否为空⏹int Length() const; //求链表的长度⏹bool Find(int k, T& x) const; //查找第k个元素⏹int Search(const T& x) const; //查找元素x⏹Chain<T>& Delete(int k, T& x); //删除第k个元素⏹Chain<T>& Insert(int k, const T& x); //在第k个元素之后插入x⏹void Output(ostream& out) const; //单链表的输出⏹Chain<T>& Fac(long n);⏹//求大数阶乘⏹private:⏹ChainNode<T> *first; // 指向第一个节点⏹};⏹⏹template<class T>⏹Chain<T>::~Chain()⏹{//删除所有的节点⏹ChainNode<T> *next;⏹while (first)⏹{⏹next = first->link;⏹delete first;⏹first = next;⏹}⏹}⏹template<class T>⏹bool Chain<T>::Find(int k, T& x) const⏹{// 查找第k个元素，并赋值给x⏹if (k < 1) return false;⏹ChainNode<T> *current = first;⏹int index = 1;⏹while (index < k && current)⏹{⏹current = current->link;⏹index++;⏹}⏹if (current)⏹{⏹x = current->data;⏹return true;⏹}⏹return false;⏹}⏹⏹template<class T>⏹int Chain<T>::Search(const T& x) const⏹{//查找元素x，返回该元素的下标⏹ChainNode<T> *current = first;⏹int index = 1;⏹while (current && current->data != x)⏹{⏹current = current->link;⏹index++;⏹}⏹if (current) return index;⏹return 0;⏹}⏹⏹template<class T>⏹Chain<T>& Chain<T>::Delete(int k, T& x)⏹{// 删除第k个元素，并赋值给x，返回改变后的链表⏹ChainNode<T> *p = first;⏹if (k == 1)⏹first = first->link;⏹else⏹{⏹ChainNode<T> *q = first;⏹for (int index = 1; index < k - 1 && q;index++)⏹q = q->link;⏹p = q->link;⏹q->link = p->link;⏹}⏹x = p->data;⏹delete p;⏹return *this;⏹}⏹template<class T>⏹int Chain<T>::Length() const // 返回链表的长度⏹{⏹ChainNode<T> *current = first;⏹int len = 0;⏹while (current)⏹{⏹len++;⏹current = current->link;⏹}⏹return len;⏹}⏹template<class T>⏹Chain<T>& Chain<T>::Insert(int k, const T& x) //在第k个元素之后插入x，返回插入后的链表⏹{⏹ChainNode<T> *p = first;⏹for (int index = 1; index < k && p;index++)⏹p = p->link;⏹ChainNode<T> *y = new ChainNode<T>;⏹y->data = x;⏹if (k)⏹{⏹y->link = p->link;⏹p->link = y;⏹}⏹else⏹{⏹y->link = first;⏹first = y;⏹}⏹return *this;⏹}⏹template<class T>⏹void Chain<T>::Output(ostream& out) const // 输出链表元素⏹{⏹ChainNode<T> *current;⏹int i=0,j=Length();⏹for (current = first; current;current = current->link)⏹{⏹i++;⏹if(i==j&&j>=1)⏹{⏹if(current->link)⏹out <<setw(3)<<setfill('0')<< current->data << " ";⏹else⏹out<< current->data << " ";⏹i=1;⏹j--;⏹current=first;⏹}⏹}⏹out<<setw(3)<<setfill('0')<<first->data<<" ";⏹}⏹template <class T> //重载运算符<<⏹ostream& operator<<(ostream& out, const Chain<T>& x)⏹{x.Output(out); return out;}⏹⏹template <class T>⏹Chain<T>& Chain<T>::Fac(long n) //初始化⏹{⏹⏹int i=0;⏹long j=n;⏹while(j>999)⏹{⏹Insert(i,j%1000);⏹i++;⏹j=j/1000;⏹}⏹Insert(i,j); //通过插入来建立链表(0,20) ⏹//计算⏹long m=0, k=0;⏹ChainNode<T> *current;⏹for(;n>2;n--)⏹{⏹for (current = first;current;current = current->link)//?⏹{⏹m=k;⏹k=(current->data*(n-1)+k)/1000; //向前进位⏹current->data=(current->data*(n-1)+m)%1000;⏹if(!current->link&&k>0) //?⏹{⏹while(k>999)⏹{⏹Insert(Length(),k%1000);⏹k=k/1000;⏹}⏹Insert(Length(),k); //链表长度加一⏹k=0;⏹break;⏹}⏹}⏹}⏹return *this;⏹}⏹int main()⏹{⏹long n;⏹char ch;⏹do⏹{⏹cout<<"请输入需要阶乘的数字n: ";⏹cin>>n;⏹Chain<long> a;⏹ a.Fac(n);⏹cout<<n<<"的阶乘为:"<<endl;⏹cout<<a;⏹cout<<endl;⏹cout<<"是否进行计算:";⏹cout<<endl;⏹⏹cin>>ch;⏹}while(ch=='Y');⏹return 0;⏹}2:题目：表达式求值❖要求：实现关键▪栈的使用▪两位数以上、负数、小数点？❖实现方式▪控制台程序▪MFC对话框#include "stdafx.h"#include <iostream>using namespace std;#include<assert.h>#include <cstdlib>#include <math.h>template<class T>class Stack{public:Stack(int sz=50);~Stack(){delete[]elements;}void Push(const T &x); //压入栈bool Pop(T&x); //弹出栈T GetTop(void)const; //取栈顶元素bool IsEmpty()const{return(top==-1)?true:false;}bool IsFull()//判断栈是否满{return (top==MaxSize-1)?true:false;}int GetSize()const//?{return top+1;}void MakeEmpty(){top=-1;}private:T *elements;int top;int MaxSize;void overflowProcess();//栈溢出处理};template<class T>Stack<T>::Stack(int sz){top=-1;MaxSize=sz;elements=new T[MaxSize];//创建栈的数组空间assert(elements!=NULL);//判断动态内存是否分配成功是否}template<class T>void Stack<T>::Push(const T&x){if(IsFull()==true){overflowProcess();}top++;elements[top]=x;}template<class T>bool Stack<T>::Pop(T&x){if(IsEmpty()==true){return false;}x=elements[top--];return true;}template<class T>T Stack<T>::GetTop(void)const//返回栈顶元素{if(IsEmpty()==true){cerr<<"栈为空!"<<endl;exit(1);}return elements[top];}template<class T>void Stack<T>::overflowProcess() //溢出处理{T *newArray=new T[2*MaxSize]; //扩充栈的空间for(int i=0;i<=top;i++){MaxSize=2*MaxSize;newArray[i]=elements[i];}delete[]elements;//释放原来旧的空间}class Calculater//计算的声明{public:Calculater(){}void Run();//执行表达式计算void Clear();//清空处理private:Stack<double>s; //声明double型的栈对象void AddOperand(double value);//把数值压入栈中bool GetOperand(double &left,double& right);//判断取操作数操作是否成功void DoOperator(char ch);//进行操作};void Calculater::AddOperand(double value){s.Push(value);}bool Calculater::GetOperand(double&left,double&right){if(s.IsEmpty()==true){cerr<<"缺少右操作数"<<endl;return false;}s.Pop(right);if(s.IsEmpty()==true){cerr<<"缺少左操作数"<<endl;return false;}s.Pop(left);return true;}void Calculater::Clear(){s.MakeEmpty();}void Calculater::DoOperator(char ch){double left,right,value;bool result;result=GetOperand(left,right);if(result==true){switch(ch){case'+':value=left+right;s.Push(value);break;case'-':value=left-right;s.Push(value);break;case'*':value=left*right;s.Push(value);break;case'/':if(right==0.0){cerr<<"Divide by 0!"<<endl;Clear();}else{value=left/right;s.Push(value);}break;}cout<<"="<<s.GetTop()<<" ";}elseClear();}void Calculater::Run(){char ch;double newOperand;while(cin>>ch,ch!='#'){switch(ch){case '+':case'-':case'*':case'/'://是操作数，执行计算DoOperator(ch);break;default: //其实也是一种case，只不过就是指“除了指定的几个case以外的其他情况”，不是操作符cin.putback(ch);//字符放回输入流cin>>newOperand;//重新读取操作数，一个操作数的第一个字符AddOperand(newOperand);//将操作数放入栈中}}}int main(){Calculater call;cout<<"输入计算表达式:";call.Run();return 0;}3.题目:❖题目：二叉树基本算法的实现❖功能要求：❖键盘输入二叉树结点序列，创建一棵二叉树❖实现SwapTree方法，以根结点为参数，交换每个结点的左子树和右子树（提示：前序递归）❖实现Find方法，查找值为key的结点，并输出该结点的所有祖先结点❖你可以选择：❖对BinaryTree模板进行功能扩充；❖自己定义并实现二叉树类❖要求键盘输入二叉树结点序列❖结点序列可以是前序，也可以是层次❖空结点以#表示//binarytree.h#ifndef BINARYTREE_H#define BINARYTREE_H#include<iostream.h>template<class T>class BinaryTreeNode//二叉树结点{//friend BinaryTree<T>;public:BinaryTreeNode(){LeftChild=RightChild=0;}BinaryTreeNode(const T&e){data=e;LeftChild=RightChild=0;}BinaryTreeNode(const T&e,BinaryTreeNode *l,BinaryTreeNode *r) {data=e;LeftChild=l;RightChild=r;}public:T data;BinaryTreeNode<T>*LeftChild,*RightChild;};template<class T>class BinaryTree{friend BinaryTreeNode<T>;public:BinaryTree(){root=0;}~BinaryTree(){}bool IsEmpty()const{return ((root)?false:true);}void Creat();void PreOrder(void (*Visit)(BinaryTreeNode<T>*u))//前序遍历{PreOrder(Visit,root);}void InOrder(void (*Visit)(BinaryTreeNode<T>*u))//中序遍历 {InOrder(Visit,root);}void PostOrder(void (*Visit)(BinaryTreeNode<T>*u))//后序遍历 {PostOrder(Visit,root);}void LevelOrder(void(*Visit)(BinaryTreeNode<T>*u))//层次遍历 {PreOrder(Output,root);cout<<endl;}void InOutput()//中序输出{InOrder(Output,root);cout<<endl;}void Postput()//后序输出{PostOrder(Output,root);cout<<endl;}void LevelOutPut()//层次输出{LevelOrder(Output);cout<<endl;}int Height()const//计算树的高度{return Height(root);}int Size()const//计算树的大小{return Size(root);}BinaryTreeNode<T>*iCreat();void swap()//交换左右节点{swap(root);}int leave()//计算叶子节点个数{return leave(root);}int noleave()////计算非叶子节点个数{return noleave(root);}private:BinaryTreeNode<T>*root;void PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t);void InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t);void PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t); //void LevelOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t); static void Output(BinaryTreeNode<T>* t)//输出树的所有节点{cout<<t->data <<" ";}int Height(BinaryTreeNode<T>*t)const;int Size(BinaryTreeNode<T>*t)const;void swap(BinaryTreeNode<T>*t);int leave(BinaryTreeNode<T>*t);int noleave(BinaryTreeNode<T>*t);};template<class T>int BinaryTree<T>::Height(BinaryTreeNode<T>*t)const{if(!t) return 0;int hl=Height(t->LeftChild);int hr=Height(t->RightChild);if(hl>hr) return ++hl;else return ++hr;}template<class T>int BinaryTree<T>::Size(BinaryTreeNode<T>*t)const{if(!t) return 0;int sl=Size(t->LeftChild);int sr=Size(t->RightChild);return (1+sl+sr);}template<class T>BinaryTreeNode<T>*BinaryTree<T>::iCreat( ){T ch;cin>>ch;BinaryTreeNode<T> * root;if(ch=='#'){root=NULL;}else{root=new BinaryTreeNode<T>;root->data=ch;root->LeftChild=this->iCreat();root->RightChild=this->iCreat();}return root;}template<class T>void BinaryTree<T>::Creat(){this->root = iCreat();}template<class T>voidBinaryTree<T>::PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>* t){if(t){Visit(t);PreOrder(Visit,t->LeftChild);PreOrder(Visit,t->RightChild);}}template<class T>voidBinaryTree<T>::InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t) {if(t){InOrder(Visit,t->LeftChild);Visit(t);InOrder(Visit,t->RightChild);}}template<class T>voidBinaryTree<T>::PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T> *t){if(t){PostOrder(Visit,t->LeftChild);PostOrder(Visit,t->RightChild);Visit(t);}}template<class T>void BinaryTree<T>::swap(BinaryTreeNode<T> *t){BinaryTreeNode<T> *temp;if(!t) return;else{temp=t->LeftChild;t->LeftChild=t->RightChild;t->RightChild=temp;swap(t->LeftChild);swap(t->RightChild);}}template<class T>int BinaryTree<T>::leave(BinaryTreeNode<T>*t){if(!t) return 0;if(t->LeftChild==0&&t->RightChild==0)return 1;int leafl=leave(t->LeftChild);int leafr=leave(t->RightChild);return leafl+leafr;}template<class T>int BinaryTree<T>::noleave(BinaryTreeNode<T> *t){if(!t) return 0;if(!t->LeftChild&&!t->RightChild)return 1;int leafl=noleave(t->LeftChild);int leafr=noleave(t->RightChild);return leafl+leafr+1;}#endif#include "stdafx.h"#include"binarytree.h"#include <iostream.h>void main(){cout<<"输入二叉树:"<<endl;BinaryTree<char> Tree;Tree.Creat();//cout<<"前序遍历:";//Tree.PreOutput();cout<<"中序遍历:";Tree.InOutput();cout<<"后序遍历:";Tree.Postput();cout<<"二叉树的叶节点数目为:";cout<<Tree.leave()<<endl;Tree.swap();cout<<"交换前序遍历:";//Tree.PreOutput();}实习题目4.❖任务：输入一棵二叉树的前序遍历序列和中序遍历序列，重构这棵二叉树❖功能要求：➢在题目三的基础之上，增加一个方法，重构这棵二叉树➢要求以图示效果，层次输出这棵二叉树//bintree.h#ifndef BINTREE_H#define BINTREE_H#include<iostream.h>#include"queue.h"template<class T>class BinaryTree;template<class T>//二叉树的二叉链表class BinaryTreeNode{friend BinaryTree<T>;public:BinaryTreeNode(){LeftChild=RightChild=0;}//构造函数BinaryTreeNode(const T&e){data=e;LeftChild=RightChild=0;}BinaryTreeNode(const T&e,BinaryTreeNode *l,BinaryTreeNode *r){data=e;LeftChild=l;RightChild=r;}private:T data;BinaryTreeNode<T>*LeftChild,*RightChild;};template<class T>class BinaryTree{public:BinaryTree()//构造函数空树{root=0;}~BinaryTree(){}bool IsEmpty()const{return ((root)?false:true);}//void BinaryTree<T>::LevelOrder(void(* Visit)(BinaryTreeNode<T>*u));void LevelOrder(void(BinaryTree<T>::* Visit)(BinaryTreeNode<T>*u));//层次访问,在访问某一层结点时把下一层结点记忆在队列（尾）中，然后在访问在队头的结点void LevelOutPut(){if(!root)//空树{return;}cout<<root->data;LevelOrder(Output);cout<<endl;}BinaryTreeNode<T>*createBinaryTree(T *VLR,T*LVR,int n)//构造二叉树前中n为元素个数{if(n==0)return NULL;int k=0;while(VLR[0]!=LVR[k])//在中序前序结合找根{k++;}BinaryTreeNode<T>*t=new BinaryTreeNode<T>(VLR[0]);//根结点为tt->LeftChild=createBinaryTree(VLR+1,LVR,k);//从前序VLR+1开始对中序0~k-1左子序列的k个元素递归建立左子树t->RightChild=createBinaryTree(VLR+k+1,LVR+k+1,n-k-1);//从前序VLR+k+1开始对中序k+1~n-1左子序列的n-k-1个元素递归建立右子树return t;}BinaryTreeNode<T>*root;void Output(BinaryTreeNode<T>* t){if(t->LeftChild||t->RightChild)//左或又子树不为空{if(t->LeftChild)cout<<t->LeftChild->data;elsecout<<"#";if(t->RightChild)cout<<t->RightChild->data;elsecout<<"#";}}};template<class T>void BinaryTree<T>::LevelOrder(void (BinaryTree<T>::*Visit)(BinaryTreeNode<T> *u))//void BinaryTree<T>::LevelOrder(void(* Visit)(BinaryTreeNode<T>*u)){LinkedQueue<BinaryTreeNode<T>*>Q;BinaryTreeNode<T> *p=root;Q.EnQueue(p);//根节点进队while(!Q.IsEmpty ()){Q.DeQueue(p);//根节点出队(this->*Visit)(p);//访问根结点if(p->LeftChild!=NULL)Q.EnQueue(p->LeftChild);//左子女进队if(p->RightChild!=NULL)Q.EnQueue(p->RightChild); //右子女进队}}#endif//queqe.h#ifndef QUEQE_H#define QUEQE_H//单链表的链式队列template<class T>class LinkedQueue;template<class T>class Node{friend LinkedQueue<T>;private:T data;Node<T>*link;};template<class T>class LinkedQueue{public:LinkedQueue() //构造函数{front=rear=0;//建立空队列}~LinkedQueue(); //析构函数bool IsEmpty()const{return ((front)?false:true);}LinkedQueue<T>&EnQueue(const T &x);//往队尾队列中插入元素LinkedQueue<T>&DeQueue(T&x);//从队头删除元素private:Node<T>*front;Node<T>*rear;};template<class T>LinkedQueue<T>::~LinkedQueue()//析构函数的实现{Node<T>*next;while(front){next=front->link;delete front;front=next;}}template<class T>LinkedQueue<T>&LinkedQueue<T>::EnQueue(const T &x){Node<T>*p=new Node<T>;p->data=x;p->link=0;if (front){rear->link=p;//在列尾添加新的结点}else//队列为空，新结点成为第一个结点{front=p;}rear=p;return *this;}template<class T>LinkedQueue<T>&LinkedQueue<T>::DeQueue( T&x)//队头结点删去{Node<T>*p=front;//暂存队头结点x=front->data;front=front->link;//队头修改delete p;return*this;}#endif#include "stdafx.h"#include"binarytree.h"#include <iostream.h>void main(){BinaryTree<char> Tree;//char 类型的int n;cout<<"二叉树中元素个数:";cin>>n;char *L=new char[n];char *R=new char[n];cout<<"前序序列为:";int i=0,j=0;while(i<n){cin>>L[i];i++;}cout<<"中序序列为:";while(j<n){cin>>R[j];j++;}Tree.root=Tree.createBinaryTree(L,R,n);cout<<"层次遍历:";Tree.LevelOutPut();delete[]L;delete[]R;}实习题目5.最优二叉树❖基本要求：对Huffman树的方法进行扩充，实现如下功能：❖1）键盘输入一个字符串，统计每个字符出现的频率；❖2）输出每个字符的Huffman编码❖3）计算并输出WPL❖提高要求：改键盘输入为读文件（任何类型）//huffmantree.h#ifndef HUFFMANTREE_H#define HUFFMANTREE_H#include <iostream.h>#include "minheap.h"#include <stdlib.h>//const int MaxN = 100;template <class Type>class HuffmanTree;template <class Type>class HuffmanTreeNode//树结点的类定义{//friend class HuffmanTree;public:int arrkey;Type data;//结点数据HuffmanTreeNode <Type> *leftChild, *rightChild, *parent;};template <class Type>class HuffmanCodeNode{//friend class HuffmanTree;public:HuffmanTreeNode <Type> *dataptr;int bit[MaxN];int start;};template <class Type>class HuffmanTree{//friend class HuffmanTreeNode;//friend class HuffmanCodeNode;public:HuffmanTree(){};HuffmanTree(Type weight[], int n);HuffmanCode();//求huffman编码protected:HuffmanTreeNode <Type> *hfTree;HuffmanCodeNode <Type> *hfCode;int currentSize;void MergeTree(HuffmanTreeNode <Type> &bt1, HuffmanTreeNode <Type>&bt2, HuffmanTreeNode <Type> *pt)//合并二叉树{pt->leftChild = &bt1;pt->rightChild = &bt2;pt->data = bt1.data + bt2.data;pt->parent = NULL;bt1.parent = pt; bt2.parent = pt;}};template <class Type>HuffmanTree <Type> :: HuffmanTree(Type weight[], int n)//n个权值为W[1]....{HuffmanTreeNode <Type> *firstchild, *secondchild, *parent;HuffmanTreeNode <Type> *TNode;if(n > MaxN){cout<<"Error!"<<endl;exit(-1);}currentSize = n;hfCode = new HuffmanCodeNode <Type> [n];TNode = new HuffmanTreeNode <Type> [n];for(int i = 0;i < n;i++)//森林各颗树初始化{hfCode[i].dataptr = &TNode[i];TNode[i].data = weight[i];TNode[i].arrkey = i;TNode[i].parent = TNode[i].leftChild = TNode[i].rightChild = NULL;}MinHeap <HuffmanTreeNode <Type> > hp(TNode,n);for(i = 0;i < n-1;i++){parent = new HuffmanTreeNode <Type>;firstchild = hp.RemoveMin();secondchild = hp.RemoveMin();MergeTree(*firstchild, *secondchild, parent);hp.Insert(*parent);}hfTree = parent;}template <class Type>HuffmanTree <Type> :: HuffmanCode(){HuffmanCodeNode <Type> *cd = new HuffmanCodeNode<Type>;HuffmanTreeNode <Type> *child, *parent;for(int i=0;i < currentSize;i++){cd->start = currentSize -1;child = hfCode[i].dataptr;parent = child->parent;while(parent != NULL){if(parent->leftChild == child)//向左标记为0cd->bit[cd->start] = 0;elsecd->bit[cd->start] = 1; //向右标记为0child = parent;parent = parent->parent;cd->start--;}for(int k=0;k < currentSize;k++){hfCode[i].bit[k] = cd->bit[k];hfCode[i].start = cd->start+1;}}cout<<endl<<"输出："<<endl;for(i=0;i<currentSize;i++){ cout<<hfCode[i].dataptr->data<<": ";for(int j=hfCode[i].start;j<currentSize;j++)cout<<hfCode[i].bit[j];cout<<endl;}}#endif//minheap.h#ifndef MINHEAP_H#define MINHEAP_Htemplate <class Type>class MinHeap{//friend class Type;public:MinHeap(int maxSize);MinHeap(Type a[], int n);//构造函数~MinHeap(){delete []heapArr;}//析构函数int Insert(Type &d);//把数据元素插入最小堆中Type * RemoveMin();//删除堆顶上最小元素private:Type * heapArr;//存放堆中元素的数组Type * Arr;Type * saveNode[100];int saveNodeCount;int heapCurrentSize;//堆中当前元素个数int heapMaxSize;//最多元素个数void siftDown(int p);//从p下滑调整为最小堆void siftUp(int p);//从p上滑调整为最小堆};template <class Type>MinHeap <Type> :: MinHeap(int maxSize){heapMaxSize = maxSize;heapArr = new Type [heapMaxSize];//创建堆存储空间heapCurrentSize = 0;//当前元素个数为0}template<class Type>MinHeap<Type>::MinHeap(Type a[],int n){heapMaxSize = n;heapArr = new Type[heapMaxSize];saveNodeCount=n;for(int j=0;j<n;j++){heapArr[j]=a[j];}Arr=a;heapCurrentSize=n;//复制堆数组，建立当前大小int i=(heapCurrentSize-2)/2;//找最初调整位置，即最后分支节点while(i>=0){siftDown(i);//再向前换一个分支结点i--;}/*if (heapMaxSize%2==0){for(int k=0;k<n;k++){heapArr[k]=heapArr[k+1];}}*/}//?template <class Type>void MinHeap<Type>::siftDown(const int start)//堆下滑，从开始结点开始{int i=start,j;Type temp=heapArr[i];j=2*i+1;//左子女位置while(j<=heapCurrentSize-1){if(j<=heapCurrentSize-1 && heapArr[j].data > heapArr[j+1].data) j++;if(temp.data <=heapArr[j].data) break;//小不作调整else {heapArr[i]=heapArr[j];i=j;j=2*j+1;}//小上移}heapArr[i]=temp;}template<class Type>int MinHeap<Type>::Insert(Type&d){heapArr[heapCurrentSize]=d;heapArr[heapCurrentSize].arrkey=saveNodeCount;siftUp(heapCurrentSize);heapCurrentSize++;saveNode[saveNodeCount++]=&d;return 1;}template <class Type>void MinHeap<Type>::siftUp(int p){int j=p,i;Type temp = heapArr[j];i=(j-1)/2;while(j>0){if(heapArr[i].data<=temp.data)break;else{heapArr[j]=heapArr[i];j=i;i=(j-1)/2;}}heapArr[j]=temp;}template<class Type>Type * MinHeap<Type>::RemoveMin(){Type * temp=new HuffmanTreeNode<char>;(*temp)=heapArr[0];heapArr[0]= heapArr[heapCurrentSize-1];heapCurrentSize--;siftDown(0);if(temp->arrkey>-1 && temp->arrkey<heapMaxSize)return &Arr[temp->arrkey];else if(temp->arrkey>=heapMaxSize && temp->arrkey<100)return saveNode[temp->arrkey];}#endif#include "stdafx.h"#include "huffmantree.h"#include <iostream.h>int main(int argc, char* argv[]){char weight[MaxN];int n;cout<<"字符个数:";cin >> n;cout<<"输入一串字符:";for(int i=0;i<n;i++)cin>>weight[i];HuffmanTree <char> a (weight,n);a.HuffmanCode();return 0;}实习题目6.⏹要求：自己设计图并编码进行存储，同时输出图的两种遍历方式的结果。
结构体2(习题与参考答案)
第八章结构体与联合体
填空题
2、有以下说明定义和语句，可用a.day引用结构体成员day, 请写出引用结构体成员a.day的其
它两种形式、。
struct{int day;char mouth;int year;}a,*b; b=&a;
5、设有以下结构类型说明和变量定义，则变量a在内存所占字节数是__ 。
Struct stud
{ char num[6];
int s[4];
double ave;
} a,*p;
6、以下程序用来输出结构体变量ex所占存储单元的字节数，请填空。
struct st
{ char name[20]; double score; };
main()
{ struct st ex;
printf(“ex size: %d\n”,sizeof( ______ ));
}
8、若有如下结构体说明：
struct STRU
{ int a, b ; char c; double d:
struct STRU p1,p2;
};
请填空，以完成对t数组的定义，t数组的每个元素为该结构体类型
______ t[20];
9、若以下定义和语句,则sizeof(a)的值是________ ,而sizeof(b)的值是_______
struct { int day; char mouth; int year;} a, *b;
b=&a;
填空题
2、(*b).day b->day 5、32 6、ex 8、struct STRU 9、12_4_ ；12、2002Shangxian
1。
数据结构实验实习题答案
数据结构实验实习题答案实验一线性表1. 设顺序表A中的数据元素递增有序，试写一程序，将x插入到顺序表的适当位置上，使该表仍然有序。
分析：其实这个题在学C语言时就已经写过了，这里采用顺序表来存储数据。
主要就是考虑插入的位置是不是在最后一个，如果不在最后一个，那么就要移动数据了，算法很简单就不再说了，这里的数据都看成是整型的。
源程序：//1.1.c#include#includevoid Insert(int* p,int length,int n){//插入函数int i,j;int flag=0;if(n>=p[length-1]){//n比最大数还要大时p[length]=n;flag=1;}else{for(i=length-2;i>=0;i--){if(n>=p[i]){//插入nfor(j=length;j>=i+2;j--){p[j]=p[j-1];}p[i+1]=n;flag=1;break;}}}if(flag==0){//n为最小数时for(j=length;j>=1;j--){p[j]=p[j-1];}p[0]=n;}}int main(){int L[10]={1,3,6,8,9,10,15};//初始化一个非递减速有顺表int length=7;//初始化表长int i,x;printf("插入前的顺序表为：\n");for(i=0;i<length;i++){< p="">printf("%4d",L[i]);}printf("\n请输入要插入的整数：\n");scanf("%d",&x);Insert(L,length,x);//插入xprintf("插入%d后的顺序表为：\n",x);for(i=0;i<=length;i++){printf("%4d",L[i]);}printf("\n");system("pause");return 0;}2. 用单链表ha 存储多项式A（x ）=a0+a1x1+a2x2+…+anxn(其中aI为非零系数)，用单链表hb 存储多项式B（x ）=b0+b1x1+b2x2+…+bmxm(其中bj为非零系数)，要求计算C（x ）= A（x ）+B（x ），结果存到单链表hc中。
数据结构实习报告题目
一、实习背景与目的随着信息技术的飞速发展，数据结构作为计算机科学的核心基础之一，在软件开发和数据处理中扮演着至关重要的角色。
为了提高自身对数据结构应用的理解和掌握，本次实习旨在通过设计和实现一个基于链表与树结构的多功能数据管理系统，提升对数据结构理论知识的实践运用能力，并增强系统分析与设计的能力。
二、需求分析1. 程序所实现的功能：（1）实现链表的基本操作，如插入、删除、查找等；（2）实现二叉树的基本操作，如插入、删除、查找等；（3）实现数据管理系统，包括数据的存储、查询、修改、删除等；（4）实现用户界面，方便用户进行操作。
2. 程序的输入：（1）输入数据格式：链表数据以空格分隔，二叉树数据以括号表示，节点间用逗号分隔；（2）输入说明：用户需按照要求输入数据，系统将自动处理。
3. 程序的输出：（1）输出格式：链表、二叉树以文本形式输出；（2）输出说明：系统将按照用户操作要求，实时显示操作结果。
4. 测试数据：（1）链表测试数据：1 2 3 4 5；（2）二叉树测试数据：(1,2,(3,4,5),6)。
5. 合作人及其分工：（1）负责人：负责整体设计和开发；（2）成员1：负责链表和二叉树的基本操作实现；（3）成员2：负责数据管理系统的设计和实现；（4）成员3：负责用户界面设计和实现。
三、设计说明1. 主要的数据结构设计说明：（1）链表：采用单向链表实现，节点包含数据域和指针域；（2）二叉树：采用二叉搜索树实现，节点包含数据域和左右指针域。
2. 程序的主要流程图：（1）用户输入数据；（2）系统解析数据并创建链表和二叉树；（3）用户选择操作，系统根据操作进行相应处理；（4）系统输出操作结果。
3. 程序的主要模块：（1）链表模块：负责链表的基本操作；（2）二叉树模块：负责二叉树的基本操作；（3）数据管理系统模块：负责数据的存储、查询、修改、删除等；（4）用户界面模块：负责用户与系统的交互。
4. 程序的主要函数及其伪代码说明：（1）链表插入：function insertNode(head, data)（2）链表删除：function deleteNode(head, data)（3）二叉树插入：function insertNode(root, data)（4）二叉树删除：function deleteNode(root, data)5. 合作人设计分工：（1）负责人：负责整体设计和开发；（2）成员1：负责链表和二叉树的基本操作实现；（3）成员2：负责数据管理系统的设计和实现；（4）成员3：负责用户界面设计和实现。
C语言博客作业--结构体
C语⾔博客作业--结构体⼀、PTA实验作业题⽬⼀.结构体数组按总分排序1.本题PTA提交列表2. 设计思路第⼀个函数的编写⾸先要遍历结构体数组使sum得初始值为0，遍历数组中的score与sum相加。
第⼆个函数编写先定义⼀个结构体中间量temp⽤选择排序法进⾏排序，进⾏第⼆个函数的操作。
3.代码截图4.本题调试过程碰到问题及PTA提交列表情况说明。
本题没有问题认为可以将第⼀个函数中的*s⽤p去操作可以节约空间,还有就是可以⽤typedef对结构体取别名这样会直观简单⼀点。
题⽬⼆.时间换算1.本题PTA提交列表2.设计思路定义结构体包括起始时间的⼩时，分钟，秒钟还有过了多少秒。
输⼊这些数据定义函数实现时间改变如果秒钟加上过去的秒钟分钟加1，当分钟超过60⼩时加1，当⼩时超过24则减去24否则则直接返回秒钟加过去的秒钟3.代码截图4.本题调试过程碰到问题及PTA提交列表情况说明。
本题⽐较容易没问题，就是补0这个操作会⽐较灵活。
题⽬三. 有理数⽐较1.本题PTA提交列表2.设计思路3.代码截图4.本题调试过程碰到问题及PTA提交列表情况说明。
本题⽐较容易，就是整数类型转⼩数⼀开始没注意。
⼆、截图本周题⽬集的PTA最后排名。
PTA排名三、阅读代码1atoi函数源代码#include<stdio.h>#include<assert.h>#include<stdlib.h>#include<ctype.h>#include<limits.h>enum Ret //状态，⽤来输⼊是否合理，分装成函数增加可读性，枚举法增加可读性{VALID,INVALID,};enum Ret state = INVALID;int My_atoi(const char *str) //指针类型传参，操作性强加上const完美严谨。
{int flag = 1; //⽤来记录是正数还是负数long long ret = 0;assert(str);if (str == NULL){return 0;}if (*str == '\0'){return (int)ret; //强制转换类型。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《C语言程序设计》实习题目6
图1 存放初始密码的文件
图2 存放学生记录个数的文件图3 存放学生记录的文件
增加的选项：
图4 执行选项2“从文件读取学生记录并输出的效果图”
图5 执行选项8“修改学生记录”，再执行选项3“列出当前所有学生记录”的效果图
图6 执行选项9“删除学生记录”，再执行选项3“列出当前所有学生记录”的效果图
执行选项10“添加学生记录”，再执行选项3“列出当前所有学生记录”的效果图：退出学生成绩管理系统
图9 再次打开student.txt文件，新图8 先添加一个学生记录，再退出系统
for(i=0; i<stu_num; i++)
{
fprintf(fp, “%s %s %c %lf %lf %lf”, stu); }。