数据结构上机作业
数据结构上机作业答案
作业1. 线性表编程作业：1．将顺序表逆置，要求用最少的附加空间。
参考答案#include <stdio.h>#include <malloc.h>#include <process.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct{ ElemType *elem;int length;int listsize;}SqList;//创建空顺序表Status InitList_Sq( SqList &L ){L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof(ElemType));if (!L.elem)exit(OVERFLOW);L.length = 0;L.listsize = LIST_INIT_SIZE;return OK;}//顺序表在第i个元素之前插入eStatus ListInsert_Sq( SqList &L, int i, ElemType e){ ElemType *newbase,*q,*p;if(i<1 || i>L.length+1) //插入位置非法return ERROR;if(L.length>=L.listsize)//溢出，动态追加空间{ newbase= (ElemType *)realloc(L.elem, (L.listsize+ LISTINCREMENT) *sizeof(ElemType));if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;p--) //元素后移*(p+1)=*p;*q=e; //完成元素插入++L.length;return(OK);}//顺序表遍历显示Status ListTraverse_Sq(SqList L){ int i=0;if(!L.elem)return ERROR;while(i<L.length)printf("%d ",L.elem[i++]);printf("\n");return OK;}//顺序表逆置void Reverse_Sq(SqList &L){int i,j;ElemType temp;for(i=0,j=L.length-1; i<j; i++,j--){temp=L.elem[i];L.elem[i]=L.elem[j];L.elem[j]=temp;}}void main(){SqList L;char flag;int i;ElemType e;if(InitList_Sq(L)==OK){printf("建立空顺序表成功！\n");do{printf("当前线性表长度为：%d\n",L.length);printf("请输入要插入元素的位置：");scanf("%d",&i);printf("请输入要插入的元素值：");scanf("%d",&e);if(ListInsert_Sq(L,i,e)==OK){printf("插入成功，插入后顺序表长度为：%d\n",L.length);printf("插入后的顺序表为：");ListTraverse_Sq(L);}elseprintf("插入失败");printf("\n继续插入元素？(y/n) ");fflush(stdin);scanf("%c",&flag);}while(flag=='y');Reverse_Sq(L);printf("顺序表逆置后为：\n");ListTraverse_Sq(L);}elseprintf("顺序表初始化失败！\n");}2．从键盘读入n个整数（升序），请编写算法实现：（1）CreateList()：建立带表头结点的单链表；（2）PrintList()：显示单链表，（形如：H->10->20->30->40）;（3）InsertList()：在有序单链表中插入元素x；（4）ReverseList()：单链表就地逆置；（5）DelList()：在有序单链表中删除所有值大于mink且小于maxk的元素。
数据结构第一次上机作业
数据结构第一次上机作业一．上机时间：2010年9月9日二．报告时间：2010年9月13日三．摘要1.试验目的：熟悉线性表的基本操作2.实验方法:（下面）3.实验结果（下面）四．内容（1）问题重新陈述题目的要求是随机的给四个人发牌，要求（斗地主为例，这个不用处理花色和王）1.每人手里要有13张牌（不用大小王，）2.每人每次手里的牌不能都是一样的（即：手中的牌是没有固定规律的）3.每轮每张牌只能出现一次，每个花色各有13张4.每人手中的牌要按照花色的顺序出现，再在同种花色中按照从小到大的顺序放置（2）验证：看是否满足上面的要求1．由于每张牌具有唯一性，则看每种花色的每张牌是否都出现过一次2．总数要是523．测试的方法：做差法（排序，就行做差，b[i+1]-b[i]）4．测试的内容：差值是否为15．判别标准：把花色转化成数字（分别用13乘以0，1，2，3在加上拍死的数字），看是否52个数字全出现了五．所用技术1．排序方法：由于每副扑克有54张牌，但是桥牌之需要出去大小王的52张。
因此用1-52同52个数字代替每张牌2．J,Q,K,A的处理：让J相当于11，Q相当于12，K相当于13，A相当于13．花色及大小的处理：52张牌除以13所得的商1，2，3和4分别表示四种花色，所得的余数表示牌的数字（A（1），2，3，4，5，6，7，8，9，10，11（J），12（Q），13（K））或者4．随机化洗牌及发牌的方法：运用srand(time(0)), rand()或者#include<stdlib.h>, #include <time.h>例如：#include<stdlib.h>#include<time.h>#include<stdio.h>main(){int r;srand((unsigned)time(NULL));r=random(10);printf("%d\n" ,r);r=random(10);printf("%d\n" ,r);getch();}还有int random(int a,int b)//产生一个它们之间并包括它们的随机数{if(a>b){a^=b^=a^=b;}//交换a,b值，使a小,b大int x=rand()%(b-a+1)+a;}5．洗牌程序void ordinary_shuffle(struct puke pk[52]){for(i=0;i<52;i++){ int t;int tds=0,ths=0;t=rand()%52;/*取随机数*/tds=pk[i].dianshu;/*进行牌与牌之间的随机替换*/ ths=pk[i].huase;pk[i].dianshu=pk[t].dianshu;pk[i].huase=pk[t].huase;pk[t].dianshu=tds;pk[t].huase=ths;}}或者void reset(){produce_seed();for(int i=1;i<=54;i++)v.push_back(i);}void random(){for(int i=0;i<random(m,n);i++)//mn为具体的数字{int index=random(1,53);v[index]^=v[0]^=v[index]^=v[0];}6．六．存在问题1.在验证程序输入时不知道花色怎么处理2.排序时不知道怎么用C语言进行描述3.关于时间和空间复杂度的计算比较混乱4.不能正确的使用C语言编译自己所想七．解决方法1.进行二维数组进行输入用a[j][i]表示某一具体的牌，其中j表示花色，i表示牌数（A，2，3，4，5，6，7，8，9，10，J,Q,K）2.八．设计程序#include <string>#include <iostream>#include <vector>#include <Windows.h>using namespace std;vector<int> v;//储存扑克的容器void produce_seed()//产生种子{SYSTEMTIME sys;GetLocalTime( &sys );srand(sys.wMilliseconds*sys.wSecond*sys.wMinute);//这样理论上能得到3600*1000种牌型}int random(int a,int b)//产生一个它们之间并包括它们的随机数{if(a>b){a^=b^=a^=b;}//交换a,b值，使a小,b大int x=rand()%(b-a+1)+a;return x;}/*产生54张打乱顺序的扑克*/void reset(){produce_seed();for(int i=1;i<=54;i++)v.push_back(i);}void random(){for(int i=0;i<random(200,300);i++)//洗牌200至300次{int index=random(1,53);v[index]^=v[0]^=v[index]^=v[0];}}void paint(const vector<int>& v,bool type=false)//type=false不显示花型{for(int i=0;i<v.size();i++){cout<<" ";if(v[i]==53)cout<<(char)1;else if(v[i]==54)cout<<(char)2;else{if(type)cout<<(char)((v[i]+2)%4+3);if((v[i]+3)/4==13)cout<<"K";else if((v[i]+3)/4==12)cout<<"Q";else if((v[i]+3)/4==11)cout<<"J";else if((v[i]+3)/4==1)cout<<"A";else cout<<(v[i]+3)/4;}//cout<<"="<<v[i];}cout<<endl<<endl;}void sort(vector<int>& v){for(int i=0;i<v.size()-1;i++)for(int j=i+1;j<v.size();j++){if(v[i]<v[j])v[i]^=v[j]^=v[i]^=v[j];if(v[i]<53&&v[j]<53)if(((v[i]+3)/4+10)%13<((v[j]+3)/4+10)%13)v[i]^=v[j]^=v[i]^=v[j];}}void main(){reset();random();vector<int> v1(v.begin(),v.begin()+17);vector<int> v2(v.begin()+17,v.begin()+34);vector<int> v3(v.begin()+34,v.begin()+51);vector<int> v4(v.begin()+51,v.end());sort(v1);sort(v2);sort(v3);sort(v4);paint(v1,/n);paint(v2,/n);paint(v3,/n);paint(v4,/n);system("pause");}九．验证程序#include<stdio.h>void main(){int i,j,m,n;int a[4][13],b[52];flag=0;printf(“Iuput number:/n”);for(i=0;i<13;i++)for(j=0;j<4;j++){Scanf(“%d”,&a[j][i]); /*进行输入*/if(j==0) b[i]= a[j][i];else if(j==1) b[i+j*13]=a[j][i];else if(j==2) b[i+j*13]= a[j][i];else(j==3) b[i+j*13]= a[j][i];}for(i=0;i<52) /*进行验证*/{m=b[i+1]-b[i];if(m!=1) printf(“thit it wrong/n”); break;elso i=i+1;}}十．运行结果十一．。
数据结构上机作业题
数据结构上机实验题：1.分裂线性表，将线性表L1中奇数存到线性表L2中,偶数存到线性表L3中2.编写递归函数，计算二叉树中叶子结点的数目。
3．编写直接插入排序测试程序4．编程实现顺序检索算法参考答案：1. 分裂线性表，将L1中奇数存到L2中,偶数存到L3中#include <stdio.h>#define N 100 /*预定义最大的数据域空间*/typedef int datatype; /*假设数据类型为整型*/typedef struct {datatype data[N]; /*此处假设数据元素只包含一个整型的关键字域*/int length; /*线性表长度*/} seqlist; /*预定义的顺序表类型*/void initseqlist(seqlist *L) //初始化表{L->length=0;}void input(seqlist *L) //输入多个数据创建表{datatype x;initseqlist(L);printf("Please input numbers,0 as end:\n");scanf("%d",&x);while (x){L->data[L->length++]=x;scanf("%d",&x);}}void print(seqlist *L){int i;for (i=0;i<L->length;i++){ printf("%5d",L->data[i]);if ((i+1)%10==0) printf("\n");}printf("\n");}/*分裂线性表，将L1中奇数存到L2中,偶数存到L3中*/void sprit(seqlist *L1,seqlist *L2,seqlist *L3){int i,j,k,len;j=0,k=0;len=L1->length-1;for (i=0;i<=len;i++){ if(L1->data[i]%2==0)L3->data[j++]=L1->data[i];else L2->data[k++]=L1->data[i];}L2->length=k;L3->length=j;}int main(){seqlist L1,L2,L3;initseqlist(&L2);initseqlist(&L3);input(&L1);sprit(&L1,&L2,&L3);print(&L1);print(&L2);print(&L3);}2.编写递归函数算法，计算二叉树中叶子结点的数目。
《数据结构》上机作业难完成的成因分析
论 学得好 ． 并不 代表 上机实践 就好 ， 事实 上 ， 上机 实 在 训 教学 中有很 多学 生都完成不 了上机作业 ．在这 里主
要从教学 方法的角度上来分析原 因
程序代 码违背 了 Ｃ语言 的语法规 定而 出现错误 ，
编译 程序一般会用英文给 出“ 出错 信 息 ”１ 示 。 告 ［ ２ 的提 并 诉 错 误 在 哪 一行 由于 学 生 英 语 水 平 普 遍 不 高 ． 难 明 很
：
《 数据结构》 上机作业难完成 的成 因分析
杨智 明 ． 漆 丽 娟
６７０ ） ５０ ０
／ ／ ／
（ ． 南保 山学 院 计 算 机 科 学 系 ， 山 ６ ８ ０ ； ． １云 保 ７０ ０ ２ 云南 昭通 师 专 计算 机 科 学 系 ， 通 昭
摘
要 ：通 过 对保 山 学 院 计科 系 ２ ０ ￣ ０ ０届 的 学 生难 以 完成 《 据 结 构 》 机 作 业 的情 况分 析 ， ０５２１ 数 上 从 教 学 方 法 的 角度 寻找 原 因 ， 据 实 际情 况提 出 上 机 实训 教 学 改 革 的 具 体 措 施 ， 根 以促 使 学 生 顺 利 完成 作 业 ． 高 用计 算 机 解 决 问题 的 能 力 。 提
１１ 算 法 转换 成 程 序 困难 ．
在 我 们 选 用 的严 蔚 敏 编 著 Ｃ版 本 的《 据 结 构 》 数 教
白编译程序提示语句错误 的原因 ．或者编译程序 提示 的语 句错误不属 于本行 ． 学生查错 、 使 改错存在 一定的
困难 。
材 中 ． 多经典 算法都 采用类 Ｃ语 言描述［ 要想 把算 许 １ ］ 。
最新大连理工大学数据结构(一)上机作业答案——张老师
typedef int ElemType;
typedef int Status;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
void CreateList(LinkList &L,int n){
s->data=m;
s->next=NULL;
p->next=s;
}
}
void ReverseList(LinkList &L){
LNode *p,*q;
if(L->next&&L->next->next){
p=L->next;
q=p->next;
p->next=NULL;
while(q){
p=q;
typedef int Status;
#define LIST_INIT_SIZE 100
#define LISTTINCREMENT 10
typedef struct{
ElemType *elem;
int length;
int listsize;
}SqList;
//创建空顺序表
Status InitList_Sq(SqList &L){
1．将顺序表逆置，要求用最少的附加空间。
参考答案
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
数据结构上机作业(新)_7965_1643_20120308093338
线性表1、某软件公司大约有30名员工，每名员工有姓名、工号、职务等属性，每年都有员工离职和入职。
把所有员工按照顺序存储结构建立一个线性表，建立离职和入职函数，当有员工离职或入职时，修改线性表，并且打印最新的员工名单。
（动态分配存储，malloc，realoc）2、约瑟夫（Josephus）环问题：编号为1,2,3,…,n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。
一开始任选一个正整数作为报数的上限值m，从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止。
报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一人开始重新从1报数，如此下去，直到所有人全部出列为止。
建立n个人的单循环链表存储结构，运行结束后，输出依次出队的人的序号。
（必须用链表）栈和队列3、某商场有一个100个车位的停车场，当车位未满时，等待的车辆可以进入并计时；当车位已满时，必须有车辆离开，等待的车辆才能进入；当车辆离开时计算停留的的时间，并且按照每小时1元收费。
汽车的输入信息格式可以是（进入/离开，车牌号，进入/离开时间），要求可以随时显示停车场内的车辆信息以及收费历史记录。
（选作，用指针轮询数组，有空位就入，利用时间函数计时）4、某银行营业厅共有6个营业窗口，设有排队系统广播叫号，该银行的业务分为公积金、银行卡、理财卡等三种。
公积金业务指定1号窗口，银行卡业务指定2、3、4号窗口，理财卡业务指定5、6号窗口。
但如果5、6号窗口全忙，而2、3、4号窗口有空闲时，理财卡业务也可以在空闲的2、3、4号窗口之一办理。
客户领号、业务完成可以作为输入信息，要求可以随时显示6个营业窗口的状态。
（复杂，选作）5、4阶斐波那契序列如下：f0=f1=f2=0, f3=1,…,f i=f i-1+f i-2+f i-3+f i-4，利用容量为k=4的循环队列，构造序列的前n+1项（f0, f1 , f2 ,… fn ），要求满足f n≤200而f n+1 >200。
数据结构上机实验
目录第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-5章
第一章◆1.16②试写一算法，如果三个整数X，Y和Z的值不是依次非递增的，则通过交换，令其为非递增。
void Descend(int &x, int &y, int &z)/* 按从大到小顺序返回x，y和z的值*/{ int t;if(x<y){t=x;x=y;y=t;}if(x<z){t=x;x=z;z=t;}if(y<z){t=y;y=z;z=t;} }1.17③已知k阶裴波那契序列的定义为f0=0, f1=0, ..., fk-2=0, fk-1=1;fn=fn-1+fn-2+...+fn-k, n=k,k+1,...试编写求k阶裴波那契序列的第m项值的函数算法，k和m均以值调用的形式在函数参数表中出现。
要求实现下列函数：Status Fibonacci(int k, int m, int &f)/* 求k阶斐波那契序列的第m项的值f */{ int tempd;int temp[100];int i,j,sum=0;if(k<2||m<0) return ERROR;if(m<k-1) f=0;else if (m==k-1) f=1;else{for(i=0;i<=k-2;i++) temp[i]=0; temp[k-1]=1;for(i=k;i<=m;i++){for(j=i-1;j>=i-k;j--)sum=sum+temp[j];temp[i]=sum;sum=0;}f=temp[m];}return OK;}1.18③假设有A、B、C、D、E五个高等院校进行田径对抗赛，各院校的单项成绩均以存入计算机并构成一张表，表中每一行的形式为项目名称性别校名成绩得分.编写算法，处理上述表格，以统计各院校的男、女总分和团体总分，并输出。
void Scores(ResultType *result, ScoreType *score)/* 求各校的男、女总分和团体总分, 并依次存入数组score */ /* 假设比赛结果已经储存在result[ ]数组中, */ /* 并以特殊记录{"", male, ' ', "", 0 }（域scorce=0）*//* 表示结束*/ {int i = 0;while( result[i].sport ){switch( result[i].schoolname ){case 'A':score[0].totalscore+= result[i].score;if( result[i].gender == female ) score[0].femalescore+=result[i].score; elsescore[0].malescore+=result[i].score; break;case 'B':score[1].totalscore += result[i].score; if( result[i].gender == female ) score[1].femalescore+=result[i].score; elsescore[1].malescore+= result[i].score;break;case 'C':score[2].totalscore += result[i].score;if( result[i].gender == female )score[2].femalescore+=result[i].score; elsescore[2].malescore += result[i].score; break;case 'D':score[3].totalscore+= result[i].score;if( result[i].gender == female )score[3].femalescore+=result[i].score;elsescore[3].malescore+=result[i].score;break;case 'E':score[4].totalscore+= result[i].score;if( result[i].gender == female )score[4].femalescore+=result[i].score;elsescore[4].malescore+=result[i].score;break;}i++;}}◆1.19④试编写算法，计算i!×2^i的值并存入数组a[0..ARRSIZE-1]的第i-1个分量中(i=1,2,…,n)。
数据结构上机作业6-10章
6.33③假定用两个一维数组L[1..n]和R[1..n]作为有n个结点的二叉树的存储结构，L[i]和R[i]分别指示结点i的左孩子和右孩子，0表示空。
试写一个算法判别结点u是否为结点v的子孙。
要求实现以下函数：Status Dencendant(Array1D L,Array1D R,int n,int u,int v);一维数组类型Array1D的定义：typedef int Array1D[MAXSIZE];Status Dencendant(Array1D L,Array1D R,int n,int u,int v){ if(L[v]==u||R[v]==u) return TRUE;if(L[v])if(Dencendant(L,R,n,u,L[v])) return TRUE;if(R[v])if( Dencendant(L,R,n,u,R[v]) )return TRUE;else return FALSE;}6.34③假定用两个一维数组L[1..n]和R[1..n]作为有n个结点的二叉树的存储结构，L[i]和R[i]分别指示结点i的左孩子和右孩子，0表示空。
试写一个算法,先由L和R建立一维数组T[1..n]，使T中第i(i=1,2,..., n)个分量指示结点i的双亲，然后判别结点u是否为结点v的子孙。
要求实现以下函数：Status Dencend(Array1D L, Array1D R, int n, int u, int v, Array1D T);一维数组类型Array1D的定义：typedef int Array1D[MAXSIZE];Status Dencend(Array1D L, Array1D R, int n, int u, int v, Array1D T){ int i;for( i = 1; i <= n; ++i )T[L[i]] = i;for( i = 1; i <= n; ++i )T[R[i]] = i;while(T[u]!=0){if(T[u]==v)return TRUE;u=T[u];}return FALSE;}6.36③若已知两棵二叉树B1和B2皆为空，或者皆不空且B1的左、右子树和B2的左、右子树分别相似，则称二叉树B1和B2相似。
数据结构的第二次上机实验作业
数据结构实验报告实验名称：______简单计算器______________________ 学生姓名：_________刘健___________________班级：_________2013211129________________班内序号：_________10_______学号：_______2013210796_____________________ 日期：____________________________1. 实验目的和内容表达式求值是程序设计语言编译中最近本的问题，它要求把一个表达式翻译成能够直接求值的序列。
例如用户输入字符串“14+((13-2)*2-11*5)*2”，程序可以自动计算得到最终的结果。
在这里，我们将问题简化，假定算数表达式的值均为非负整数常数，不包含变量、小数和字符常量。
试设计一个算术四则运算表达式求值的简单计算器。
基本要求：1、操作数均为非负整数常数，操作符仅为+、-、*、/、（和）；2、编写main函数进行测试。
2. 程序分析2.1 存储结构为了实现运算符有限算法，在程序中应该设计两个栈，分别是运算符栈OPTR，操作数栈OPND。
2.2 程序流程2.3 关键算法分析算法1：char Precede(char t1, char t2)[1] 算法功能：判断运算符t1和t2的优先级关系[2] 算法基本思想：如：cas e’+’:case’-:’if(t1==’(’||t1==’#’)f=’<’;//t1<t2elsef=’>’;//t1>t2break;优先级图表：[3] 算法空间、时间复杂度分析：O(1)算法2: bool IsOperator(char c)[1] 算法功能：判断c是否为7种运算符之一[2] 算法基本思想：bool IsOperator(char c) //判D断?c是?否?为a7种?运?算?符?之?一?{switch(c){case'+':case'-':case'*':case'/':case'(':case')':case'#':return true;default:return false;}}用switch进行选择判断。
数据结构课程上机实践题目
3. 设有双向链表 A，其中的数据内容为整型数值，且按增序排列，要求： 输入任一整型数值，若 A 中已存在，则删除该结点；若 A 中不存在，则
在相应位置插入该结点。 编程要求：
输入： 键盘输入链表 A 的数据元素(至少 5 个) 键盘输入任意一个整型数据
输出： 屏幕打印链表 A 的数据元素。
《数据结构》第 1，2 次上机题 （线性表练习） 1. 设计线性表顺序存储结构的 11 个基本操作函数，并编程实现之 。 2．利用上题的线性表，编程下列功能：假设以两个元素依值递增有序排列的线 性表 A 和 B 分别表示两个集合，现要求另辟空间构成一个线性表 C，其元素为 A 和 B 元素的交集，且表 C 中的元素也是依值递增有序排列。 3. 设计线性表链式存储结构的基本操作函数，并编程实现之 。 4. 利用上题的链式表，编程下列功能：一元多项式的相加。 5. 约瑟夫问题。设有 n 个人做作圆桌周围，从第 s 个人开始报数，报到 m 的人 出列，然后再从下一个人开始报数，数到 m 的人又出列，如此重复，直到所有 的人都出列为止。要求按出列的先后顺序输出每个人的信息。 结构体和结点可以参照下列代码：
编程要求： 输入： 键盘输入链表 A 的数据元素(至少 5 个) 键盘输入链表 B 的数据元素(至少 5 个) 输出： 屏幕分别打印链表 A，B，C 的数据元素。
2. 设有链表 A 和 B，其中的数据内容均为整型数值，且都按增序排列，生成一 个新的链表 C，满足下列要求： (1) C = A I B (C 中元素为 A 和 B 中都出现的元素) (2) C 中元素为 A 中元素的逆序排列 编程要求： 输入： 键盘输入链表 A 的数据元素(至少 5 个) 键盘输入链表 B 的数据元素(至少 5 个) 输出： 屏幕分别打印链表 A，B，C 的数据元素 (其中第 2 小题只要打印 A，
数据结构上机作业——顺序表
数据结构上机作业——顺序表一、实验目的理解线性表的逻辑结构、顺序存储结构和数据操作，熟练运用Java语言实现线性表的基本操作，分析各种操作算法特点和时间复杂度。
熟悉JCreator调试程序的方法。
二、主要内容1、按照教材P37编写顺序表类，在SeqList中增加main方法或者编写一个测试类测试各方法的正确性。
说明：注意package路径，导入LList，过程参考如下：1）创建工程：File->New->Project，选择Empty Project，输入工程名称及路径，点击完成。
2）鼠标指向工程ds，单击鼠标右键，在快捷菜单中选择Add->New Folder，新建文件夹dataStructure，在dataStructure新建文件夹linearList。
3）鼠标指向文件夹linearList，单击鼠标右键，在快捷菜单中选择Add Existing Files，选择LList.java（教育在线例程中）。
4）鼠标指向文件夹linearList，单击鼠标右键，，在快捷菜单中选择New Class，在Class Wizard中输入相关内容，类名：SeqList。
5）程序编辑结束后，执行Build->Build File菜单命令，编译Java程序，系统在Build Output区域输出错误信息，编译通过后将生成字节码文件（.class）。
6）测试：方法1 在SeqList类中增加main方法，例如public static void main(String args[]){SeqList<String> list=new SeqList<String>(7);list.add("");list.add("");list.add("");list.add("");System.out.println(list.toString());list.add(2,"");System.out.println(list.toString());list.remove(3);System.out.println(list.toString());}修改main方法，完成相应测试。
数据结构上机作业
数据结构上机作业1.已知输⼊x、y、z三个不相等的整数，试设计⼀个算法，使这三个数按从⼩到⼤的顺序进⾏排序并输出，并考虑此算法的⽐较次数和元素的移动次数。
2.猴⼦吃桃⼦问题。
猴⼦第⼀天摘下若⼲个桃⼦，当即吃了⼀半，还不过瘾，⼜多吃了⼀个；第⼆天早上⼜将剩下的桃⼦吃掉了⼀半，⼜多吃了⼀个；以后每天早上都吃了前⼀天剩下的⼀半加⼀个，到第⼗天早上再想吃时，发现只剩下⼀个桃⼦了。
求第⼀天共摘了多少个桃⼦。
3.给定⼀个数组，要求在此数组中插⼊⼀个元素、删除⼀个元素，并显⽰每次操作之后的输出。
4.验证课本P11程序2-1和P13程序2-2，体会顺序存储结构下线性表的插⼊和删除操作。
5.有顺序存储结构下的线性表A和B，其元素均按从⼩到⼤的升序排列，编写⼀个算法将它们合并成⼀个顺序表C，要求C的元素也是从⼩到⼤升序排列。
如：线性表A为：1、5、9、12、18、25线性表B为：2、3、6、10、16、19、20、26、28、30、35合并之后的线性表C为：1、2、3、5、6、9、10、12、16、18、19、20、25、26、28、30、356. 试写出在顺序存储结构下逆转线性表的算法，要求使⽤最少的附加空间。
7.试编程实现，在⼀个有序线性表中（顺序存储结构）插⼊⼀个元素后仍然是有序线性表。
8.设顺序存储结构下线性表中有多个0元，编程实现所有⾮零元依次移到线性表的前端。
9.验证课本P16程序2-3和P17程序2-4，体会线性链表的建⽴和查找操作。
10.思考题：将程序2-4稍作修改，改为“在单链表中查找指定结点的前⼀个结点”，为将来的插⼊和删除操作做准备。
11.试编写⼀个在单链表中数据域值为a的结点之后，插⼊⼀个新结点的算法。
若原链表中⽆数据域值为a的结点，则把新结点插⼊到表尾。
设新结点数据域值为x。
12.已知线性单链表，试编写⼀个删除表中所有值⼤于min且⼩于max的元素（若表中存在这样的元素）的算法。
13.设有两个有序线性单链表，头指针分别为AH和BH。
经典数据结构上机题—答案【精选文档】
数据结构上机实验题目实验一线性表的顺序存储结构实验学时 2学时背景知识：顺序表的插入、删除及应用.目的要求：1．掌握顺序存储结构的特点。
2．掌握顺序存储结构的常见算法。
实验内容1．输入一组整型元素序列，建立顺序表。
2．实现该顺序表的遍历。
3．在该顺序表中进行顺序查找某一元素,查找成功返回1，否则返回0。
4．判断该顺序表中元素是否对称，对称返回1，否则返回0。
5．实现把该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数.6．输入整型元素序列利用有序表插入算法建立一个有序表.7．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表.8。
利用该顺序结构实现循环队列的入队、出队操作。
8．编写一个主函数,调试上述算法。
＃include 〈stdio.h〉#include <stdlib。
h>＃define OVERFLOW 0＃define MAXSIZE 100typedef int ElemType；typedef struct list{ElemType elem［MAXSIZE];int length；｝Sqlist；void Creatlist(Sqlist ＆L)｛int i；printf(”请输入顺序表的长度："）; //输入一组整型元素序列，建立一个顺序表.scanf（"％d”，＆L。
length)；for(i=0；i<L。
length；i++）scanf(”%d"，&L。
elem［i］);}void printlist（Sqlist &L）//以输出的形式实现对该顺序表的遍历{int i;for（i=0；i<L.length；i++)printf("％d ”，L。
elem［i］）;printf（”\n”)；｝void Searchlist（Sqlist &L,int x) //在顺序表中进行顺序查找某一元素x，查找成功则返回其存储位置i，否则返回错误信息{int i,k=—1；for(i=0;i<L.length;i++）if(L。
数据结构课程上机实践题目
datatype info; struct node *next; } NODE; 6. 设有一个双向循环链表，每个结点中除有 pre，data 和 next 三个域外，还增设 了一个访问频度域 freq。在链表被起作用前，频度域 freq 的值均初始化为零，而 当对链表进行一次 LOCATE(L,x)的操作之后，被访问的结点（即元素值等于 x 的节点）中的频度域 freq 的值便增 1，同时调整链表中结点之间的次序，使其按 访问频度非递增的顺序排列，以便始终保持被频繁访问的结点总是靠近表头结 点。试编程实现之。
6. 已知线性表中的元素以值递增顺序排列，并以双向链表为存储结构。试实现 以下功能：删除表中所有[MinNum, MaxNum]范围内的数据。 编程要求： 输入： 键盘输入链表的数据元素(至少 5 个) 键盘输入 MinNum, MaxNum 值 输出： 屏幕打印链表操作的结果。
第一阶段总结
《数据结构》 第 3,4,5 次上机题目： （栈 队列 串 数组 十字链表 练习） 1. 设计栈的基本操作函数，并编程实现之 。 2. 利用栈操作实现八皇后问题求解。(选做题)
《数据结构》 第 7 次上机题目 ( 图 练习 ) 1．无向图的最小生成树练习 2．拓扑排序和关键路径练习 3．最短路径练习
第三阶段总结
《数据结构》 第 8 次上机题目 ( 查找 排序 练习 ) 1. 哈希表设计 ( 习题集 P166. 6.2 题) 2. 平衡二叉树练习 ( 习题集 P166. 6.4 题) (选做) 3. 内部排序算法的比较 (习题集 P166. 6.6 题)
C 的元素)。
3. 设有双向链表 A，其中的数据内容为整型数值，且按增序排列，要求： 输入任一整型数值，若 A 中已存在，则删除该结点；若 A 中不存在，则
数据结构上机考试(含答案)
《数据结构》上机练习题1、设有两个有序序列，利用归并排序将它们排成有序表，并输出。
2、设有一有序序列，从键盘输入一个数，判别是否在序列中，如果在输出“YSE”；否则，将它插入到序列中使它仍然有序，并输出排序后的序列。
3、设有一有序序列，从键盘输入一个数，判别是否在序列中，如果不在，则输出“NO”，否则，将它从序列中删除它，并输出删除后的序列。
4、从键盘输入一组任意数据，建立一个有序链表，并从链头开始输出该链，使输出结果是有序的。
5、从键盘输入一组任意数据，建立一个包含所有输入数据的单向循环链表，并从链表的任意开始，依次输出该链表中的所有结点。
10、设有一个链表，（自己建立，数据从键盘输入），再从键盘输入一个数，判别是否在链表中，如果不在，则输出“NO“，否则，将它从链表中删除，并输出删除后的链表。
11、设有一个链表，（自己建立，数据从键盘输入），再从键盘输入一个数，判别是否在链表中，如果在输出“YSE”，否则，将它从插入到链头，并输出插入后的链表。
12、设有一个链表，（自己建立，数据从键盘输入），再从键盘输入一个数，判别是否在链表中，如果在输出“YSE”，否则，将它从插入到链尾，并输出插入后的链表。
13、编写栈的压栈push、弹栈pop函数，从键盘输入一组数据，逐个元素压入堆栈，然后再逐个从栈中弹出它们并输出。
14、编写栈的压栈push、弹栈pop函数，用它判别（）的匹配问题。
15、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树中序遍历的结果。
16、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树先序遍历的结果。
17、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树后序遍历的结果。
18、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树的总结点数。
19、按类似先序遍历结果输入一序列，建立一棵二叉树（算法6、4），输出二叉树叶子结点数。
数据结构上机题目
数据结构上机题目一、问题描述我们要实现一个简单的学生信息管理系统，该系统能够对学生的基本信息进行存储、查询、修改和删除操作。
请设计一个合适的数据结构和算法来实现这个学生信息管理系统。
二、设计思路1. 定义学生信息结构体首先，我们需要定义一个学生信息结构体，用来存储一个学生的基本信息，包括学号、姓名、年龄、性别等。
可以使用C语言中的结构体来实现，如下所示：```ctypedef struct{int id; // 学号char name[20]; // 姓名int age; // 年龄char gender[5]; // 性别} Student;```2. 学生信息存储和管理接下来，我们可以使用数组来存储学生信息。
可以定义一个全局数组来存储所有学生的信息，数组的每个元素都是一个学生信息结构体，数组的大小可以根据实际情况设定，这里假设最多存储100个学生的信息，代码如下：```c#define MAX_STUDENTS 100Student students[MAX_STUDENTS]; // 数组存储学生信息int numStudents = 0; // 学生数量```3. 学生信息操作函数接下来，我们可以定义一些函数来实现对学生信息的增删改查操作。
以下是几个常用操作的函数原型：```c// 添加学生信息void addStudent(Student s);// 根据学号查找学生信息Student* findStudentById(int id);// 修改学生信息void updateStudent(Student* s, char name[], int age, char gender[]);// 删除学生信息void deleteStudent(Student* s);// 输出所有学生信息void printAllStudents();```4. 学生信息操作函数的实现我们可以实现上述函数，具体实现细节如下所示：```cvoid addStudent(Student s) {if (numStudents < MAX_STUDENTS) {students[numStudents++] = s;} else {printf("学生信息已满，无法添加新学生！\n"); }}Student* findStudentById(int id) {for (int i = 0; i < numStudents; i++) {if (students[i].id == id) {return &students[i];}return NULL;}void updateStudent(Student* s, char name[], int age, char gender[]) { strcpy(s->name, name);s->age = age;strcpy(s->gender, gender);printf("学生信息修改成功！\n");}void deleteStudent(Student* s) {for (int i = 0; i < numStudents; i++) {if (&students[i] == s) {for (int j = i; j < numStudents - 1; j++) {students[j] = students[j + 1];}numStudents--;printf("学生信息删除成功！\n");return;}printf("未找到该学生信息！\n");}void printAllStudents() {printf("学生信息列表：\n");for (int i = 0; i < numStudents; i++) {printf("学号：%d 姓名：%s 年龄：%d 性别：%s\n", students[i].id, students[i].name, students[i].age, students[i].gender);}}```三、示例程序下面是一个简单的示例程序，演示了如何调用上述函数来实现学生信息的增删改查操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》上机作业
(黑色--必做；蓝色--选作)
线性表
1、某软件公司大约有30名员工，每名员工有姓名、工号、职务等属性，每年都有员工离
职和入职。
把所有员工按照顺序存储结构建立一个线性表，建立离职和入职函数，当有员工离职或入职时，修改线性表，并且打印最新的员工名单。
（动态分配存储，malloc，realoc）2、约瑟夫（Josephus）环问题：编号为1,2,3,…,n的n个人按顺时针方向围坐一圈，每
人持有一个密码（正整数）。
一开始任选一个正整数作为报数的上限值m，从第一个人开始按顺时针方向自1开始顺序报数,报到m时停止。
报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一人开始重新从1报数，如此下去，直到所有人全部出列为止。
建立n个人的单循环链表存储结构，运行结束后，输出依次出队的人的序号。
（必须用链表）
3、已知线性表中的元素以值递增有序排列，并以单链表作存储结构。
试写一高效的算法，
删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素），同时释放被删结点空间，并分析你的算法的时间复杂度（注意：mink和maxk是给定的两个参变量，他们的值可以和表中相同，也可以不同）
4、试写一个算法，对单链表实现就地逆置。
5、设有一个双向循环链表，每个结点中除有prior, data和next三个域外，还增设了一个访
问频度域freq。
在链表被起用之前，频度域freq的值均初始化为零，而每当对链表进行一次locate(L, x)的操作后，被访问的结点（即元素值等于x的结点）中的频度域freq的值便增1，同时调整链表中结点之间的次序，使其按访问频度非递减的次序顺序排列，以便始终保持被频繁访问的结点总是靠近表头结点。
试编写符合上述要求的locate操作的算法。
（注意：如果没有特别说明，链表均带头结点）
栈和队列
6、某商场有一个100个车位的停车场，当车位未满时，等待的车辆可以进入并计时；当车
位已满时，必须有车辆离开，等待的车辆才能进入；当车辆离开时计算停留的的时间，并且按照每小时1元收费。
汽车的输入信息格式可以是（进入/离开，车牌号，进入/离开时间），要求可以随时显示停车场内的车辆信息以及收费历史记录。
（选作，用指针轮询数组，有空位就入，利用时间函数计时）
7、某银行营业厅共有6个营业窗口，设有排队系统广播叫号，该银行的业务分为公积金、
银行卡、理财卡等三种。
公积金业务指定1号窗口，银行卡业务指定2、3、4号窗口，理财卡业务指定5、6号窗口。
但如果5、6号窗口全忙，而2、3、4号窗口有空闲时，理财卡业务也可以在空闲的2、3、4号窗口之一办理。
客户领号、业务完成可以作为输入信息，要求可以随时显示6个营业窗口的状态。
（复杂，选作）
8、4阶斐波那契序列如下：f0=f1=f2=0, f3=1,…,f i=f i-1+f i-2+f i-3+f i-4，
利用容量为k=4的循环队列，构造序列的前n+1项（f0, f1 , f2 ,… fn ），要求满足f n≤200而f n+1 >200。
9、八皇后问题：设8皇后问题的解为(x1, x2, x3, …,x8), 约束条件为：在8x8的棋盘上，
其中任意两个xi 和xj不能位于棋盘的同行、同列及同对角线。
要求用一位数组进行存储，输出所有可能的排列。
10、迷宫求解：用二维矩阵表示迷宫，自动生成或者直接输入迷宫的格局，确定迷宫是否能
走通，如果能走通，输出行走路线。
11、英国人格思里于1852年提出四色问题(four colour problem，亦称四色猜想），即在为一
平面或一球面的地图着色时，假定每一个国家在地图上是一个连通域，并且有相邻边界线的两个国家必须用不同的颜色，问是否只要四种颜色就可完成着色。
现在给定一张地图，要求对这张地图上的国家用不超过四种的颜色进行染色。
要求建立地图的邻接矩阵存储结构，输入国家的个数和相邻情况，输出每个国家的颜色代码。
数组与广义表
12、鞍点问题：若矩阵A中的某一元素A[i,j]是第i行中的最小值，而又是第j列中的最
大值，则称A[i,j]是矩阵A中的一个鞍点。
写出一个可以确定鞍点位置的程序。
13、稀疏矩阵转置：输入稀疏矩阵中每个元素的行号、列号、值，建立稀疏矩阵的三元组
存储结构，并将此矩阵转置，显示转置前后的三元组结构。
树和二叉树
以下问题要求统一在一个大程序里解决。
14、按先序遍历的扩展序列建立二叉树的存储结构
15、二叉树先序、中序、后序遍历的递归算法
16、二叉树中序遍历的非递归算法
17、二叉树层次遍历的非递归算法
18、求二叉树的深度(后序遍历)
19、建立树的存储结构
20、求树的深度
图
21、输入任意的一个网，用普里姆(Prim)算法构造最小生成树。
22、要求建立图的存储结构（邻接表或邻接矩阵），输入任意的一个图，显示图的深度优先
搜索遍历路径。
23、要求建立图的存储结构（邻接表或邻接矩阵），输入任意的一个图，显示图的广度优先
搜索遍历路径。
查找
24、设计一个读入一串整数构成一颗二叉排序树的程序，从二叉排序树中删除一个结点，使
该二叉树仍保持二叉排序树的特性。
25、设定哈希函数H(key) = key MOD 11 ( 表长=11 )，输入一组关键字序列，根据线性探测
再散列解决冲突的方法建立哈希表的存储结构，显示哈希表，任意输入关键字，判断是否在哈希表中。
排序
以下问题要求统一在一个大程序里解决。
26、折半插入排序
27、冒泡排序
28、快速排序
29、简单选择排序
30、归并排序
31、堆排序。