《数据结构》实验题目
《数据结构》实验指导第一章实验0 C/C++程序设计一、实验基础知识二、实验案例1 学生成绩统计系统[问题描述]一个班同学的学号为1-n，输入n位同学的学号、姓名、语文、数学、英语等3门课程成绩，统计每位同学的总分后按成绩从高到低的次序输出。
[基本要求]实现成绩表的录入、总分统计、总分排序和输出。
[测试数据]对于10个同学的学号、姓名、语文、数学、英语等3门课程成绩设计实例数据[实现提示]1）用结构体设计同学记录，学号、各课程成绩和总分数据域用整型，姓名域采用字符数组；学生成绩表用数组模拟，数组大小根据实际学生数动态申请；学生成绩统计系统通过主菜单形式提供成绩表初始化、学生成绩录入、学生总分统计和排名、成绩表输出等功能。
[提高部分]1）实现成绩表的文件录入和文件保存2）实现成绩键盘录入的有效数据限制2复数计算器[问题描述]设计一个能进行复数运算的演示程序。
[基本要求]实现复数的基本运算：1）由输入的实部和虚部生成一个复数；2）求两个复数的和；3）求两个复数的差；4）求两个复数的乘积；5）求复数的实部；6）求复数的虚部[测试数据]0+0=03.1,0;4.22,8.9;输出7.32+i8.99,8;-9,8;输出i169,-8;-9,-8;输出-i16-9,8;-9,-8;输出-189,-7;-9,8;输出i9,-9;-9,8;输出-i[实现提示]将复数的实部和虚部组成结构体数据类型，利用实数的操作实现复数的操作。
[提高部分]1）实现复数的除法运算；2）求共轭复数3有理数计算器[问题描述]设计一个能进行有理数运算的演示程序。
[基本要求]实现有理数的基本运算：1）由输入的分子和分母生成一个有理数；2）求两个有理数的和；3）求两个有理数的差；4）求两个有理数的乘积；5）求有理数的分子；6）求有理数的分母[实现提示]将有理数的分子和分母组成结构体数据类型，利用整数的操作实现有理数的操作。
[提高部分]1）实现有理数的除法运算；第二章线性表一、实验基础知识二、实验案例4顺序表基本操作演示系统[问题描述]设计一个能进行顺序表基本运算的演示程序。
[基本要求]实现顺序表的基本运算：1）顺序表的初始化；2）置空顺序表；3）求表长；4）在指定位置插入新元素；5）查找指定位置元素；6）查找给定值元素；7）删除指定位置元素；8）删除指定值元素[测试数据][实现提示][提高部分]1）实现顺序表中重复元素的删除；2）实现有序顺序表的指定元素的保序插入；3）实现有序顺序表中重复元素的删除；5单链表基本操作演示系统[问题描述]设计一个能进行单链表基本运算的演示程序。
[基本要求]实现带头结点单链表的基本运算：1）单链表的初始化；2）置空单链表；3）求表长；4）在指定位置插入新元素；5）查找指定位置元素；6）查找给定值元素；7）删除指定位置元素；8）删除指定值元素[测试数据][实现提示][提高部分]1）实现无序单链表中重复元素的删除；2）有序单链表的指定元素的保序插入；2）实现有序顺序表中重复元素的删除；6集合运算演示系统[问题描述]设计一个能进行集合基本运算的演示程序。
[基本要求]1）限制集合基本元素为小写字母a-z；2）实现集合建立：a）集合的并；b）集合的交；c）集合的差；1)Set1=”magzine”,set2=”paper”set1∪set2=”aeimnprz”,set1∩set2=”ae”,set1-set2=”gimnz”2)set1=”012per4a6tion89”,set2=”error data”set1∪set2=”adeinoprt”,set1∩set2=”aeort”,set1-set2=”inp”[实现提示]以有序单链表表示集合[提高部分]1）集合元素判定和子集判定；2）求集合的补集；7约瑟夫环问题[问题描述]编号为1~n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
一开始任选一个正整数作为报数的上限值m，从第一个人开始按顺时针方向从1开始顺序报数，报到m时停止报数。
报m的人出列，将他的密码作为新的m值，从他的顺时针方向上的下一个人开始重新从1报数，如此下去，直到所有人全部出列为止。
试设计一个程序求出列顺序。
[基本要求]利用无头结点循环链表存储模拟此过程；每个结点中包含序号、密码和指针域。
[测试数据]当m初始值为20；n=7,7个人的密码依次为：3，1，7，2，4，8，4；正确的输出序列为6，1，4，7，2，3，5；当m初始值为2；n=1;密码为3；正确的输出序列为1。
[实现提示]1）扫描指针应指向报数结点的前驱结点以方便出列；2）当表中只有一个结点时，无须报数了，直接出列即行。
[提高部分]1）采用带头结点单链表实现；2）采用顺序表实现；8一元稀疏多项式计算器[问题描述]设计一个一元稀疏多项式计算器。
[基本要求]实现一元稀疏多项式的基本运算：1）输入并建立一元稀疏多项式；2）输出多项式（以指数降序方式输出非零系数项的系数和指数）；3）实现一元稀疏多项式的相加；[测试数据][实现提示]用带头结点的单链表存储多项式，每个结点中包含指数、系数和指针；单链表中结点按指数降序排列。
[提高部分]1）实现一元稀疏多项式的相减；2）实现一元稀疏多项式求导；9仓储管理系统[问题描述]设计一个能对商厦商品进行管理的系统。
实现：1）商品的入库；2）商品的出库；3）商品查询；4）营业前的商品数据恢复；5）营业结束的商品数据保存[测试数据][实现提示]用有序单链表模拟商品数据表。
[提高部分]第三章栈和队列一、实验基础知识二、实验案例10顺序栈模拟器[问题描述]设计一个实现顺序栈的基本运算的演示程序。
[基本要求]实现顺序栈的基本运算：1）顺序栈的初始化；2）置空栈；3）元素入栈；4）元素出栈；5）打印栈中元素[测试数据][实现提示]注意栈的溢出。
[提高部分]1）实现两栈共享一连续存储空间的基本运算；2）使用链栈实现栈的基本运算11队列模拟器[问题描述]设计一个实现循环队列的基本运算的演示程序。
[基本要求]实现循环队列的基本运算：1）循环队列的初始化；2）置空队列；3）元素入队；4）元素出队；5）打印队列中元素[测试数据][实现提示]1）通过设置队尾指针指向队尾元素，队首指针指向队首前一位置以及模运算方法实现循环队列；2）注意循环队列的溢出。
[提高部分]1）用队尾指针指向真正队尾、队首指针指向真正队首和附加队列曼/空标记实现循环队列和循环队列的基本操作；2）用队尾指针加表长方式实现循环队列和循环队列的基本操作；3）用循环链表实现队列和队列的基本操作12表达式括号匹配判断器[问题描述]设计一个判断一个表达式中的括号匹配是否配对的演示程序。
实现判断一个表达式中圆括号是否配对[测试数据]1）（A+B）+（B-D）2）（（A+B）*（C-D）））3）（（A+B））*（（C-D）[实现提示]将算术表达式输入并保存在数组中，通过顺序栈实现括号配对。
当读入的字符为左括号时入栈，为右括号时出栈。
出栈时，若栈顶元素为对应左括号，则出栈；若栈空则说明括不匹配，算法结束；若表达式结束时，栈为空，则说明表示式括号配对，否则说明表示式括号不配对。
[提高部分]1）实现含3种括号配对13舞伴问题[问题描述]在周末舞会上，男士们和女士们进入舞厅时，各排成一队。
跳舞开始时，依次从男队和女队的对头上各出一人配成舞伴。
若两队初始人数不同，则较长的那队中未配对者等待下一轮舞曲。
写一程序模拟舞伴配对问题。
[基本要求]输入跳舞者人数、姓名、性别后，建立男士和女士队列；输出配对成功的男士和女士姓名，以及未配对队伍中剩余元素的个数和队头元素的姓名。
[测试数据]（A，M），（B，F），（C，F），（D，M），（E，M），（F，M），（G，F）[实现提示]使用两个循环队列分别模拟男士队列和女士队列（队列的大小根据人数确定）。
根据输入的姓名和性别分别入到男队或女队；舞曲开始后，将男士和女士从队列出队，直到一队为空。
[提高部分]1）实现多轮舞曲的配对14数制转换[问题描述]实现一个将十进制整数转化为n（n<10）进制的数的程序。
[基本要求]将输入的十进制整数用“除n取余法”求出其n进制表示。
[测试数据][实现提示]将非零正整数除n后的余数保存在栈中，当商为0时，才将栈中数出栈，出栈序列即为转换成功的序列。
[提高部分]1）实现将十进制整数转化为n（n>10）进制的数的程序15八皇后问题[问题描述]在一个8*8的棋盘里放置8个皇后，要求每个皇后两两之间互不相冲（每一行、列和斜线上都只能有一个皇后）。
[基本要求]求出无冲突八皇后问题的一组解。
[测试数据][实现提示]利用递归和回溯的方法，在8*8的棋盘从一行一列开始逐行尝试放置皇后，若冲突，则回到上一行下一列尝试，若无冲突，则继续下一行放置，直到放上所有8个皇后。
[提高部分]1）求出所有可行的八皇后方案。
16背包问题[问题描述]设一个背包能放入的物品的重量为s，现有n件物品，重量分别是w[1],w[2]，…，w[n]。
判断能否从着n件物品中选择若干件放入此背包中，使得放入的重量之和正好为s；若可以，求出其具体方案。
[基本要求]求出满足背包问题的一组解。
[测试数据]s=10,w={1,8,4,3,5,2}结果：（1，4，3，2）、（1，4，5）、（8，2）、（3，5，2）[实现提示]利用递归回溯的方法，设置栈模拟背包，将物品放入背包模拟为入栈，若能放入且剩余空间为0，则栈中序列即为一组合法解；若物品放入背包后，剩余空间为>0，则继续选择物品放入；若剩余空间为<0,则取出栈部分物品，继续其他物品的尝试。
[提高部分]1）设置用户栈求解背包问题；2）求出背包问题的所有解。
17迷宫问题[问题描述]迷宫是一个矩形区域，它有一个入口和一个出口。
在迷宫内包含不能穿越的墙或障碍。
障碍沿着行和列放置，它们与迷宫的矩形边界平行。
[基本要求]用二维数组模拟迷宫，其中为0处表示通路，为1处表示墙或障碍。
求出从入口（0，0）到出口（m,n）的一条通路（通路路径由一组位置构成）。
[测试数据][实现提示]1）把一个m*n的迷宫设置为一个（m+2）*(n+2)的二维数组表示；2）。
[提高部分]1）求出从入口（0，0）到出口（m,n）的所有通路。
18马踏棋盘演示[问题描述]设计一个国际象棋的马踏棋盘的演示程序。
[基本要求]将马放在国际象棋的8*8棋盘board[8][8]的某个方格中，马按走棋规则进行移动。
要求每个方格只进入一次，走遍棋盘上的全部64个方格。
编制非递归程序，求出马的行走路线，并按求出的行走路线，将数字1，2，…，64依次填入一个8*8的方阵并输出方阵。
[测试数据][实现提示]1）下图显示了马位于方格（2，3）时的8个可移动位置。
数据结构实验题目数据结构实验题目09级
实验一线性表的顺序存储实验一、实验目的1、掌握用Visual C++6.0上机调试顺序表的基本方法2、掌握顺序表的基本操作，插入、删除、查找等算法的实现二、实验内容1、顺序表基本操作的实现[问题描述] 当我们要在顺序表的第i个位置上插入一个元素时，必须先将顺序表中第i个元素之后的所有元素依次后移一个位置，以便腾空一个位置，再把新元素插入到该位置。
若是欲删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置。
[基本要求] 要求生成顺序表时，可以键盘上读取元素，用顺序存储结构实现存储。
实验二单链表实验一、实验目的1、掌握用Visual C++6.0上机调试单链表的基本方法2、掌握单链表的插入、删除、查找、求表长以及有序单链表的合并算法的实现二、实现内容1、单链表基本操作的实现[问题描述]要在带头结点的单链表h中第i个数据元素之前插入一个数据元素x ，首先需要在单链表中寻找到第i-1个结点并用指针p指示，然后申请一个由指针s 指示的结点空间，并置x为其数据域值，最后修改第i-1个结点，并使x结点的指针指向第i个结点，要在带头结点的单链表h中删除第i个结点，首先要计数寻找到第i个结点并使指针p指向其前驱第i-1个结点，然后删除第i个结点并释放被删除结点空间。
[基本要求]用链式存储结构实现存储[实现提示]链式存储结构不是随机存储结构，即不能直接取到单链表中某个结点，而要从单链表的头结点开始一个一个地计数寻找。
2、求表长以及有序单链表的合并算法的实现[问题描述] 假设有两个按元素值递增次序排列的线性表，均以单链表形式存储。
请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并计算表长。
要求利用原来两个单链表的结点存放归并后的单链表。
[基本要求]用链式存储结构实现存储实验三栈的实现及应用一、实验目的1、掌握顺序栈的类型定义方法。
2、掌握在顺序栈上实现的六种基本算法。
2、掌握顺序栈的简单应用。
《数据结构》实验题目
通过上机实验加深对课程内容的理解，增加感性认识，提高算法设计、程序编写及调试的能力。
要求所编的程序能正确运行（最好用C++调试），并提交实验报告。
实验题目先由理论课程的教师给学生，实验前学生必须做好准备，实验报告理论教师可以相当于作业登记。
上实验课程的教师督促、监控学生是否自己调试程序，相关情况作为成绩评定的依据。
实习报告规范：实习报告开头有题目，班级，姓名，学号和完成日期，并包括以下七个内容：1. 需求分析以无歧义的陈述说明程序设计的任务，强调的是程序要做什么？明确规定：输入的形式和输入值的范围；输出的形式；程序所能达到的功能；测试数据；2. 概要设计：说明本程序中用到的所有抽象数据类型的定义，主程序的流程以及各程序模块之间的层次关系。
3. 详细设计：对每个操作写出伪码算法；对主程序和其他模块也需要写出伪码算法；画出函数的调用关系图。
提交带注释的源程序或者用伪代码写出每个操作所涉及的算法。
4. 调试分析：调试过程中遇到的问题；算法的时空分析和改进思想；经验和体会。
5. 用户使用说明：说明如何使用你编写的程序，详细列出每一步的操作步骤。
6. 测试结果：列出你的测试的结果，包括输入和输出。
7. 附录：带注释的源程序。
《数据结构》实验题目实验一栈的实现及应用一、实验目的及要求：1、熟悉栈的定义和栈的基本操作。
2、掌握顺序存储栈和链式存储栈的基本操作的具体实现。
3、加深对栈结构的理解，并逐步培养解决实际问题的编程能力二、实验内容说明：以下题目选择其一编程实现，在报告中说明栈实现的方式1．数制转换将一个非负的十进制整数N转换为另一个等价的基为B的B进制数的问题，用"除B取余法"来解决。
【例】将十进制数13转化为二进制数。
解答：按除2取余法，得到的余数依次是1、0、1、1，则十进制数转化为二进制数为1101。
2．表达式求值（后缀表达式）当用户输入一个合法的后缀表达式后，能够返回正确的结果。
《数据结构》程序设计实习题目
《数据结构》程序设计实习题目1.分别以顺序表和单链表作为存储结构，实现将线性表就地逆置的操作。
（所谓“就地逆置”是指辅助空间为O（1），即利用原表中的结点空间）。
2.写一程序将单链表中值重复的结点删除，使得表中各结点值均不相同。
3.已知一单链表中含有两类字符的数据元素（如：字母、数字），试编写程序将该单链表分成两个单链表，使得每个链表中只含有同一类的字符。
4.假设有两个按元素值递增有序的单链表A和B，试编写程序将A和B归并成一个按元素值递减有序的单链表。
5.利用线性结构（顺序表或链表）实现两个20位大整数的加法运算。
6.已知两个以顺序结构存储的线性表A和B，试编写程序实现从A表中删除包含在B表中的元素。
7.已知两个单链表A和B，试编写程序实现从A表中删除包含在B表中的元素。
8.已知两个以顺序结构存储的线性表A和B，试编写程序实现：将在B表中但不在A表中的元素插入到A表。
9.已知两个单链表A和B，试编写程序实现：将在B表中但不在A表中的元素插入到A表。
10.试编写程序，对任意输入的一个算术表达式，将式中的数字和运算符分成两类（一类是数字，一类是运算符），并按逆序输出。
（提示：利用栈来实现）11.利用栈结构，编写一个程序，对以逆波兰式表示的表达式求值。
12.编写程序，求得所有包含在串S中而不包含在串T中的字符（S中重复的字符只选一个）构成的新串R。
13.编写程序，求任意输入的串S中所含不同字符的总数和每种字符的个数。
14.一个文本串可用事先给定的字母映射表进行加密。
例如：设字母映射表为：a b c d e f g h i j k l m n o p q r s t u v w x y zn g z q t c o b m u h e l k p d a w x f y i v r s j则字符串“encrypt”被加密为“tkzwsdf”。
试写一程序将输入的文本串进行加密后输出。
15.假设两个10×10的稀疏矩阵A和B以三元组表的方式存储，试编写程序实现矩阵的相加运算，其结果存放在三元组表C中。
数据结构上机实验
目录第1章绪论——上机实验题1解析实验题1.1求素数实验题1.2求一个正整数的各位数字之和实验题1.3求一个字符串是否为回文第2章线性表——上机实验题2解析实验题2.1实现顺序表各种基本运算的算法/*文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType elem[MaxSize];int length;} SqList;void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->elem[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e){if (i<1 || i>L->length)return 0;e=L->elem[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->elem[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; /*将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/L->elem[j]=L->elem[j-1];L->elem[i]=e;L->length++; /*顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; /*将顺序表位序转化为elem下标*/e=L->elem[i];for (j=i;j<L->length-1;j++)L->elem[j]=L->elem[j+1];L->length--;return 1;}实验题2.2实现单链表各种基本运算的算法*文件名:algo2-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/L->next=NULL;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==NULL);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=NULL){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p=L;while (j<i && p!=NULL){j++;p=p->next;}if (p==NULL)return 0;else{e=p->data;return 1;}}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=NULL && p->data!=e){p=p->next;n++;}if (p==NULL)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e)int j=0;LinkList *p=L,*s;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插p->next=s;return 1;}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;while (j<i-1 && p!=NULL){j++;p=p->next;}if (p==NULL) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}第3章栈和队列——上机实验题3解析实验题3.1实现顺序栈各种基本运算的算法*文件名:algo3-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 100typedef char ElemType;typedef struct{ElemType elem[MaxSize];int top; /*栈指针*/} SqStack;void InitStack(SqStack *&s){s=(SqStack *)malloc(sizeof(SqStack));s->top=-1;}void ClearStack(SqStack *&s){free(s);}int StackLength(SqStack *s){return(s->top+1);}int StackEmpty(SqStack *s){return(s->top==-1);}int Push(SqStack *&s,ElemType e){if (s->top==MaxSize-1)return 0;s->top++;s->elem[s->top]=e;return 1;}int Pop(SqStack *&s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];s->top--;return 1;int GetTop(SqStack *s,ElemType &e){if (s->top==-1)return 0;e=s->elem[s->top];return 1;}void DispStack(SqStack *s){int i;for (i=s->top;i>=0;i--)printf("%c ",s->elem[i]);printf("\n");}实验题3.2实现链栈各种基本运算的算法/*文件名:algo3-2.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct linknode{ElemType data; /*数据域*/struct linknode *next; /*指针域*/} LiStack;void InitStack(LiStack *&s){s=(LiStack *)malloc(sizeof(LiStack));s->next=NULL;}void ClearStack(LiStack *&s){LiStack *p=s->next;while (p!=NULL){free(s);s=p;p=p->next;}}int StackLength(LiStack *s){int i=0;LiStack *p;p=s->next;while (p!=NULL){i++;p=p->next;}return(i);}int StackEmpty(LiStack *s){return(s->next==NULL);}void Push(LiStack *&s,ElemType e){LiStack *p;p=(LiStack *)malloc(sizeof(LiStack));p->data=e;p->next=s->next; /*插入*p结点作为第一个数据结点*/s->next=p;}int Pop(LiStack *&s,ElemType &e){LiStack *p;if (s->next==NULL) /*栈空的情况*/return 0;p=s->next; /*p指向第一个数据结点*/e=p->data;s->next=p->next;free(p);return 1;}int GetTop(LiStack *s,ElemType &e){if (s->next==NULL) /*栈空的情况*/return 0;e=s->next->data;return 1;}void DispStack(LiStack *s){LiStack *p=s->next;while (p!=NULL){printf("%c ",p->data);p=p->next;}printf("\n");}实验题3.3实现顺序队列各种基本运算的算法/*文件名:algo3-3.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 5typedef char ElemType;typedef struct{ElemType elem[MaxSize];int front,rear; /*队首和队尾指针*/} SqQueue;void InitQueue(SqQueue *&q){q=(SqQueue *)malloc (sizeof(SqQueue));q->front=q->rear=0;}void ClearQueue(SqQueue *&q){free(q);}int QueueEmpty(SqQueue *q){return(q->front==q->rear);}int QueueLength(SqQueue *q){return (q->rear-q->front+MaxSize)%MaxSize; }int enQueue(SqQueue *&q,ElemType e){if ((q->rear+1)%MaxSize==q->front) /*队满*/return 0;q->rear=(q->rear+1)%MaxSize;q->elem[q->rear]=e;return 1;}int deQueue(SqQueue *&q,ElemType &e){if (q->front==q->rear) /*队空*/return 0;q->front=(q->front+1)%MaxSize;e=q->elem[q->front];return 1;}实验题3.4实现链队各种基本运算的算法/*文件名:algo3-4.cpp*/#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct qnode{ElemType data;struct qnode *next;} QNode;typedef struct{QNode *front;QNode *rear;} LiQueue;void InitQueue(LiQueue *&q){q=(LiQueue *)malloc(sizeof(LiQueue));q->front=q->rear=NULL;}void ClearQueue(LiQueue *&q){QNode *p=q->front,*r;if (p!=NULL) /*释放数据结点占用空间*/{r=p->next;while (r!=NULL){free(p);p=r;r=p->next;}}free(q); /*释放头结点占用空间*/ }int QueueLength(LiQueue *q){int n=0;QNode *p=q->front;while (p!=NULL){n++;p=p->next;}return(n);}int QueueEmpty(LiQueue *q){if (q->rear==NULL)return 1;elsereturn 0;}void enQueue(LiQueue *&q,ElemType e){QNode *s;s=(QNode *)malloc(sizeof(QNode));s->data=e;s->next=NULL;if (q->rear==NULL) /*若链队为空,则新结点是队首结点又是队尾结点*/q->front=q->rear=s;else{q->rear->next=s; /*将*s结点链到队尾,rear指向它*/q->rear=s;}}int deQueue(LiQueue *&q,ElemType &e){QNode *t;if (q->rear==NULL) /*队列为空*/return 0;if (q->front==q->rear) /*队列中只有一个结点时*/{t=q->front;q->front=q->rear=NULL;}else /*队列中有多个结点时*/{t=q->front;q->front=q->front->next;}e=t->data;free(t);return 1;}第4章串——上机实验题4解析实验题4.1实现顺序串各种基本运算的算法/*文件名:algo4-1.cpp*/#include <stdio.h>#define MaxSize 100 /*最多的字符个数*/typedef struct{ char ch[MaxSize]; /*定义可容纳MaxSize个字符的空间*/ int len; /*标记当前实际串长*/} SqString;void StrAssign(SqString &str,char cstr[]) /*str为引用型参数*/ {int i;for (i=0;cstr[i]!='\0';i++)str.ch[i]=cstr[i];str.len=i;}void StrCopy(SqString &s,SqString t) /*s为引用型参数*/ {int i;for (i=0;i<t.len;i++)s.ch[i]=t.ch[i];s.len=t.len;}int StrEqual(SqString s,SqString t){int same=1,i;if (s.len!=t.len) /*长度不相等时返回0*/same=0;else{for (i=0;i<s.len;i++)if (s.ch[i]!=t.ch[i]) /*有一个对应字符不相同时返回0*/same=0;}return same;}int StrLength(SqString s){return s.len;}SqString Concat(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++) /*将s.ch[0]～s.ch[s.len-1]复制到str*/ str.ch[i]=s.ch[i];for (i=0;i<t.len;i++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/ str.ch[s.len+i]=t.ch[i];return str;}SqString SubStr(SqString s,int i,int j){SqString str;int k;str.len=0;if (i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str; /*参数不正确时返回空串*/}for (k=i-1;k<i+j-1;k++) /*将s.ch[i]～s.ch[i+j]复制到str*/str.ch[k-i+1]=s.ch[k];str.len=j;return str;}SqString InsStr(SqString s1,int i,SqString s2){int j;SqString str;str.len=0;if (i<=0 || i>s1.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return s1;}for (j=0;j<i-1;j++) /*将s1.ch[0]～s1.ch[i-2]复制到str*/str.ch[j]=s1.ch[j];for (j=0;j<s2.len;j++) /*将s2.ch[0]～s2.ch[s2.len-1]复制到str*/str.ch[i+j-1]=s2.ch[j];for (j=i-1;j<s1.len;j++) /*将s1.ch[i-1]～s.ch[s1.len-1]复制到str*/str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;return str;}SqString DelStr(SqString s,int i,int j){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j>s.len+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=i+j-1;k<s.len;k++)/*将s.ch[i+j-1]～ch[s.len-1]复制到str*/ str.ch[k-j]=s.ch[k];str.len=s.len-j;return str;}SqString RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len) /*参数不正确时返回空串*/ {printf("参数不正确\n");return str;}for (k=0;k<i-1;k++) /*将s.ch[0]～s.ch[i-2]复制到str*/str.ch[k]=s.ch[k];for (k=0;k<t.len;k++) /*将t.ch[0]～t.ch[t.len-1]复制到str*/str.ch[i+k-1]=t.ch[k];for (k=i+j-1;k<s.len;k++) /*将s.ch[i+j-1]～ch[s.len-1]复制到str*/str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;return str;}void DispStr(SqString str){int i;if (str.len>0){for (i=0;i<str.len;i++)printf("%c",str.ch[i]);printf("\n");}}实验题4.2实现链串各种基本运算的算法*文件名:algo4-2.cpp*/#include <stdio.h>#include <malloc.h>typedef struct snode{char data;struct snode *next;} LiString;void StrAssign(LiString *&s,char t[]){int i;LiString *r,*p;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;r=s;for (i=0;t[i]!='\0';i++){p=(LiString *)malloc(sizeof(LiString));p->data=t[i];p->next=NULL;r->next=p;r=p;}}void StrCopy(LiString *&s,LiString *t){LiString *p=t->next,*q,*r;s=(LiString *)malloc(sizeof(LiString));s->next=NULL;s->next=NULL;r=s;while (p!=NULL) /*将t的所有结点复制到s*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}}int StrEqual(LiString *s,LiString *t){LiString *p=s->next,*q=t->next;while (p!=NULL && q!=NULL && p->data==q->data){p=p->next;q=q->next;}if (p==NULL && q==NULL)return 1;elsereturn 0;}int StrLength(LiString *s){int i=0;LiString *p=s->next;while (p!=NULL){i++;p=p->next;}return i;}LiString *Concat(LiString *s,LiString *t){LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;while (p!=NULL) /*将s的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}p=t->next;while (p!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *SubStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++)p=p->next;for (k=1;k<=j;k++) /*将s的第i个结点开始的j个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *InsStr(LiString *s,int i,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s)+1) /*参数不正确时返回空串*/{printf("参数不正确\n");return str;}for (k=1;k<i;k++) /*将s的前i个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}while (p1!=NULL) /*将t的所有结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/ {q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *DelStr(LiString *s,int i,int j){int k;LiString *str,*p=s->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}LiString *RepStr(LiString *s,int i,int j,LiString *t){int k;LiString *str,*p=s->next,*p1=t->next,*q,*r;str=(LiString *)malloc(sizeof(LiString));str->next=NULL;r=str;if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s)) {printf("参数不正确\n");return str; /*参数不正确时返回空串*/ }for (k=0;k<i-1;k++) /*将s的前i-1个结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}for (k=0;k<j;k++) /*让p沿next跳j个结点*/p=p->next;while (p1!=NULL) /*将t的所有结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p1->data;q->next=NULL;r->next=q;r=q;p1=p1->next;}while (p!=NULL) /*将*p及其后的结点复制到str*/{q=(LiString *)malloc(sizeof(LiString));q->data=p->data;q->next=NULL;r->next=q;r=q;p=p->next;}return str;}void DispStr(LiString *s){LiString *p=s->next;while (p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}第5章数组和稀疏矩阵——上机实验题5解析实验题5.1求5×5阶螺旋方阵/*文件名:exp5-1.cpp*/#include <stdio.h>#define MaxLen 10void fun(int a[MaxLen][MaxLen],int n){int i,j,k=0,m;if (n%2==0) //m=én/2ùm=n/2;elsem=n/2+1;for (i=0;i<m;i++){for (j=i;j<n-i;j++){k++;a[i][j]=k;}for (j=i+1;j<n-i;j++){k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;a[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("\n");printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}printf("\n");}实验题5.2求一个矩阵的马鞍点/*文件名:exp5-2.cpp*/#include <stdio.h>#define M 4#define N 4void MinMax(int A[M][N]){int i,j,have=0;int min[M],max[N];for (i=0;i<M;i++) /*计算出每行的最小值元素,放入min[0..M-1]之中*/{min[i]=A[i][0];for (j=1;j<N;j++)if (A[i][j]<min[i])min[i]=A[i][j];}for (j=0;j<N;j++) /*计算出每列的最大值元素,放入max[0..N-1]之中*/{max[j]=A[0][j];for (i=1;i<M;i++)if (A[i][j]>max[j])max[j]=A[i][j];}for (i=0;i<M;i++)for (j=0;j<N;j++)if (min[i]==max[j]){printf(" A[%d,%d]=%d\n",i,j,A[i][j]); /*显示马鞍点*/have=1;}if (!have)printf("没有鞍点\n");}void main(){int i,j;int A[M][N]={{9, 7, 6, 8},{20,26,22,25},{28,36,25,30},{12,4, 2, 6}};printf("A矩阵:\n");for (i=0;i<M;i++){for (j=0;j<N;j++)printf("%4d",A[i][j]);printf("\n");}printf("A矩阵中的马鞍点:\n");MinMax(A); /*调用MinMax()找马鞍点*/}实验题5.3求两个对称矩阵之和与乘积/*文件名:exp5-3.cpp*/#include <stdio.h>#define n 4#define m 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[n][n]){int i,j;for (i=0;i<n;i++)for (j=0;j<n;j++)c[i][j]=value(a,i,j)+value(b,i,j);}void mult(int a[],int b[],int c[n][n]){int i,j,k,s;for (i=0;i<n;i++)for (j=0;j<n;j++){s=0;for (k=0;k<n;k++)s=s+value(a,i,k)*value(b,k,j); c[i][j]=s;}}void disp1(int a[]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",value(a,i,j));printf("\n");}}void disp2(int c[n][n]){int i,j;for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",c[i][j]);printf("\n");}}void main(){int a[m]={1,2,3,4,5,6,7,8,9,10};int b[m]={1,1,1,1,1,1,1,1,1,1};int c1[n][n],c2[n][n];madd(a,b,c1);mult(a,b,c2);printf("\n");printf("a矩阵:\n");disp1(a);printf("b矩阵:\n");disp1(b);printf("a+b:\n");disp2(c1);printf("a*b:\n");disp2(c2);printf("\n");}实验题5.4实现稀疏矩阵（采用三元组表示）的基本运算/*文件名:exp5-4.cpp*/#include <stdio.h>#define N 4typedef int ElemType;#define MaxSize 100 /*矩阵中非零元素最多个数*/ typedef struct{ int r; /*行号*/int c; /*列号*/ElemType d; /*元素值*/} TupNode; /*三元组定义*/typedef struct{ int rows; /*行数值*/int cols; /*列数值*/int nums; /*非零元素个数*/TupNode data[MaxSize];} TSMatrix; /*三元组顺序表定义*/void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nums].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);printf("\t------------------\n");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); }void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v; /*q为tb.data的下标*/tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++) /*tb.data[q]中的记录以c 域的次序排列*/for (p=0;p<t.nums;p++) /*p为t.data的下标*/if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}int MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c){int i=0,j=0,k=0;ElemType v;if (a.rows!=b.rows || a.cols!=b.cols)return 0; /*行数或列数不等时不能进行相加运算*/c.rows=a.rows;c.cols=a.cols; /*c的行列数与a的相同*/while (i<a.nums && j<b.nums) /*处理a和b中的每个元素*/{if (a.data[i].r==b.data[j].r) /*行号相等时*/{if(a.data[i].c<b.data[j].c) /*a元素的列号小于b 元素的列号*/{c.data[k].r=a.data[i].r;/*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if (a.data[i].c>b.data[j].c)/*a元素的列号大于b元素的列号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else /*a元素的列号等于b元素的列号*/{v=a.data[i].d+b.data[j].d;if (v!=0) /*只将不为0的结果添加到c中*/{c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if (a.data[i].r<b.data[j].r) /*a元素的行号小于b元素的行号*/{c.data[k].r=a.data[i].r; /*将a元素添加到c中*/c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else /*a元素的行号大于b元素的行号*/{c.data[k].r=b.data[j].r; /*将b元素添加到c中*/c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return 1;}int value(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j))k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}int MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows) /*a的列数不等于b的行数时不能进行相乘运算*/return 0;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+value(a,i,k)*value(b,k,j);if (s!=0) /*产生一个三元组元素*/{c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=p;return 1;}void main(){ElemType a1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};ElemType b1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};TSMatrix a,b,c;CreatMat(a,a1);CreatMat(b,b1);printf("a的三元组:\n");DispMat(a);printf("b的三元组:\n");DispMat(b);printf("a转置为c\n");TranMat(a,c);printf("c的三元组:\n");DispMat(c);printf("c=a+b\n");MatAdd(a,b,c);printf("c的三元组:\n");DispMat(c);printf("c=a*b\n");MatMul(a,b,c);printf("c的三元组:\n");DispMat(c);}实验题5.5实现广义表的基本运算#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct lnode{ int tag; /*结点类型标识*/ union{ElemType data;struct lnode *sublist;}val;struct lnode *link; /*指向下一个元素*/} GLNode;extern GLNode *CreatGL(char *&s);extern void DispGL(GLNode *g);void Change(GLNode *&g,ElemType s,ElemType t) /*将广义表g中所有原子s 替换成t*/{if (g!=NULL){if (g->tag==1) /*子表的情况*/Change(g->val.sublist,s,t);else if (g->val.data==s) /*原子且data域值为s的情况*/g->val.data=t;Change(g->link,s,t);}}void Reverse(GLNode *&g) /*将广义表g所有元素逆置*/{GLNode *p,*q,*t;t=NULL;if (g!=NULL){p=g;while (p!=NULL) /*将同级的兄弟逆置*/{q=p->link;if (t==NULL){t=p;p->link=NULL;}else{p->link=t;t=p;}p=q;}g=t;p=g;while (p!=NULL){if (p->tag==1)Reverse(p->val.sublist);p=p->link;}}}int Same(GLNode *g1,GLNode *g2) /*判断两个广义表是否相同*/ {int s;if (g1==NULL && g2==NULL) /*均为NULL的情况*/return 1;else if ((g1==NULL && g2!=NULL) || (g1!=NULL && g2==NULL)) /*一个为NULL,另一不为NULL的情况*/return 0;else{s=1;while (g1!=NULL && g2!=NULL && s==1){if (g1->tag==1 && g2->tag==1)/*均为子表的情况*/s=Same(g1->val.sublist,g2->val.sublist);else if (g1->tag==0 && g2->tag==0)/*均为原子的情况*/{if (g1->val.data!=g2->val.data)s=0;}else /*一个为原子,另一为子表的情况*/s=0;g1=g1->link;g2=g2->link;}if (g1!=NULL || g2!=NULL) /*有一个子表尚未比较完时*/s=0;return s;}}ElemType MaxAtom(GLNode *g) /*求广义表g中最大的原子*/{ElemType m=0,m1; /*m赋初值0*/while (g!=NULL){if (g->tag==1) /*子表的情况*/{m1=MaxAtom(g->val.sublist); /*对子表递归调用*/if (m1>m) m=m1;}else{if (g->val.data>m) /*为原子时,进行原子比较*/m=g->val.data;}g=g->link;}return m;}void DelAtom(GLNode *&g,ElemType x) /*删除广义表g中的第一个为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtom(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/{if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}return;}}pre=p;p=q;}}void DelAtomAll(GLNode *&g,ElemType x) /*删除广义表g中的所有为x原子*/{GLNode *p=g,*q,*pre;while (p!=NULL){q=p->link;if (p->tag==1) /*子表的情况*/DelAtomAll(p->val.sublist,x); /*对子表递归调用*/else{if (p->val.data==x) /*为原子时,进行原子比较*/if (p==g)/*被删结点是本层的第1个结点*/{g=q;free(p); /*释放结pre=g;}else /*被删结{pre->link=q;free(p);}}pre=p;p=q;}}void PreOrder(GLNode *g) /*采用先根遍历g*/{if (g!=NULL){if (g->tag==0) /*为原子结点时*/printf("%c ",g->val.data);elsePreOrder(g->val.sublist); /*为子表时*/ PreOrder(g->link);}}void main(){GLNode *g1,*g2,*g3,*g4;char *str1="(a,(a),((a,b)),((a)),a)";char *str2="(a,(b),((c,d)),((e)),f)";char *str3="(a,(a,b),(a,b,c)))";char *str4="(a,(b),((c,d)),((e)),f)";g1=CreatGL(str1);printf("\n");printf(" 广义表g1:");DispGL(g1);printf("\n");printf(" 将广义表g1中所有'a'改为'b'\n");Change(g1,'a','b');printf(" 广义表g1:");DispGL(g1);printf("\n\n");g2=CreatGL(str2);printf(" 广义表g2:");DispGL(g2);printf("\n");printf(" 广义表g2中最大原子:%c\n",MaxAtom(g2));printf(" 将g2的元素逆置\n");Reverse(g2);printf(" 广义表g2:");DispGL(g2);printf("\n\n");printf(" 广义表g1和g2%s\n\n",(Same(g1,g2)?"相同":"不相同"));g3=CreatGL(str3);printf(" 广义表g3:");DispGL(g3);printf("\n");printf(" 删除广义表g3的第一个为'a'的原子\n");DelAtom(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");printf(" 删除广义表g3中的所有'a'原子\n");DelAtomAll(g3,'a');printf(" 广义表g3:");DispGL(g3);printf("\n\n");g4=CreatGL(str4);printf(" 广义表g4:");DispGL(g4);printf("\n");printf(" 采用先根遍历g4的结果:");PreOrder(g4);printf("\n\n");}。
数据结构实验考试题
第 1 题：报数问题(时间限制为：5000毫秒)5输入：标准输入输出：标准输出描述：n个人围成一个圈，每个人分别标注为1、2、...、n，要求从1号从1开始报数，报到k的人出圈，接着下一个人又从1开始报数，如此循环，直到只剩最后一个人时，该人即为胜利者。
例如当n=10,k=4时，依次出列的人分别为4、8、2、7、3、10，9、1、6、5，则5号位置的人为胜利者。
给定n个人，请你编程计算出最后胜利者标号数。
输入：输入包含若干个用例，每个用例为接受键盘输入的两个数n(1<=n<=1000000), k(1<=k<=50)，分别表示总人数及报到出圈数。
输入为“0 0“表示输入用例结束。
输出：每个用例用一行输出最后胜利者的标号数。
输入样例1：1 110 40 0输出样例1：15第2题：成绩统计(顺序线性表)(时间限制为：1000毫秒)描述：根据输入统计学生的平均分及各科平均分。
输入：第一行为学生的个数n及课程数m，第二行至m+1行为课程名，接下来为各学生的姓名及成绩，每个学生的信息占两行，第一行为学生的姓名，第二行为m个实数，表示学生各科成绩。
输出：输出包含2n+2m行，前2n行为学生的平均分，其中第一行为学生姓名，第二行为该生的平均分，后2m行为各课程的平均分，其中第一行为课程名，第二行为对应的平均分。
(保留两位小数)样例输入：3 2englishcomputerzhangshan87.5 98lisi80 78wangwu60 59样例输出：zhangshan92.75lisi79.00wangwu59.50english75.83computer78.33第3题：合并线性表(时间限制为：500毫秒)描述：已知两非递减的顺序线性表，要求合并成一个新的非递减顺序线性表。
输入：输入包含四行，第一行为自然数n，表示第一个非递减顺序线性表的长度，第二行为n个自然数构成的非递减顺序线性表，第三行为自然数m，表示第二个非递减顺序线性表的长度，第四行为m个自然数构成的非递减顺序线性表。
数据结构与算法实践练习题目及解答
数据结构与算法实践练习题目及解答以下是一些数据结构与算法的实践练题目及其解答。
1. 数组相关题目题目一给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回它们的索引。
def twoSum(nums, target):nums_dict = {}for i in range(len(nums)):nums_dict[nums[i]] = i题目二给定一个整数数组 nums，将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
def moveZeroes(nums):count = 0for i in range(len(nums)):if nums[i] != 0:nums[count] = nums[i]count += 1while count < len(nums):nums[count] = 0count += 12. 链表相关题目题目三反转一个单链表。
class ListNode:def __init__(self, val=0, next=None): self.val = valself.next = nextdef reverseList(head):prev = Nonecurr = headwhile curr is not None:next_node = curr.nextcurr.next = prevprev = currcurr = next_nodereturn prev题目四给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
def deleteDuplicates(head):curr = headwhile curr is not None and curr.next is not None:if curr.val == curr.next.val:curr.next = curr.next.nextelse:curr = curr.nextreturn head以上是一些数据结构与算法的实践练习题目及其解答。
数据结构完整题目及答案1
数据结构与算法实验报告目录实验一学生成绩分析程序 (4)1.1 上机实验的问题和要求（需求分析）： (4)1.2 程序设计的基本思想，原理和算法描述： (4)1.3 调试和运行程序过程中产生的问题及采取的措施： (4)1.4 运行输出结果： (4)1.5 源程序及注释： (5)实验二线性表的基本操作 (8)2.1 上机实验的问题和要求（需求分析）： (8)2.2 程序设计的基本思想，原理和算法描述： (8)2.3 调试和运行程序过程中产生的问题及采取的措施： (8)2.4 运行输出结果： (8)2.5 源程序及注释： (8)实验三链表的基本操作 (11)3.1 上机实验的问题和要求（需求分析）： (11)3.2 程序设计的基本思想，原理和算法描述： (11)3.3 调试和运行程序过程中产生的问题及采取的措施： (11)3.4 运行输出结果： (11)3.5 源程序及注释： (11)实验四单链表综合实验 (14)4.1 上机实验的问题和要求（需求分析）： (14)4.2 程序设计的基本思想，原理和算法描述： (14)4.3 调试和运行程序过程中产生的问题及采取的措施： (14)4.4 运行输出结果： (14)4.5 源程序及注释： (14)实验五串 (19)5.1 上机实验的问题和要求（需求分析）： (19)5.2 程序设计的基本思想，原理和算法描述： (19)5.3 调试和运行程序过程中产生的问题及采取的措施： (19)5.4 运行输出结果： (19)5.5 源程序及注释： (21)实验六循环队列的实现与运算 (22)6.1 上机实验的问题和要求（需求分析）： (22)6.2 程序设计的基本思想，原理和算法描述： (22)6.3 调试和运行程序过程中产生的问题及采取的措施： (22)6.4 运行输出结果： (22)6.5 源程序及注释： (23)实验七栈子系统 (26)7.1 上机实验的问题和要求（需求分析）： (26)7.2 程序设计的基本思想，原理和算法描述： (26)7.3 调试和运行程序过程中产生的问题及采取的措施： (26)7.4 运行输出结果： (26)7.5 源程序及注释： (28)实验八树 (36)8.1 上机实验的问题和要求（需求分析）： (36)8.2 程序设计的基本思想，原理和算法描述： (39)8.3 调试和运行程序过程中产生的问题及采取的措施： (39)8.4 运行输出结果： (39)8.5 源程序及注释： (41)实验九建立哈夫曼树与哈夫曼树与码 (50)9.1 上机实验的问题和要求（需求分析）： (50)9.2 程序设计的基本思想，原理和算法描述： (50)9.3 调试和运行程序过程中产生的问题及采取的措施： (50)9.4 运行输出结果： (50)9.5 源程序及注释： (50)实验十图 (53)10.1 上机实验的问题和要求（需求分析）： (53)10.2 程序设计的基本思想，原理和算法描述： (53)10.3 调试和运行程序过程中产生的问题及采取的措施： (53)10.4 运行输出结果： (53)10.5 源程序及注释： (53)实验一学生成绩分析程序一、上机实验的问题和要求（需求分析）：【题目】设一个班有10个学生，每个学生有学号，以及数学、物理、英语、语文、体育 5 门课的成绩信息。
数据结构实验题目
实验题目一一、单链表基本运算【问题描述】设计并实现线性表的单链表存储和运算。
【基本要求】实现单链表的插入、删除和遍历运算，每种操作用一个函数实现。
插入操作：将一个新元素插入表中指定序号的位置。
删除操作：将指定序号的元素从表中删除。
遍历操作：从表头按次序输入所有元素的值，若是空表，则输出信息“empty list!”。
【实现提示】程序运行时，首先在main函数中创建空的、带头结点的单链表。
然后多次调用实现插入操作的函数（每次都将元素在序号1位置上插入），将元素依次插入表中，最后调用实现遍历操作的函数输出所有元素。
之后再多次调用实现删除操作的函数将表还原为空表（每次都删除第1个元素，每删除一个元素后，将表中剩余元素都输出一次）。
【测试数据】输入数据：1 2 3 4 5 0（为0时结束，0不存入链表）第一次输出：5 4 3 2 1第二次输出：4 3 2 1第三次输出：3 2 1第四次输出：2 1第五次输出：1第六次输出：empty list!二、约瑟夫环问题【问题描述】编号为1,2,...,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
现在给定一个随机数m>0，从编号为1的人开始，按顺时针方向1开始顺序报数，报到m时停止。
报m的人出圈，同时留下他的密码作为新的m值，从他在顺时针方向上的下一个人开始，重新从1开始报数，如此下去，直至所有的人全部出列为止。
【基本要求】利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。
【测试数据】M的初始值为20；n等于7，7个人的密码依次为：3，1，7，2，4，8，4。
输出为：6，1，4，7，2，3，5【实现提示】程序运行时，首先要求用户指定初始报数上限值，然后读取各人的密码。
可设n≤30。
此题所用的循环链表中不需要“头结点”，请注意空表和非空表的界限。
【选作内容】用顺序存储结构实现该题目。
三、一元多项式相加、减运算器【问题描述】设计一个一元稀疏多项式简单计算器。
数据结构试验题目
试验一：顺序表操作试验1．试验目的（1）掌握顺序表的顺序存储结构；（2）验证顺序表及其基本操作的实现；（3）掌握数据结构及算法的程序实现的基本方法。
2．试验内容（1）建立含有若干个元素的顺序表；（2）对已建立的顺序表实现插入、删除、查找等操作。
试验二：栈操作验证1、试验目的（1）掌握栈的存储结构；（2）掌握栈的操作特性；（3）掌握基于顺序栈的基本操作的实现方法。
2、试验内容（1）建立一个空栈；（2）对已建立的栈进行插入、删除、取栈顶元素等基本操作。
试验三、队列操作验证1、试验目的（1）掌握队列的链接的存储结构；（2）掌握队列的操作特性；（3）掌握基于链队列的基本操作的实现方法。
2、试验内容（1）建立一个空队列；（2）对已建立的队列进行插入、删除、取栈顶元素等基本操作。
试验四、二叉树操作验证1、试验目的（1）掌握二叉树的逻辑结构；（2）掌握二叉树的二叉链表存储结构；（3）掌握基于二叉链表存储的二叉树的遍历操作的实现。
2、试验内容（1）建立一棵含有n个结点的二叉树，采用二叉链表存储；（2）前序（或中序、后序）遍历该二叉树。
实验五、邻接矩阵操作验证1、试验目的（1）掌握图的逻辑结构；（2）掌握图的邻接矩阵存储结构；（3）掌握图在邻接矩阵存储结构上遍历算法的实现。
2、试验内容（1）建立无向图的邻接矩阵存储；（2）对建立的无向图，进行深度优先遍历；（3）对建立的无向图，进行广度优先遍历。
试验六、折半查找验证1、试验目的（1）掌握折半查找算法的基本操作；（2）掌握折半查找算法的实现方法；（3）掌握折半查找算法的时间性能。
2、试验内容对给定的有序数组（假设长度为n），查找数组中与给定值k相等的元素。
试验七、简单选择排序算法验证1、试验目的（1）掌握简单选择排序算法的基本思想；（2）掌握简单选择排序算法的实现方法；（3）验证简单选择排序算法的时间性能。
2、试验内容对一组数据进行简单选择排序（按升序排列）。
数据结构实习题目
一元多项式计算能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减和相乘, 并将结果输出。
矩阵的运算采用十字链表表示稀疏矩阵, 并实现矩阵的加法运算, 要求: 要检查有关运算的条件, 并对错误的条件产生报警。
迷宫求解输入一个任意大小的迷宫数据, 用递归和非递归两种方法求出一条走出迷宫的路径, 并将路径输出；宾馆订房和退房系统假设一个宾馆有n个标准的客房, 每个标准客房有m个标准间, 利用链表、栈或者队列等数据结构设计出具有订房和退房等功能的管理系统。
建立二叉树和线索二叉树分别用以下方法建立二叉树并用图型显示出来:用先序遍历的输入序列用层次遍历的输入序列用先序和中序遍历的结果最后对所建立的二叉树进行中序线索化, 并对此线索树进行中序遍历(不使用栈)。
学生成绩查询系统试编写程序完成学生成绩记录的查询。
按学号排序后对学号进行折半查找。
随机输入以学号为关键字的学生信息并构建二叉排序树, 对学号进行二叉排序树查找。
马的遍历问题设计程序完成如下要求: 在中国象棋棋盘上, 对任一位置上放置的一个马, 均能选择一个合适的路线, 使得该棋子能按象棋的规则不重复地走过棋盘上的每一位置。
要求:1)依次输出所走过的各位置的坐标。
2)最好能画出棋盘的图形形式, 并在其上动态地标注行走过程。
教学计划编制问题大学的每个专业都要编制教学计划。
假设任何专业都有固定的学习年限, 每学年含两学期, 每学期的时间长度和学分上限都相等。
每个专业开设的课程都是确定的, 而且课程的开设时间的安排必须满足先修关系。
每个课程的先修关系都是确定的, 可以有任意多门, 也可以没有。
每一门课程恰好一个学期。
试在这样的情况下设置一个教学计划编制程序。
设计要求：针对计算机系本科课程, 根据课程之间的依赖关系(如高级语言、离散数学应在数据结构之前开设)制定课程安排计划, 并满足各学期课程数目大致相同。
设计一个模拟计算器的程序要求对包含加、减、乘、除、括号运算符的任意整型表达式进行求解。