数据结构上机题
数据结构第五章 查找 答案
数据结构与算法上机作业第五章查找一、选择题1、若构造一棵具有n个结点的二叉排序树，在最坏情况下，其高度不超过 B 。
A. n/2B. nC. (n+1)/2D. n+12、分别以下列序列构造二叉排序数（二叉查找树），与用其他3个序列所构造的结果不同的是 C ：A. (100, 80, 90, 60, 120, 110, 130)B. (100, 120, 110, 130, 80, 60, 90)C. (100, 60, 80, 90, 120, 110, 130)D. (100, 80, 60, 90, 120, 130, 110)3、不可能生成下图所示的二叉排序树的关键字的序列是 A 。
A. 4 5 3 1 2B. 4 2 5 3 1C. 4 5 2 1 3D. 4 2 3 1 54、在二叉平衡树中插入一个结点造成了不平衡，设最低的不平衡点为A，并已知A的左孩子的平衡因子为0，右孩子的平衡因子为1，则应作 C 型调整使其平衡。
A. LLB. LRC. RLD. RR5、一棵高度为k的二叉平衡树，其每个非叶结点的平衡因子均为0，则该树共有 C 个结点。
A. 2k-1-1B. 2k-1+1C. 2k-1D. 2k+16、具有5层结点的平衡二叉树至少有 A 个结点。
A. 12B. 11C. 10D. 97、下面关于B-和B+树的叙述中，不正确的是 C 。
A. B-树和B+树都是平衡的多叉树B. B-树和B+树都可用于文件的索引结构C. B-树和B+树都能有效地支持顺序检索D. B-树和B+树都能有效地支持随机检索8、下列关于m阶B-树的说法错误的是 D 。
A. 根结点至多有m棵子树B. 所有叶子结点都在同一层次C. 非叶结点至少有m/2（m为偶数）或m/2+1(m为奇数)棵子树D. 根结点中的数据是有序的9、下面关于哈希查找的说法正确的是 C 。
A. 哈希函数构造得越复杂越好，因为这样随机性好，冲突小B. 除留余数法是所有哈希函数中最好的C. 不存在特别好与坏的哈希函数，要视情况而定D. 若需在哈希表中删去一个元素，不管用何种方法解决冲突都只要简单地将该元素删去即可10、与其他查找方法相比，散列查找法的特点是 C 。
全国计算机等级考试(2级)上机考试题库及解析004
（1）下列数据结构中，属于非线性结构的是（）。
A）循环队列B）带链队列C）二叉树D）带链栈（2）下列数据结构中，能够按照“先进后出”原则存取数据的是（）。
A）循环队列B）栈C）队列D）二叉树（3）对于循环队列，下列叙述中正确的是（）。
A）队头指针是固定不变的B）队头指针一定大于队尾指针C）队头指针一定小于队尾指针D）队头指针可以大于队尾指针，也可以小于队尾指针（4）算法的空间复杂度是指（）。
A）算法在执行过程中所需要的计算机存储空间B）算法所处理的数据量C）算法程序中的语句或指令条数D）算法在执行过程中所需要的临时工作单元数（5）软件设计中划分模块的一个准则是（）。
A）低内聚低耦合B）高内聚低耦合C）低内聚高耦合D）高内聚高耦合（6）下列选项中不属于结构化程序设计原则的是（）。
A）可封装B）自顶向下C）模块化D）逐步求精（7）软件详细设计产生的图如下：该图是（）。
A）N-S图B）PAD图C）程序流程图D）E-R图（8）数据库管理系统是（）。
A）操作系统的一部分B）在操作系统支持下的系统软件C）一种编译系统D）一种操作系统（9）在E-R图中，用来表示实体联系的图形是（）。
A）椭圆形B）矩形C）菱形D）三角形（10）有三个关系R，S和T如下：其中关系T由关系R和S通过某种操作得到，该操作为（）。
A）选择B）投影C）交D）并（11）下列符号中可以用做C++标识符的是（）。
A）_radiusB）foo~barC）elseD）3room（12）下列各组类型声明符中，含义相同的一组是（）。
A）unsigned long int和longB）signed short int和shortC）unsigned short和shortD）short int和int（13）必须用一对大括号括起来的程序段是（）。
A）switch语句中的case标号语句B）if语句的分支C）循环语句的循环体D）函数的函数体（14）语句int *p = &k；定义了指针p，与这个语句等效的语句序列是（）。
数据结构上机考试题目及要求
数据结构上机实验考试标准一、评分标准：1.根据考试完成情况，参考平时上机情况评定优、良、中、及格、不及格5个档。
2.成绩分布比例近似为：优15%、良30%、中30%、及格20%、不及格<10%二、评分原则：1.充分参考平时实验完成情况，结合如下原则给出成绩；2.只完成第一题，成绩为良以下成绩（中、及格），若平时上机情况很好，可以考虑良好；3.两道题都完成，成绩为良及以上（优、良），根据完成质量和完成时间给成绩；4.如未完成任何程序，则不及格（根据平时成绩将不及格率控制在10%以下）；三、监考要求：1.考试前，要求学生检查电脑是否工作正常，如果不正常及时解决，待所有考生均可正常考试后再发布试题。
2.平时上机完成的程序可以在考试过程直接调用，在考试开始前复制到硬盘当中，考试过程中可以看教材。
3.考试开始后向学生分发考题的电子文档，同时宣读试题，学生可以通过网络或磁盘拷贝试题。
4.考试开始十五分钟之后把网络断开，学生不得再使用任何形式的磁盘。
5.程序检查时，记录其完成时间和完成情况。
除检查执行情况外，还要求学生对代码进行简要讲解，核实其对代码的理解情况和设计思想，两项均合格方视为试题完成。
6.完成考试的学生须关闭电脑立刻离开考场，考试成绩由教务办统一公布，负责教师不在考试现场公布成绩。
数据结构上机实验考试题目（2011年12月23日）题目1.设C={a1,b1,a2,b2,…,a n,b n}为一线性表，采用带头结点的单链表hc（hc为C链表的头指针）存放，设计一个算法，将其拆分为两个线性表（它们都用带头结点的单链表存放），使得：A={a1,a2,…,a n}，B={b n,b n-1,…,b1}。
[例] C链表为：C={1，2，3，4，5，6，7，8，9，10｝拆分后的A、B链表如下：A={1，3，5，7，9}，B={10，8，6，4，2}。
要求：算法的空间复杂度为O（1）。
即利用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");}。
数据结构 上机实验题及题解
2013-03-08 上机实验题1.构建两个顺序表示的非空线性表LA和LB (数据元素为整型，其值自行确定)；2.从线性表LA中删除第i 个元素；3.将元素e插入到线性表LB中的第i个元素之后；4.假设LA中不含重复的元素 (LB同)，将线性表LA和LB合并，并输出结果，要求结果中不含重复的元素。
//构建两个顺序表（定义、初始化）//在一个顺序表中删除指定位置的元素//在一个顺序表中指定位置插入一个新元素//将两个线性表LA和LB进行合并//遍历LB, 如果其中的数据元素不在LA中，则将其插入LA，否则不予处理//打印线性表LA#define List_Init_Size 100#define LISTINCREMENT 10typedef int Status;typedef struct {int * elem;int length; // 当前长度int ListSize; // 当前分配的存储容量}SqList;Status Initialize_table (SqList &L) {// 初始化线性表int i, m, data;L.elem=(int *)malloc(List_Init_Size *sizeof(int));if (!L.elem) { // 为线性表分配空间printf("Overflow");return FAILURE; }L.ListSize=List_Init_Size; L.length=0;printf ("Please input the size of linear table (<=%d): "+ List_Init_Size);scanf_s("%d",&m);for (i=0;i<m;i++) { // 依次输入线性表的数据元素printf("Please input the NO.%d element : ", i+1);scanf_s("%d",&data);*(L.elem+i)=data;L.length++;}return SUCCESS;}Status ListDelete (SqList &L, int i, int &e) {// 从线性表中删除第i个元素，用e返回int *p, *q;if ((i<1) || (i>L.length)) //检查i值是否合法return -1;p=L.elem+i-1; // 找到删除位置e=*p;q=L.elem+L.length-1; //找到最后一个元素位置for (++p; p<=q; ++p) //数据元素前移*(p-1)=*p;--L.length; //修改表长return SUCCESS;}Status ListInsert(SqList &L, int i, int e) {// 在线性表中第i个位置后插入元素eint *p,*q;if (i<0 || i>L.length) return FAILURE;if (L.length >= L.ListSize){p=(int*)realloc(L.elem,(L.ListSize+ListIncrement)*sizeof(int));if (p==NULL) return FAILURE;L.elem=p;L.ListSize+=ListIncrement;}q=L.elem+i; //即在第i+1个位置上插入元素efor (p=L.elem+L.length-1;p>=q;--p)*(p+1)=*p;*q=e;++L.length; // 修改表长return SUCCESS;}Status MergeList (SqList &L1,SqList L2) {// 合并线性表L1和L2int i=0,k=L1.length;int ai;while (i < L2.length) { // 将第2个线性表中的元素// 根据合并规则加入到第1个线性表中ai = *(L2.elem + i);if (!ExistsIn(L1, ai))ListInsert(L1, k++, ai);++i;}return OK;}// end of functionStatus PrintSq (SqList L) {// 打印线性表的所有数据元素int i;printf("Allocated Memory Size=%d Length=%d ", L.ListSize, L.length);for (i=0;i<L.length;i++)printf("%d",L.elem[i]);printf ("\n");return OK;}Status main (void) {int result;SqList La, Lb;Initialize_table (La); // 初始化线性表Initialize_table (Lb);ListDelete (La, 3, result); // 删除元素ListInsert (Lb, 4, 35); // 插入元素MergeList (La, Lb); //合并线性表PrintSq (La); // 打印线性表free (La.elem); // 释放存储空间free (Lb.elem);return SUCCESS;}。
数据结构上机实验题
当涉及数据结构的上机实验题时，通常会涉及编程和算法的实践。
以下是一些可能的
上机实验题目：
1. 实现一个栈（Stack）数据结构，并编写基本的操作（入栈、出栈、获取栈顶元素等）。
2. 实现一个队列（Queue）数据结构，并编写基本的操作（入队、出队等）。
3. 实现一个链表（Linked List）数据结构，并编写插入、删除、查找等操作。
4. 实现一个二叉树（Binary Tree）数据结构，并编写遍历算法（前序、中序、后序遍历）。
5. 实现一个图（Graph）数据结构，并编写基本的图算法（深度优先搜索、广度优先搜索）。
6. 实现一个哈希表（Hash Table）数据结构，并编写插入、删除、查找等操作。
这些实验题目可以帮助学生加深对数据结构的理解，并通过编程实践来掌握数据结构
的基本操作和算法。
同时，这些实验也有助于提高学生的编程能力和解决问题的能力。
数据结构教程上机实验题
编写一个程序ALGO2-1.CPP,实现顺序表的各种基本运算，并在此基础上设计一个主程序完成如下功能：(1)初始化顺序表L(2)依次采用尾插法插入a,b,c,d,e元素(3)输出顺序表L:(4)输出顺序表L长度(5)判断顺序表L是否为空(6)输出顺序表L的第3个元素(7)输出元素a的位置(8)在第4个元素位置上插入f元素(9)输出顺序表L:(10)删除L的第3个元素(11)输出顺序表L:(12)释放顺序表L#include <stdio.h>#include <malloc.h>#define MaxSize 100typedefcharElemType;typedefstruct{ElemType data[MaxSize];int length;}SqList;void Init(SqList *&L){L = (SqList *)malloc(sizeof(SqList));L->length=0;}void CreateList(SqList *&L, ElemType source[],int n) {int i;for(i=0;i<n;i++){L->data[i]=source[i];}L->length=n;}void DisplayList(SqList* L){int i;for(i=0;i<L->length;i++){printf("%c\t",L->data[i]);}printf("\n");}void main(){SqList* h;char a[]={'a','b','c','d','e'};Init(h);printf("before Create length=%d\n",h->length);CreateList(h,a,5);DisplayList(h);printf("after Create length=%d\n",h->length);}。
数据结构课程课后习题集答案解析
《数据结构简明教程》练习题及参考答案练习题11. 单项选择题（1）线性结构中数据元素之间是（）关系。
A.一对多B.多对多C.多对一D.一对一答：D（2）数据结构中与所使用的计算机无关的是数据的（）结构。
A.存储B.物理C.逻辑D.物理和存储答：C（3）算法分析的目的是（）。
A.找出数据结构的合理性B.研究算法中的输入和输出的关系C.分析算法的效率以求改进D.分析算法的易懂性和文档性答：C（4）算法分析的两个主要方面是（）。
A.空间复杂性和时间复杂性B.正确性和简明性C.可读性和文档性D.数据复杂性和程序复杂性答：A（5）计算机算法指的是（）。
A.计算方法B. 排序方法C.求解问题的有限运算序列D.调度方法答：C（6）计算机算法必须具备输入、输出和（）等5个特性。
A.可行性、可移植性和可扩充性B.可行性、确定性和有穷性C.确定性、有穷性和稳定性D.易读性、稳定性和安全性答：B2. 填空题（1）数据结构包括数据的①、数据的②和数据的③这三个方面的内容。
答：①逻辑结构②存储结构③运算（2）数据结构按逻辑结构可分为两大类，它们分别是①和②。
答：①线性结构②非线性结构（3）数据结构被形式地定义为（D,R），其中D是①的有限集合，R是D上的②有限集合。
答：①数据元素②关系数据结构简明教程（4）在线性结构中，第一个结点 ① 前驱结点，其余每个结点有且只有1个前驱结点；最后一个结点 ② 后继结点，其余每个结点有且只有1个后继结点。
答：①没有 ②没有 （5）在树形结构中，树根结点没有 ① 结点，其余每个结点有且只有 ② 个前驱结点；叶子结点没有 ③ 结点，其余每个结点的后继结点数可以是 ④ 。
答：①前驱 ②1 ③后继 ④任意多个（6）在图形结构中，每个结点的前驱结点数和后继结点数可以是（ ）。
答：任意多个（7）数据的存储结构主要有四种，它们分别是 ① 、 ② 、 ③ 和 ④ 存储结构。
答：①顺序 ②链式 ③索引 ④哈希（8）一个算法的效率可分为 ① 效率和 ② 效率。
航空工业出版社《数据结构》课后题答案
// 输入字符存入 ch //输入未结束 //输入非回车字符
// 输入字符为‘#’ //栈顶元素出栈
// 输入字符为‘@’ //栈清空
//输入其他字符直接进栈
// 输入字符为回车，直接进栈 // 栈 S 中元素出栈进入栈 T
8
课后习题答案
{ Pop (&S, &e); Push (&T, e);
// 栈顶元素出栈 // 出栈元素压入栈 T
void InsertItem (DLinkList q, ElemType item)
{
DLinkList p; p = (DLinkList) malloc (sizeof (DNode));
p -> da=ta item; p -> pri= or q;
p -> next = q -> next; q -> ne= xt p;
{
int i = 0, k = 0;
char x, theta; SeqStack OPTR IniS tack (&OPTR); Push (&OPTR, '#');
//定义运算符栈 // 初始化运算符栈
//将'#'压入栈底
while (str1[i] != '#' || GetTop (OPTR) != '#')
//算符优先关系数组
//输入字符是否属于运算符集合，如果是，返回它在数组中的位置；否则，返回-1
int Isoperator (char ch)
{
int i;
for (i = 0; i < 7; i ++)
数据结构课程课后习题集答案解析
《数据结构简明教程》练习题及参考答案练习题11. 单项选择题（1）线性结构中数据元素之间是（）关系。
A.一对多B.多对多C.多对一D.一对一答：D（2）数据结构中与所使用的计算机无关的是数据的（）结构。
A.存储B.物理C.逻辑D.物理和存储答：C（3）算法分析的目的是（）。
A.找出数据结构的合理性B.研究算法中的输入和输出的关系C.分析算法的效率以求改进D.分析算法的易懂性和文档性答：C（4）算法分析的两个主要方面是（）。
A.空间复杂性和时间复杂性B.正确性和简明性C.可读性和文档性D.数据复杂性和程序复杂性答：A（5）计算机算法指的是（）。
A.计算方法B. 排序方法C.求解问题的有限运算序列D.调度方法答：C（6）计算机算法必须具备输入、输出和（）等5个特性。
A.可行性、可移植性和可扩充性B.可行性、确定性和有穷性C.确定性、有穷性和稳定性D.易读性、稳定性和安全性答：B2. 填空题（1）数据结构包括数据的①、数据的②和数据的③这三个方面的内容。
答：①逻辑结构②存储结构③运算（2）数据结构按逻辑结构可分为两大类，它们分别是①和②。
答：①线性结构②非线性结构（3）数据结构被形式地定义为（D,R），其中D是①的有限集合，R是D上的②有限集合。
答：①数据元素②关系数据结构简明教程（4）在线性结构中，第一个结点 ① 前驱结点，其余每个结点有且只有1个前驱结点；最后一个结点 ② 后继结点，其余每个结点有且只有1个后继结点。
答：①没有 ②没有 （5）在树形结构中，树根结点没有 ① 结点，其余每个结点有且只有 ② 个前驱结点；叶子结点没有 ③ 结点，其余每个结点的后继结点数可以是 ④ 。
答：①前驱 ②1 ③后继 ④任意多个（6）在图形结构中，每个结点的前驱结点数和后继结点数可以是（ ）。
答：任意多个（7）数据的存储结构主要有四种，它们分别是 ① 、 ② 、 ③ 和 ④ 存储结构。
答：①顺序 ②链式 ③索引 ④哈希（8）一个算法的效率可分为 ① 效率和 ② 效率。
数据结构上机考试(含答案)
《数据结构》上机练习题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.如果按由表尾至表头的次序输入数据元素，应如何建立顺序表。
{
Datatypestack[MAXNUM];
int top;
}SqStack;
/*初始化顺序栈函数*/
void InitStack(SqStack *p)
{q=(SqStack*)malloc(sizeof(SqStack) /*申请空间*/}
/*入栈函数*/
void Push(SqStack *p,Datatypex)
实现提示：
1.由于C语言的数组类型也有随机存取的特点，一维数组的机内表示就是顺序结构。因此，可用C语言的一维数组实现线性表的顺序存储。
在此，我们利用C语言的结构体类型定义顺序表：
#define MAXSIZE 1024
typedef int elemtype; /*线性表中存放整型元素*/
typedef struct
实验一线性表
实验目的：
1.熟悉C语言的上机环境，进一步掌握C语言的结构特点。
2.掌握线性表的顺序存储结构的定义及C语言实现。
3.掌握线性表的链式存储结构——单链表的定义及C语言实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
实验内容：
printf("输入源点v1 : ");
scanf("%d",&v1); /*输入源点V1 */
数据结构上机考试试题(C++语言版)
数据结构上机考试试题（C++语言版）考试要求：本次考试共列考核试题4大题，考生可以在所列4个考核试题中任选3个小题（即可能只属于2个大题），作为上机考核试题。
考核原则：所选题目在上机编程调试通过后即为考核通过。
监考教师依据学生编程及调试通过与否情况给予考核成绩。
考核成绩评分标准：所选3个题目全部编写出程序并调试通过：优所选3个题目全部编写出程序，但只有2个上机调试通过：良所选3个题目全部编写出程序，但只有1个上机调试通过：及格所选3个题目全部编写出程序但都没有上机调试通过，或没有编写出全部程序：不及格。
考核时间：2小时。
考核试题：1、建立一个顺序方式存储的线性表，向表中输入若干元素后进行以下操作：（1）向线性表的表头、表尾或合适位置插入元素（2）对线性表按升序或降序输出2、建立一个动态链接方式存储的线性表，向表中输入若干元素后进行以下操作：（1）从单链表中查找指定元素（2）返回单链表中指定序号的结点值3、建立一个动态链接结构存储的二叉树，向这棵二叉树进行以下操作：（1）按任中序遍历次序输出二叉树中的所有结点（2）求二叉树的叶子数4、编写一个对整型数组A[n+1]中的A[1]至A[n]元素进行选择排序的算法，使得首先从待排序区间中选择出一个最大值并同最后一个元素交换，再从待排序区间中选择出一个最小值并同最第一个元素交换，反复进行直到待排序区间中元素的个数不超过1为止。
#include<iomanip.h>#include<stdlib.h>#include"linearlist1.h"//初始化线性表void InitList(LinearList& L, int ms){L.list=new ElemType[ms];if(!L.list) {cerr<<"Memory allocation failure!"<<endl;exit(1);}L.size=0;L.MaxSize=ms;}//清空线性表void ClearList(LinearList& L){L.size=0;}//求线性表长度int ListSize(LinearList& L){return L.size;}//检查线性表是否为空bool ListEmpty(LinearList& L){return L.size==0;}//检查线性表是否为满bool ListFull(LinearList& L){return L.size==L.MaxSize;}//遍历线性表void TraverList(LinearList& L){for(int i=0; i<L.size; i++) cout<<L.list[i]<<' ';cout<<endl;}//从线性表中查找元素bool FindList(LinearList& L, ElemType& item) {for(int i=0; i<L.size; i++)if(L.list[i]==item) {item=L.list[i];return true;}return false;}//更新线性表中的给定元素bool UpdateList(LinearList& L, const ElemType& item){for(int i=0; i<L.size; i++)if(L.list[i]==item) {L.list[i]=item;return true;}return false;}//向线性表的表头、表尾或合适位置插入元素bool InsertList(LinearList& L, const ElemType& item, int mark) {if(ListFull(L)) return false;if(mark>0) {for(int i=L.size-1; i>=0; i--)L.list[i+1]=L.list[i];L.list[0]=item;}else if(mark<0) L.list[L.size]=item;else {for(int i=0; i<L.size; i++)if(item<L.list[i]) break;for(int j=L.size-1; j>=i; j--)L.list[j+1]=L.list[j];L.list[i]=item;}L.size++;return true;}//从线性表中删除表头、表尾或等于给定值的元素bool DeleteList(LinearList& L, ElemType& item, int mark){if(ListEmpty(L)) return false;if(mark>0) {item=L.list[0];for(int i=1; i<L.size; i++)L.list[i-1]=L.list[i];}else if(mark<0) item=L.list[L.size-1];else { for(int i=0; i<L.size; i++)if(L.list[i]==item) break;if(i>=L.size)return false;else item=L.list[i];for(int j=i+1; j<L.size; j++)L.list[j-1]=L.list[j];}L.size--;return true;}//对线性表按升序或降序输出void OrderOutputList(LinearList& L, int mark){int* b=new int[L.size];int i,k;for(i=0; i<L.size; i++) b[i]=i;for(i=1; i<L.size; i++) {k=i-1;for(int j=i; j<L.size; j++) {if(mark==1 && L.list[b[j]]<L.list[b[k]]) k=j;if(mark!=1 && L.list[b[k]]<L.list[b[j]]) k=j;}if(k!=i-1) {int x=b[i-1]; b[i-1]=b[k]; b[k]=x;} }for(i=0; i<L.size; i++)cout<<L.list[b[i]]<<' ';cout<<endl;}#include<iomanip.h>const int ML=10;#include"linearlist1.h"//主文件listmain1.cppvoid main(){LinearList a;InitList(a,ML);int i;ElemType x;//依次向线性表a表尾插入5个整数元素cout<<"从键盘输入5个整数:";for(i=0; i<5; i++) {cin>>x;InsertList(a,x,-1);}//依次向线性表a表头插入2个整数元素cout<<"从键盘输入2个整数:";cin>>x; InsertList(a,x,1);cin>>x; InsertList(a,x,1);//按不同次序遍历输出线性表aTraverList(a);OrderOutputList(a,1);OrderOutputList(a,0);//把线性表a中的所有元素依次有序插入到一个新线性表b中"LinearList b;InitList(b,ML);for(i=0; i<a.size; i++)InsertList(b, a.list[i], 0);//输出线性表bTraverList(b);//从线性表a中分别删除表头、表尾、给定值元素if(DeleteList(a,x,1)) cout<<"Delete success!"<<endl;else cout<<"Delete fail!"<<endl;if(DeleteList(a,x,-1)) cout<<"Delete success!"<<endl;else cout<<"Delete fail!"<<endl;cout<<"从键盘上输入一个待删除的整数:";cin>>x;if(DeleteList(a,x,0)) cout<<"Delete success!"<<endl;else cout<<"Delete fail!"<<endl;//输出线性表aTraverList(a);}。
数据结构上机实验题
数据结构上机实验题数据结构实验⼀线性表270。
实验⽬的：1.熟悉C语⾔的上机环境，进⼀步掌握C语⾔的结构特点。
2.掌握线性表的顺序存储结构的定义及C语⾔实现。
3.掌握线性表的链式存储结构——单链表的定义及C语⾔实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
实验内容：1.顺序线性表的建⽴、插⼊及删除。
2.链式线性表的建⽴、插⼊及删除。
实验步骤：1.建⽴含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利⽤前⾯的实验先建⽴⼀个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插⼊元素68。
3.建⽴⼀个带头结点的单链表，结点的值域为整型数据。
要求将⽤户输⼊的数据按尾插⼊法来建⽴相应单链表。
实现提⽰：1.由于C语⾔的数组类型也有随机存取的特点，⼀维数组的机内表⽰就是顺序结构。
因此，可⽤C语⾔的⼀维数组实现线性表的顺序存储。
在此，我们利⽤C语⾔的结构体类型定义顺序表：#define MAXSIZE 1024-可编辑修改-typedef int elemtype; /* 线性表中存放整型元素*/typedef struct{elemtype vec[MAXSIZE];int len; /* 顺序表的长度*/}sequenlist;将此结构定义放在⼀个头⽂件sqlist.h⾥，可避免在后⾯的参考程序中代码重复书写，另外在该头⽂件⾥给出顺序表的建⽴及常量的定义。
2. 注意如何取到第i个元素，在插⼊过程中注意溢出情况以及数组的下标与位序（顺序表中元素的次序）的区别。
3.单链表的结点结构除数据域外，还含有⼀个指针域。
⽤C语⾔描述结点结构如下：typedef int elemtype;typedef struct node{elemtype data; //数据域struct node *next; //指针域}linklist;注意结点的建⽴⽅法及构造新结点时指针的变化。
吉林大学数据结构第三次上机实验题目
第三次上机
验证试验（必作题）：
题目：二叉树相关算法的实验验证
[实验目的]
验证二叉树的链接存储结构及其上的基本操作。
[实验内容及要求]
1、定义链接存储的二叉树类。
2、实验验证如下算法的正确性、各种功能及指标：
1）创建一棵二叉树，并对其初始化；
2）先根、中根、后根遍历二叉树；
3）在二叉树中搜索给定结点的父结点；
4）搜索二叉树中符合数据域条件的结点；
3、由教师随机指定树结构，测试上述功能；
设计实验（选作题）：
题目：判别给定二叉树是否为完全二叉树。
[实验目的]
在掌握二叉树的链接存储及基本操作的基础上，设计解决问题的算法。
[实验内容及要求]
设计算法判别给定二叉树t是否为完全二叉树；实现链接存储的二叉树类。
数据结构上机实验(两次共五题).
数据结构上机实验（两次共五题）
1、约瑟夫环：将编号为1，2，…，n的n个人按顺时针方向围坐一圈，每人持
有一个密码（正整数）。
一开始任选一个正整数作为报数上限值m，从第一个开始按顺时针方向自1开始报数，报到m时停止报数。
报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。
试设计一个程序求出出列顺序。
设m 的初值为20，密码为：3，1，7，2，4，8，4。
2、编一程序：①建立一个数据域为1至10的带头结点的链表；
②将此链表就地逆转。
3、编写构造Huffman树和Huffman编码的程序。
已知：字符a，b，c，d，e，f，g的权值分别为{4，10，8，5，3，1，2}
4、编一程序算出教材中图7.30（p185）的关键路径
5、一程序实现堆排序。
已知输入关键字序列为：49，38，65，97，76，13，27，48
要求输出每趟排序的结果。
中大实践考核数据结构试题和答案(上机考试)
数据结构样题1、已知整数a、b，假设函数succ(x)=x+1、pred(x)=x-1，不许直接用“＋”、“－”运算符号，也不许用循环语句，只能利用函数succ( )和pred( )，试编写计算a+b，a-b的递归函数add(a,b)，sub(a,b)，并在主程序中验证函娄的正确性。
#include "stdio.h"#include "conio.h"int succ(int x){return x+1;}int pred(int x){return x-1;}int add(int a,int b){if(b==0) return a;if(b>0) return succ(add(a,pred(b)));else return pred(add(a,succ(b)));}int sub(int a,int b){if(b==0) return a;if(b>0) return pred(sub(a,pred(b)));else return succ(sub(a,succ(b)));}void main(){int k,a,b;clrscr();printf("\n Please input a b: ");scanf("%d%d",&a,&b);printf("\n a+b=%d",a+b);printf("\n a-b=%d",a-b);printf("\n add(a,b)=%d",add(a,b));printf("\n sub(a,b)=%d",sub(a,b));if((a+b==add(a,b))&&(a-b==sub(a,b)))printf("\n It's right! ");else printf("\n It's wrong! \n\n");}样题2 试编写一个求解Josephus问题的函数。
华南农业大学数据结构上机答案实验
华南农业大学数据结构上机答案实验8583 顺序栈的基本操作时间限制:1000MS 内存限制:1000K提交次数:530 通过次数:212题型: 编程题语言: 无限制Description创建一个空的顺序栈，并实现栈的入栈、出栈、返回栈的长度、返回栈顶元素、栈的遍历等基本算法。
请将下#include<malloc.h>#include<stdio.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100 // 存储空间初始分配量#define STACKINCREMENT 10 // 存储空间分配增量typedef int SElemType; // 定义栈元素类型typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK 等struct SqStack{SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL SElemType *top; // 栈顶指针int stacksize; // 当前已分配的存储空间，以元素为单位}; // 顺序栈Status InitStack(SqStack &S){// 构造一个空栈S，该栈预定义大小为STACK_INIT_SIZE// 请补全代码S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base) return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,SElemType e){// 在栈S中插入元素e为新的栈顶元素// 请补全代码if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SEl emType));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR// 请补全代码if(S.top==S.base) return ERROR;e=*--S.top;return OK;}Status GetTop(SqStack S,SElemType &e){// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR // 请补全代码if(S.top==S.base) return ERROR;e=*(S.top-1);return OK;}int StackLength(SqStack S){// 返回栈S的元素个数// 请补全代码return S.top-S.base;}Status StackTraverse(SqStack S){// 从栈顶到栈底依次输出栈中的每个元素SElemType *p = (SElemType *)malloc(sizeof(SElemType));p = S.top ; //请填空if(S.top==S.base)printf("The Stack is Empty!"); //请填空else{printf("The Stack is: ");p--;while(p>=S.base) //请填空{printf("%d ", *p);p--; //请填空}}printf("\n");return OK;}int main(){int a;SqStack S;SElemType x, e;if(InitStack(S)) // 判断顺序表是否创建成功，请填空{printf("A Stack Has Created.\n");}while(1){printf("1:Push \n2:Pop \n3:Get the Top \n4:Return the Length of the Stack\n5:Load the Stack\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d", &x);if(!Push(S,x)) printf("Push Error!\n"); // 判断Push是否合法，请填空else printf("The Element %d is Successfully Pushed!\n", x); break;case 2: if(!Pop(S,e)) printf("Pop Error!\n"); // 判断Pop是否合法，请填空else printf("The Element %d is Successfully Poped!\n", e); break;case 3: if(!GetTop(S,e))printf("Get Top Error!\n"); // 判断Get Top 是否合法，请填空else printf("The Top Element is %d!\n", e);break;case 4: printf("The Length of the Stack is %d!\n",StackLength(S)); //请填空break;case 5: StackTraverse(S); //请填空break;case 0: return 1;}}}8584 循环队列的基本操作时间限制:1000MS 内存限制:1000K提交次数:366 通过次数:157题型: 编程题语言: 无限制Description创建一个空的循环队列，并实现入队、出队、返回队列的长度、返回队头元素、队列的遍历等基本算法。
数据结构(C语言版)习题及答案第四章
数据结构(C语言版)习题及答案第四章习题4.1选择题1、空串与空格串是（B）。
A、相同B、不相同Ｃ、不能确定2、串是一种特殊的线性表，其特殊性体现在（B）。
A、可以顺序存储B、数据元素是一个字符C、可以链式存储D、数据元素可以是多个字符3、设有两个串p和q，求q在p中首次出现的位置的操作是（B）。
A、连接B、模式匹配C、求子串D、求串长4、设串1=“ABCDEFG”，2=“PQRST”函数trconcat（，t）返回和t串的连接串，trub（，i，j）返回串中从第i个字符开始的、由连续j 个字符组成的子串。
trlength()返回串的长度。
则trconcat（trub（1，2，trlength（2）），trub（1，trlength（2），2））的结果串是（D）。
A、BCDEFB、BCDEFGC、BCPQRSTD、BCDEFEF5、若串=“oftware”，其子串个数是（B）。
A、8B、37C、36D、94.2简答题1、简述空串与空格串、主串与子串、串名与串值每对术语的区别？答：空串是指长度为0的串，即没有任何字符的串。
空格串是指由一个或多个空格组成的串，长度不为0。
子串是指由串中任意个连续字符组成的子序列，包含子串的串称为主串。
串名是串的一个名称，不指组成串的字符序列。
串值是指组成串的若干个字符序列，即双引号中的内容。
2、两个字符串相等的充要条件是什么？答：条件一是两个串的长度必须相等条件二是串中各个对应位置上的字符都相等。
3、串有哪几种存储结构？答：有三种存储结构，分别为：顺序存储、链式存储和索引存储。
4、已知两个串：1=”fgcdbcabcadr”,2=”abc”,试求两个串的长度，判断串2是否是串1的子串，并指出串2在串1中的位置。
答：（1）串1的长度为14，串2的长度为3。
（2）串2是串1的子串，在串2中的位置为9。
5、已知：1=〃I’matudent〃，2=〃tudent〃，3=〃teacher〃，试求下列各操作的结果：trlength(1)；答：13trconcat(2,3)；答：”tudentteachar”trdelub(1,4,10)；答：I’m6、设1=”AB”，2=”ABCD”，3=”EFGHIJK，试画出它们在各种存储结构下的结构图。
上海交大2012年数据结构上机考试题目
只允许用iostream 、fstream、cstdio运行时间1s 内存：32M1.Ordered FractionsConsider the set of all reduced fractions between 0 and 1 inclusive with denominators less than or equal to N.Here is the set when N = 5:0/1 1/5 1/4 1/3 2/5 1/2 3/5 2/3 3/4 4/5 1/1Write a program that, given an integer N between 1 and 160 inclusive, prints the fractions in order of increasing magnitude.PROGRAM NAME: frac.cppINPUT FORMATOne line with a single integer N.SAMPLE INPUT (file frac.in)5OUTPUT FORMATOne fraction per line, sorted in order of magnitude.SAMPLE OUTPUT (file frac.out)0/11/51/41/32/51/23/52/33/44/51/1给定N个整数集合（S[1],S[2],…,S[N]）及M个集合操作，编写程序计算这些操作执行后N 个集合的值。
一个集合操作是一个三元组（k,x,y），其中k表示对集合S[x]和S[y]所进行的操作。
-当k=1时，更新S[x]的值为union(S[x],S[y])-当k=2时，更新S[x]的值为insersect(S[x],S[y])-当k=3时，更新S[x]的值为complement(S[x],S[y])对于两个集合A和B，我们如下定义三种运算：-union(A,B)中的元素可以在A中，或在B中，或同时在A和B中-intersect(A,B)中的元素既在A中也在B中-complement(A,B)中的元素在B中但不在A中程序文件名：set.cpp输入格式第1行是两个正整数N和M第2行到第N+1行定义了N个集合最初的值第i行（2<=i<=N+1）以一个非负整数c开始，接下来是c个互不相同的非负整数a[1]，a[2],...,a[c],表示S[i]={a[1],a[2],...,a[c]}第N+2行到第M+N+1行定义了M个集合操作第j行(N+2<=j<=M+N+1)包含三个正整数k、x和y输入中所有整数都是小于1000,30%的测试数据中的整数都小于300样例输入（文件set.in）3 35 10 20 30 40 503 60 40 203 10 20 302 3 23 3 21 1 3输出格式输出N行，其中第i 行为集合S[i]的大小。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include <stdio.h>#include <iostream.h>#include <malloc.h>#include <stdlib.h>#include <string.h>#define null 0#define M 100//typedef int Elemtype;这里定义了却没用，可见思维不连惯struct Lnode{// int num;char data;struct Lnode *next;};int lenth(struct Lnode **L){int n=0;struct Lnode *t;t=*L;while(t!=null){n++;t=t-> next;}return n;}/*int lenth1(char r[]){int n=0;n=sizeof(r);return n-1;}*/void creat(struct Lnode**L){*L=null;}//void insert(struct Lnode**L,int n, char d)//从功能化分上，这个函数不需要知道现在插入第几个字符//困为你init函数中是先对一个串的字符进行了排序，所以//这里直接插入链表的尾部就行了void insert(struct Lnode**L, char d){struct Lnode *t1,*t2;int j=1;t1=(struct Lnode*)malloc(sizeof(struct Lnode));t1-> data=d;t1-> next=NULL;if(*L==NULL){*L=t1;return;}t2=*L;while(t2-> next!=NULL){t2=t2-> next;}t2-> next=t1;/*if(n==1){t1-> next=t2;*L=t1;}else{while(j <n-1&&t2-> next!=null){t2=t2-> next;j++;}if(j==n-1){t1-> next=t2-> next;t2-> next=t1;}else{cout < < "Insert error! ";}}*/}/*显示链表*/void display(struct Lnode **L){struct Lnode *t;t=*L;if(t==null){cout << "The link is null! ";}else{for(;t!=null;){cout <<t-> data;t=t-> next;}}cout << "\n ";}/* 初始化和排序*/void init(struct Lnode**L,int n,char str[]) {int i,j,k,x=0,p=0;char ti,d[100];//,r[100]。
//struct Lnode*t;for(i=0;i <=n-1;i++){d[i]=str[i];}for(j=0;j <n-1;j++)for(k=j+1;k <=n-1;k++){if(int(d[j])> int(d[k])){ti=d[j];d[j]=d[k];d[k]=ti;//cout < <d[j] < <ti < <d[k] < <endl;}}/*for(j=0;j <n-1;j++)这两个for块是想去掉相同的字符吧？因为前面已排过序，就不需要两个for循环了,直接比较一下这个字符和刚才插入链表的是否一样，一样就不再插入就行了。
for(k=j+1;k <=n-1;k++){if(d[j]==d[k]){x++;d[j]=d[k];cout < < "123 ";cout < <d[k];for(int m=k;m <n-1;m++){d[m]=d[m+1];}n--;}} */creat(&*L);//for(int h=1;h <(n;h++)//{// insert(&*L,h,d[h]);//}if(n> 0)insert(&*L,d[0]);//第一个字符是要插入的for(int h=1;h <n;h++){if(d[h] != d[h-1])insert(&*L,d[h]);}// cout < < "The data of the linktable is: ";// display(&*L);}/*删除指定位置的节点*/void delet(struct Lnode **L,int n){int i=1;struct Lnode *t1,*t2;t1=*L;if(n==1)t2=t1;*L=t1-> next;}else{while(i <n-1&&t1-> next!=null){t1=t1-> next;i++;}if(t1-> next!=null&&i==n-1){t2=t1-> next;t1-> next=t2-> next;}else{cout << "Delete error!\n ";}}if(t2==null){free(t2);}}/*返回指定节点的值*/char get(struct Lnode **L,int n){int i=1;struct Lnode *t;t=*L;while (i <n&&t!=null){t=t-> next;i++;}if(t!=null){return(t-> data);}elsecout << "The Lnode haven 't find !\n ";}return(t-> data);}void copy(struct Lnode **L1,struct Lnode **L2 ){struct Lnode *t=*L1;//int i,len;//char t;//len=lenth(&*L1);creat(&*L2);//for(i=1;i <=len;i++)//{// t=get(&*L1,i);//insert(&*L2,i,t);//}while(t != NULL){insert(&*L2,t-> data);t=t-> next;}}/*求交集*/void intersection(struct Lnode **L1,struct Lnode **L2,struct Lnode **L3) {/*int i,j,k=1;*/struct Lnode *t1,*t2;t1=*L1;t2=*L2;creat(&*L3);/* for(i=1;i <=lenth(&*L1);i++)//用数组的思维操作链表，毙{for(j=1;j <=lenth(&*L2);j++){if(t1-> data==t2-> data){//insert(&*L3,k,t1-> data);k++;}t2=t2-> next;}t1=t1-> next;t2=*L2;}*/while(t1 != NULL && t2 != NULL){if(t1-> data==t2-> data ){insert(&*L3,t1-> data);t1=t1-> next;t2=t2-> next;}else if(t1-> data <t2-> data){t1=t1-> next;}else//t1-> data> t2-> data{t2=t2-> next;}}}/*求并集*/void unionset(struct Lnode **L1,struct Lnode **L2,struct Lnode **L3) {/*int i,j,k;*/struct Lnode *t1,*t2;creat(&*L3);//copy(&*L1,&*L3);t1=*L1;t2=*L2;while(t1 != NULL && t2 != NULL){if( t1-> data==t2-> data ){insert(&*L3,t1-> data);t1=t1-> next;t2=t2-> next;}else if( t1-> data <t2-> data){insert(&*L3,t1-> data);t1=t1-> next;}else//t1-> data> t2-> data{insert(&*L3,t2-> data);t2=t2-> next;}}if(t1==NULL){while(t2!=NULL){insert(&*L3,t2-> data);t2=t2-> next;}}else//(t2==NULL){while(t1!=NULL){insert(&*L3,t1-> data);t1=t1-> next;}}}/*求差集*/void diffrenceset(struct Lnode **L1,struct Lnode **L2,struct Lnode **L3) {struct Lnode *t1=*L1;struct Lnode *t2=*L2;creat(&*L3);while(t1 != NULL ){if(t2==NULL || t1-> data <t2-> data ){insert(&*L3,t1-> data);t1=t1-> next;}else if(t1-> data> t2-> data)//t2!=NULL{t2=t2-> next;}else//t1-> data==t2-> data{t1=t1-> next;t2=t2-> next;}}}void main(){int len1=0,len2=0;//char r[100],r1[100];char r1[100],r2[100];//cin> > r1[100];cin>> r1;int i=0;while(r1[i++]!= '\0 '){len1++;}cin>> r2;int x=0;while(r2[x++]!= '\0 '){len2++;}// cout < < "123 ";static struct Lnode *head1,*head2,*head3,*head4,*head5,*head6;init(&head1,len1,r1);cout << "Setl: ";display(&head1);// cout < < "Please input the lenth of the first linktable! ";init(&head2,len2,r2);cout << "Set2: ";display(&head2);intersection(&head1,&head2,&head3);cout << "Setl∩Set2: ";display(&head3);unionset(&head1,&head2,&head4);cout << "Setl∪Set2: ";display(&head4);diffrenceset(&head1,&head2,&head5);cout << "Setl-Set2: ";display(&head5);}。