数据结构与算法上机作业
数据结构第五章 查找 答案
数据结构与算法上机作业第五章查找一、选择题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 。
数据结构上机考试(含答案)
数据结构》上机练习题1、设有两个有序序列, 利用归并排序将它们排成有序表,并输出。
2、设有一有序序列, 从键盘输入一个数, 判别是否在序列中,如果在输出“YSE”;否则, 将它插入到序列中使它仍然有序, 并输出排序后的序列。
3、设有一有序序列,从键盘输入一个数,判别是否在序列中,如果不在,则输出“NO”,否则,将它从序列中删除它, 并输出删除后的序列。
4、从键盘输入一组任意数据,建立一个有序链表, 并从链头开始输出该链,使输出结果是有序的。
5、从键盘输入一组任意数据,建立一个包含所有输入数据的单向循环链表, 并从链表的任意开始, 依次输出该链表中的所有结点。
10、设有一个链表,（自己建立, 数据从键盘输入）, 再从键盘输入一个数,判别是否在链表中, 如果不在, 则输出“ NO“,否则, 将它从链表中删除, 并输出删除后的链表。
11、设有一个链表,（自己建立, 数据从键盘输入）, 再从键盘输入一个数,判别是否在链表中,如果在输出“ YSE”,否则,将它从插入到链头,并输出插入后的链表。
12、设有一个链表,（自己建立, 数据从键盘输入）, 再从键盘输入一个数,判别是否在链表中,如果在输出“ YSE”,否则,将它从插入到链尾,并输出插入后的链表。
13、编写栈的压栈push、弹栈pop函数, 从键盘输入一组数据,逐个元素压入堆栈, 然后再逐个从栈中弹出它们并输出14、编写栈的压栈 push 、弹栈 pop 函数,用它判别() 的匹配问题 树中序遍历的结果。
树先序遍历的结果。
树后序遍历的结果。
树的总结点数。
树叶子结点数。
叉树的高度。
21、给出一个无向图的邻接矩阵 , 输出各个顶点的度。
22、给出一个有向图的邻接矩阵 , 输出各个顶点的入度与出度。
23、输入一个有序序列 , 利用折半查找来查找一个数是否在序列中 出其位置 ,否则输出“ NO ”。
24、用插入排序方法对一组数据进行排序 , 并输出每趟排序的结果。
2015级软件工程专业《数据结构与算法》上机题目 (1)
1868: 2015级软件班《数据结构与算法》实验1：线性表的应用（6学时）Description输入一个字符串，按照字符串的输入顺序创建一个线性表A。
线性表A中包含有三类字符：数字字符、字母字符、其他字符。
试写一个函数实现对线性表A的拆分，使得线性表A、B、C分别各自指向同一类字符。
要求如下：（1）在拆分时，必须使用原表A的结点空间，不能额外创建新结点。
（2）拆分后，原表A指向数字字符，且其内容的前后次序与原表中的前后次序必须一致，新的表B指向字母字符，新的表C指向其他字符。
其中要求删除B中的重复结点（如“abbcdexec”，变为“abcdex”）。
（3）判断拆分后的表A是否是中心对称的（如123321或12321都是中心对称的），若是，则输出1，否则输出0。
Input输入格式要求：输入一行字符串，可以带空格，并以‘？’做为输入结束标志，中间不能输入’？‘。
字符串长度不做限制。
如可以输入：1aabccd2e3f(!3c<2g1>？Output输出格式要求：前3行分别输出表A、B、C的内容（若某个表为空表，则相应行输出-1），第4行输出表A是否为对称的标志。
如输出：123321 (拆分后表A的内容)abcdef g (拆分后表B的内容)(!<> (拆分后表C的内容)1 (拆分后表A是中心对称的)Sampl e Input1aabccd2e3f(!3c<2g1>?Sampl e Output123321abcdefg(!<>1HINT为了方便判断线性表是否为中心对称的，可以使用双向链表结构（但不是必须的）。
1869: 2015级软件工程专业《数据结构与算法》实验2：表达式求值（9学时~12学时）Description表达式求值是计算机实现程序设计语言中的基本问题之一，也是栈应用的一个典型例子，通过本实验，对输入的一个表达式进行求值。
[实验目的]掌握栈的应用；掌握算符优先表达式求值的算法；掌握字符串处理和数值的转换。
数据结构上机作业题
数据结构上机实验题：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.编写递归函数算法，计算二叉树中叶子结点的数目。
数据结构上机实验
目录第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、在一棵树中,如果结点A有3个兄弟,B就是A得双亲,则B得度为 DA、1B、2C、3D、42、深度为h得完全二叉树至少有 D 个结点,至多有 B 个结点A、2hB、2h-1C、2h+1D、2h-13、具有n个结点得满二叉树有 C 个叶结点。
A、n/2B、(n-1)/2C、(n+1)/2D、n/2+14、一棵具有25个叶结点得完全二叉树最多有 C 个结点。
A、48B、49C、50D、515、已知二叉树得先根遍历序列就是ABCDEF,中根遍历序列就是CBAEDF,则后根遍历序列就是 A 。
A、CBEFDAB、FEDCBAC、CBEDFAD、不定6、具有10个叶结点得二叉树中有 B 个度为2得结点。
A、8B、9C、10D、117、一棵非空二叉树得先序遍历序列与后序遍历序列正好相反,则该二叉树一定满足B 。
A、所有非叶结点均无左孩子B、所有非叶结点均无右孩子C、只有一个叶子结点D、A与B同时成立8、在线索二叉树中,t所指结点没有左子树得充要条件就是 D 。
A、t->left=NULLB、t->ltag=TRUEC、t->ltag=TRUE且t->left=NULLD、以上都不对9、n个结点得线索二叉树上含有得线索数为 C 。
A、2nB、n-1C、n+1D、n10、二叉树按照某种顺序线索化后,任一结点都有指向其前驱与后继得线索,这种说法 B 。
A、正确B、错误C、不确定D、都有可能11、具有n(n>1)个结点得完全二叉树中,结点i(2i>n)得左孩子结点就是 D 。
A、2iB、2i+1C、2i-1D、不存在12、具有64个结点得完全二叉树得深度为 C 。
A、5B、6C、7D、813、将一颗有100个结点得完全二叉树从上到下、从左到右一次对结点进行编号,根结点得编号为1,则编号为45得结点得右孩子得编号为 D 。
A、46B、47C、90D、9114、在结点数为n得堆中插入一个结点时,复杂度为 C 。
数据结构上机题目
数据结构上机题目第二次:sqlist-顺序表2.11 设顺序表va中的数据元素递增有序。
试写一算法，将x插入到顺序表的适当位置上，以保持该表的有序性。
2.21 试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表(a1,a2,…,an)逆置为(an,an-1,…,a1)。
第三次:LinkList-单链表2.15已知指针ha和hb分别指向两个单链表的头结点，并且已知两个链表的长度分别为m和n。
试写一算法将这两个链表连接在一起(即令其中一个表的首元结点连在另一个表的最后一个结点之后)，假设指针hc 指向连接后的链表的头结点，并要求算法以尽可能短的时间完成连接运算。
请分析你的算法的时间复杂度。
2.19已知线性表中的元素以值递增有序排列，并以单链表作存储结构。
试写一高效的算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素），同时释放被删结点空间，并分析你的算法的时间复杂度（注意，mink和maxk是给定的两个参变量，它们的值可以和表中的元素相同，也可以不同）。
第四次:cdLinkList-循环链表2.33已知由一个线性链表表示的线性表中含有三类字符的数据元素（如：字母字符、数字字符和其他字符），试编写算法将该线性表分割为三个循环链表，其中每个循环链表表示的线性表中均只含一类字符。
2.38设有一个双向循环链表，每个结点中除有prior，data和next 三个域外，还增设了一个访问频度域freq。
在链表被起用之前，频度域freq的值均初始化为零，而每当对链表进行一次LOCATE(L,x)的操作后，被访问的结点（即元素值等于x的结点）中的频度域freq的值便增1，同时调整链表中结点之间的次序，使其按访问频度非递增的次序顺序排列，以便始终保持被频繁访问的结点总是靠近表头结点。
试编写符合上述要求的LOCATE操作的算法。
第五次:outqueue-实验1线性表实验目的熟悉线性表的基本运算在顺序存储结构和链式存储结构上的实现，其中重点熟悉链表的各种操作。
16秋北理工《数据结构与算法》在线作业
北理工《数据结构与算法》在线作业一、单选题（共40 道试题，共100 分。
）1. 下列说法正确的是()A. 堆栈是在两端操作、先进后出的线性表B. 堆栈是在一端操作、先进后出的线性表C. 队列是在一端操作、先进先出的线性表D. 队列是在两端操作、后进先出的线性表正确答案：2. 判定一个队列Q(最多元素为m0)为满队列的条件是()A. rear-front= = m0B. rear-front-1= =m0C. front= =rearD. front= =rear+1正确答案：3. 评价排序算法好坏的标准主要是()。
A. 执行时间B. 辅助空间C. 算法本身的复杂度D. 执行时间和所需的辅助空间正确答案：4. 设有50行60列的二维数组A[50][60]，其元素长度为4字节，按行优先顺序存储，基地址为200，则元素A[18][25]的存储地址为()。
A. 3700B. 4376C. 3900D. 4620正确答案：5. 根据二叉树的定义可知二叉树共有()种不同的形态。
A. 4B. 5C. 6D. 7正确答案：6. 以下排序方法中，稳定的排序方法是()。
A. 直接插入排序和希尔排序B. 直接插入排序和冒泡排序C. 希尔排序和快速排序D. 冒泡排序和快速排序正确答案：7. 下述几种排序方法中，平均查找长度最小的是()。
A. 插入排序B. 选择排序C. 快速排序D. 归并排序正确答案：8. 在数据结构中，与所使用的计算机无关的是数据的()结构A. 逻辑B. 存储C. 逻辑和存储D. 物理正确答案：9. 二分查找（又称折半查找）要求查找表中的记录按关键字()。
A. 有序B. 无序C. 既可有序也可无序正确答案：10. 以二叉链表作为二叉树的存贮结构时，在具有n个结点的二叉链表中(n>0)，空指针域的个数为()。
A. 2n-1B. n+1C. n-1D. 2n+1正确答案：11. 设结点A有3个兄弟结点且结点B为结点A的双亲结点，则结点B的度数数为()A. 3B. 4C. 5D. 1正确答案：12. 长度为256的表,采用分块查找,每块最佳长度为()。
数据结构与算法上机实验报告
数据结构与算法B上机实验报告第1次2011-10-02 顺序表的实现和基本操作第2次2011-10-29 二叉树的实现和递归遍历第3次2011-11-23 内部排序第4次2011-12-dd 实现图从邻接矩阵到邻接表存储转化第一次线性表数据结构一、上机实习题目线性链表操作——插入、删除、合并、排序、查找二数据结构设计（算法设计）源程序（#include <iostream>#define MaxSize 100using namespace std;typedef int ElemType;class SeqList{ElemType list[MaxSize];int length;public:SeqList() {length=0;}void SeqListSort(int i,ElemType x);void SeqListCreat(int n);void SeqListInset(int i,ElemType x);void SeqListDelete(int i);void SeqListMerge();int GetLength(){return length;}int SeqListFind(ElemType x);int SeqListIsEmpty();void SeqListPrint();}Mylist1,Mylist2;//创建顺序表void SeqList::SeqListCreat(int n){ElemType x;cout<<"请输入数据元素:";for (int i=0;i<n;i++){cin>>x;list[i]=x;length++;}}//对顺序表进行排序void SeqList::SeqListSort(int i,ElemType x) {for(int k=0;k<length;k++){for(i=k+1;i<=length;i++){if(list[k]>list[i]){x=list[k];list[k]=list[i];list[i]=x;}}}}//在顺序表L中的第i个位置插入新元素x void SeqList::SeqListInset(int i,ElemType x) {int k;if(length>=MaxSize)cout<<"表已满，无法插入！"<<endl;else if(i<0||i>length)cout<<"参数i不合理！"<<endl;else{for (k=length;k>=i;k--){list[k]=list[k-1];}list[i-1]=x;length++;}}//删除第i个位置的数据元素void SeqList::SeqListDelete(int i){int k;if(!SeqListIsEmpty())cout<<"表已空，无法删除！"<<endl;else if(i<0||i>length)cout<<"参数i不合理！"<<endl;elsefor(k=i-1;k<length;k++)list[k]=list[k+1];length--;}//查找元素x在表中的位置int SeqList::SeqListFind(ElemType x) {int i=0;while(i<length&&list[i]!=x)i++;if(i>length)return -1;elsereturn i+1;}//判断顺序表是否为空int SeqList::SeqListIsEmpty(){if(length<=0)return 0;else return 1;}//将顺序表显示在屏幕上void SeqList::SeqListPrint(){if(!SeqListIsEmpty())cout<<"空表！"<<endl;elsefor(int i=0;i<length;i++)cout<<list[i]<<" ";cout<<endl;}int main(){SeqList Mylist1,Mylist2;int i,n,flag=1,select;ElemType x;cout<<"1. 建立顺序表\n";cout<<"2. 对顺序表进行排序\n";cout<<"3. 求x数值的位置\n";cout<<"4. 在第i个位置插入新元素x\n"; cout<<"5. 删除第i个位置上的数值\n"; cout<<"6. 将两个顺序表合并\n";cout<<"7. 退出\n";cout<<endl;while (flag){cout<<"请选择操作：";cin>>select;switch(select){case 1:cout<<"请输入顺序表1的长度：";cin>>n;Mylist1.SeqListCreat(n);cout<<"你所输入的顺序表1为：";Mylist1.SeqListPrint();cout<<"请输入顺序表2的长度：";cin>>n;Mylist2.SeqListCreat(n);cout<<"你所输入的顺序表2为：";break;case 2:cout<<"请选择所要排序的顺序表1或2："; cin>>n;if(n==1){Mylist1.SeqListSort(i,x);cout<<"排序后的顺序表1为:";Mylist1.SeqListPrint();}else{Mylist2.SeqListSort(i,x);cout<<"排序后的顺序表2为:";Mylist2.SeqListPrint();}break;case 3:cout<<"请输入x的值：";cin>>x;i=Mylist1.SeqListFind(x);if(i!=-1) cout<<"x的位置为："<<i<<endl;else cout<<"没有找到！";break;case 4:cout<<"请输入要插入的元素的位置和数值x："; cin>>i>>x;cout<<"插入后的顺序表为:";Mylist1.SeqListPrint();break;case 5:cout<<"请输入要删除的元素的位置：";cin>>i;Mylist1.SeqListDelete(i);cout<<"删除后的顺序表为：";Mylist1.SeqListPrint();break;case 6:cout<<"合并后的顺序表为：\n";Mylist1.SeqListPrint();Mylist2.SeqListPrint();break;case 7:flag=0;break;}}}三运行结果为：四、上机环境和使用语言（计算机程序实现）Visual C++。
数据结构与算法上机实验七__查找和排序
数据结构上机实验五实验内容:查找表和内部排序的基本算法实验要求:1) 基本操作要作为函数被调用，做到模块化.2) 基本上实现每个实验题目的要求.分组要求：可单独完成，也可两人一组。
实验目的:1)熟悉C/C++基本编程,培养动手能力.2)通过实验,加深对查找算法的理解.评分标准：1) 只完成第一和第二题，根据情况得4，5-分；2）完成前3题，根据情况得5，6分；3）在2）基础上，选做四）中题目，根据情况得6，7分。
题目:一)顺序表与有序表的查找(1)建立一个顺序表，利用教材9.1.1的顺序查找算法进行查找；(2)建立一个有序表，利用折半法进行查找；(3)试将把(2)中的折半法改用递归算法实现；二)二叉排序树的一些基本操作(1)利用二叉链表的存储形式，从键盘输入建立一棵二叉排序树；(2)对（1）中建立的二叉排序树进行中序遍历并打印；(3)编写算法，判断一棵二叉树是否为二叉排序树。
(4)在（1）建立的二叉排序树中，查找一个树中不存在的关键字后并插入，之后打印该树；三)排序（1）插入排序——已知序列{17，18，60，40，7，32，73，65，85}建立一个顺序表，采用插入排序算法的实现升序排序，打印排序结果；（2）交换排序——已知序列{503，87，512，61，908，170，897，275，652，462}(1)建立一个顺序表，采用冒泡排序法实现升序排序，并打印每趟排序结果；(2)建立一个顺序表，采用快速排序法实现升序排序，并打印每趟排序结果，与(1)做比较；（3）选择排序——已知序列{42，13，24，91，23，16，05，88}利用简单选择排序，实现上述序列的降序排序；四）选作题（1）试构造一个算法，从键盘输入一组关键字，按哈希函数H(key) = key MOD 13和链地址法处理冲突构来造哈希表,能对关键字进行查找并显示。
如(19,14,23,1,68,20,84,27,55,11,10,79,33).(2)已知序列{503，87，512，61，908，170，897，275，652，462}，采用基数排序法对其作升序排序，打印每一趟的结果。
《算法与数据结构》上机指导书
else {printf("不存在值为%d的元素\n",e);return 0;}
}
int scan()
{int d;
printf("请选择所要进行的操作\n");
printf("1.初始化2.清空3.求顺序表长度4.检查顺序表是否为空\n");
}
五、实验注意事项
1、在做第一次“数据结构”课程实验之前，要在硬盘上建立好自己的工作目录，专门来存储你所做的实验程序及相关信息，以后每次做实验都采用这个目录。
实验二顺序表其它操作
一、目的和要求
1、进一步掌握在线性表的顺序存储结构上的一些其它操作。
三、仪器、设备和材料
1、计算机若干台
四、实验步骤
/*定义ElemType为int类型*/
typedef int ElemType;
/*顺序表存储空间的总分配量*/
#define MAXSIZE 100
#define FALSE 0
#define TRUE 1
/*顺序存储类型*/
typedef struct
前言
算法与数据结构是计算机科学与技术专业和其他有志从事计算机技术工作的人员的一门重要的专业基础课。算法与数据结构课程的教学要求是学会分析研究计算机加工的数据对象的特征，以便在实际应用中选择适当的数据结构、存储结构和相应的算法，初步掌握算法的时间与空间性能分析技巧，得到复杂程序设计的训练。
本书是与高等教育出版社出版的《数据结构――用C语言描述》（唐策善等编）相配套的，给出了十三个上机实验指导，每个实验都给出了几道上机题目，每个实验题目都介绍了实验目的，主要采用的方法与技术和C语言实现程序。通过实验使学生了解并学会如何运用数据结构只是去解决现实世界的某些实际问题，具备设计较复杂程序的初步能力。
C++数据结构与算法上机练习题
Bracket Matching
时间限制：1 秒 内存限制：256 兆 题目描述 检查输入字符串中的括号是否匹配。括号包括：{, }, (, ), [, ]. 输入格式 第一行是一整数，即测试样例个数 n. 以下 n 行，每一行是一个长度不超过 100 个字符的字符串。 输出格式 第一行是一整数，即测试样例个数 n. 以下 n 行，每一行是一个长度不超过 100 的字符串。 样例输入 3 a 2-[(1+2)*2] (a+b]) 样例输出 Yes Yes
while(p!=NULL) { cout<<p->data<<" "; p=p->next; } cout<<endl; } } void ReverseList(LinkedNode* pCur,LinkList& ListHead) { if( (NULL==pCur)||(NULL==pCur->next) ) { ListHead=pCur; } else { LinkedNode* pNext=pCur->next; ReverseList(pNext,ListHead); //递归逆置后继结点 pNext->next=pCur; //将后继结点指向当前结点。 pCur->next=NULL; } } int main() { int a[N]={1,2,3,4,5,6}; LinkedNode* list=CreateList(a); PrintList(list); LinkedNode*pTemp=list; ReverseList(pTemp,list); PrintList(list); return 0; }
数据结构练习题: 单链表的逆置 题目描述 实现单链表的逆置 输入格式 输入需要逆置的字符串 输出格式 第一行输出逆置前的字符串 第二行输出逆置后的字符串 样例输入 abcdefg 样例输出 abcdefg gfedcba #include<iostream> using namespace std; const int N=6; typedef int DataType;//类型定义 typedef struct node{ //单链表 DataType data; struct node* next; }LinkedNode,*LinkList; /****由数组创建单链表****/ LinkList CreateList(DataType a[N]) { LinkedNode* ListHead=new LinkedNode(); ListHead->data=a[0]; ListHead->next=NULL; for(int i=N-1;i>=1;i--) { LinkedNode* p=new LinkedNode(); p->data=a[i]; p->next=ListHead->next; ListHead->next=p; } return ListHead; } /****输出单链表****/ void PrintList(LinkList ListHead) { if(NULL==ListHead)cout<<"The List is empty!"<<endl; else { LinkedNode* p=ListHead;
算法与数据结构上机题目
实验一顺序表的操作及其应用实验目的1）掌握线性表的顺序存储结构；2）熟练掌握顺序表基本算法的实现；3）掌握利用线性表数据结构解决实际问题的方法和基本技巧；4）按照实验题目要求独立正确地完成实验内容。
实验环境1) 硬件：每个学生需配备计算机一台，操作系统：Windows2000/XP；2) 软件：visual c++6.0；实验学时3学时实验内容要求：数据元素类型ElemType 取整型int 或者char。
顺序存储实现如下算法：1）创建一顺序表；2）输出该顺序表；3）在顺序表中查找第i 个元素，并返回其值；4）在顺序表中第i 个元素之前插入一已知元素；5）在顺序表中删除第i 个元素；实验二队列的操作及其应用实验目的1) 掌握队列的基本定义；2）掌握循环队列基本操作的实现；3）掌握利用栈和循环队列进行回文字符串的判定。
实验环境1) 硬件：每个学生需配备计算机一台，操作系统：Windows2000/XP；2) 软件：visual c++6.0；实验学时2学时实验内容1、回文字符串的判定要求：数据元素类型 ElemType 取字符型 char。
实现如下算法：1）创建一循环队列；2）创建一个顺序栈；3）利用栈和队列实现回文字符串的判定。
实验提示1)在实验3的基础上（利用已完成的栈的类型定义和基本操作的实现）完成循环队列的存储结构定义（取名为SqQueue）。
2)完成循环队列的基本操作（参数可根据实际需要来确定）●初始化队列InitQueue●销毁队列ClearQueue●入队列enQueue●出队列deQueue3) 利用栈和队列的特性，将输入的字符串分别进栈和队列，完毕后再依次出栈和出队，比较输出内容是否相等，若不相等则判别为非回文字符串，若栈空且队列空则是回文字符串。
4）如何实现接受用户从键盘输入的字符串？cout<<"请输入一个字符序列，回车换行结束！"<<endl;cin.getline(str,80);int h=strlen(str);实验三查找算法一、实验目的1) 掌握有序表、无序表查找的基本思想及存储、运算的实现2) 深刻理解各种算法的特点，并加以灵活应用3）加深对查找的理解，逐步培养解决实际问题的编程能力二、实验内容1)建立一个无序表并实现其上的顺序查找；2)建立一个有序表并实现其上的折半查找（用递归和非递归两种算法实现）；三、实验结果。
数据结构上机作业
数据结构上机作业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。
数据结构与算法在线作业答案
数据结构与算法在线作业答案55283,单选题655121.邻接表是图的一种____。
A 顺序存储结构B 链式存储结构C 索引存储结构D 散列存储结构6550255281,单选题655022.具有5个顶点的有向完全图有____条弧。
A 10B 16C 20D 256547555245,单选题654753.链表不具有的特点是_____。
A 可随机访问任一元素B 插入和删除不需要移动元素C 不必事先估计存储空间D 所需空间和线性表长度成正比6548555256,单选题654854.作进栈操作时，应先判断栈是否为_____。
A 空B 满C 上溢D 下溢6551555287,单选题655155.下面关于图的存储的叙述中，哪一个是正确的？A 用相邻矩阵法存储图,占用的存储空间数只与图中结点个数有关,而与边数无关B 用相邻矩阵法存储图,占用的存储空间数只与图中边数有关,而与结点个数无关C 用邻接表法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关D 用邻接表法存储图，占用的存储空间数只与图中边数有关，而与结点个数无关6548655261,单选题654866.当字符序列 x5y 作为字符堆栈的输入时，输出长度为3的且可以作为C语言标识符的个数是____。
A 3个B 4个C 5个D 6个6547755253,单选题654777.树最适合用来表示_____。
A 有序数据元素B 无序数据元素C元素之间具有分支层次关系的数据D 元素之间无联系的数据6546055240,单选题654608.线性表按链式方式存储时，每个结点的存储包括_____两部分。
A 数据值与符号B 数据与指针C 数据与表名D 数据项与符号6549855268,单选题654989.树的基本遍历策略可分为先根遍历和后根遍历；二叉树的基本遍历策略可分为先序遍历、中序遍历和后序遍历。
这里我们把由树转化得到的二叉树叫做这棵树对应的二叉树。
那么以下结论中_____是正确的。
数据结构与算法 作业
习 题 11． 简述下列术语：数据 数据元素 数据结构 存储结构 数据类型 抽象数据类型2．在下面两列中，左侧是算法的执行时间，右侧是一些时间复杂度。
请用连线的方式表示每个算法的时间复杂度。
100n 3 (1) (a) O (1) 6n 2-12n +1 (2) (b) O (2n ) 1024 (3) (c) O (n ) n +2log 2n (4) (d) O (n 2) n (n +1)(n +2)/6 (5) (e) O (log 2n ) 2n +1+100n (6)(f) O (n 3)3. 试编写算法，求一元多项式P n (x )=∑=ni ii xa 0的值P n (x 0)，并确定算法中每一语句的执行次数和整个算法的时间复杂度。
注意选择你认为较好的输入和输出方法，本题输入为a i (i=0,1,…,n )，x 0和n ，输出为P n (x 0)。
习 题 21． 填空题：a) 在顺序表中插入和删除一个元素，需要平均移动 表中一半 元素，具体移动的元素个数与 插入或删除元素的位置 有关。
b) 顺序表中逻辑上相邻的元素的物理位置 要求 紧邻。
单链表中逻辑上相邻的元素的物理位置 不要求 紧邻。
c) 在单链表中，除了首结点外，任一结点的存储位置由 前一结点的指针 指示。
d) 在单链表中设置头结点的作用是 储存指向第一个结点的指针 。
2． 已知顺序线性表A 和B 中各存放一个英语单词，字母均为小写。
试编写一个判定那个单词在字典中排在前面的算法。
3．试写一算法，实现顺序表的就地逆置，即利用原表的存储空间将线性表（a1，a2，…, a n）逆置为（a n，a n-1，…，a1）。
4．已知指针ha和hb分别指向两个单链表的头结点，并且已知两个链表的长度分别为m 和n。
试写一算法将这两个链表连接在一起（即令其中一个表的首元结点连在另一个表的最后一个结点之后），假设指针hc指向连接后的链表的头结点，并要求算法以尽可能短的时间完成连接运算。
《数据结构与算法(C语言版)》上机实验4
上机实验4 二叉树的遍历【实验目的】（1）掌握指针变量的含义及使用方法。
（2）熟悉二叉树结点的结构。
（3）掌握二叉树每一种操作具体实现的方法。
（4）学会利用递归的方法实现二叉树的遍历算法。
【实验内容】实现对二叉树的如下操作：（1）创建二叉树。
（2）先序遍历二叉树。
（3）中序遍历二叉树。
（4）后序遍历二叉树。
（5）按层遍历二叉树。
要求能够从键盘上输入建树的结点内容，并且将遍历的结果输出在屏幕上。
【实验步骤】（1）在Microsoft Visual C++中创建应用程序L4。
（2）在程序中创建二叉树的存储结构BiTNode，以链表作为存储结构。
（3）创建CreateBiTree()函数，实现创建二叉树的操作，能够按先序次序从键盘输入结点内容，空格表示空树。
（4）创建PreOrderTraverse()函数，用递归的方法实现先序遍历二叉树的操作。
（5）创建InOrderTraverse()函数，用递归的方法实现中序遍历二叉树的操作。
（6）创建PostOrderTraverse()函数，用递归的方法实现后序遍历二叉树的操作。
（7）创建LevelOrderTraverse()函数，实现按层遍历二叉树的操作。
（8）创建主函数，用switch语句实现从键盘上输入字符，选择要执行的操作。
（9）编译连接程序，执行并观察程序的运行效果。
【参考源代码】#include "stdlib.h"#include "stdio.h"typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,* BiTree;void CreateBiTree(BiTree &T){ //按先序次序输入，构造二叉链表表示的二叉树T，空格表示空树char ch;scanf("%c",&ch);if (ch==' ') T=NULL;else{if (!(T=(BiTNode*)malloc(sizeof(BiTNode)))) exit(-1);T->data=ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}}//CreateBiTreevoid PreOrderTraverse(BiTree T){ //先序遍历if(T){printf("%c ",T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}//PreOrderTraversevoid InOrderTraverse(BiTree T){ //中序遍历if(T){InOrderTraverse(T->lchild);printf("%c ",T->data);InOrderTraverse(T->rchild);}}//InOrderTraversevoid PostOrderTraverse(BiTree T){ //后序遍历if(T){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);printf("%c ",T->data);}}//PostOrderTraversevoid LevelOrderTraverse(BiTree T){ //按层遍历const int MaxLength=100;BiTree Q[MaxLength];Q[0]=T;int front=0,rear=1;while(front<rear){if(Q[front]){printf("%c",Q[front]->data);Q[rear++]=Q[front]->lchild;Q[rear++]=Q[front]->rchild;front++;}else{front++;}}}//LevelOrderTraversevoid main(){BiTree T=NULL;char select;while(1){printf("请选择要执行的操作：\n");printf("1.创建二叉树\n");printf("2.二叉树的递归遍历算法（前、中、后）\n");printf("3.二叉树的层序遍历算法\n");printf("0.退出\n");fflush(stdin);scanf("%c",&select);fflush(stdin);switch(select){case '0':return;case '1':printf("请按先序次序输入各结点的值，以空格表示空树(输入时可连续输入)：\n");CreateBiTree(T);printf("\n");break;case '2':printf("先序遍历:");PreOrderTraverse(T);printf("\n中序遍历:");InOrderTraverse(T);printf("\n后序遍历:");PostOrderTraverse(T);printf("\n\n");break;case '3':printf("层序遍历:");LevelOrderTraverse(T);printf("\n\n");break;default:printf("请确认选择项!\n\n") ;}//end switch}//end while}//end main【实验结果】运行示例：构建如下二叉树，并且将其遍历的结果输出在屏幕上。
《数据结构与算法(C语言版)》上机实验2
上机实验2 串的匹配算法及实现【实验目的】（1）了解串的相关概念。
（2）掌握串的有关存储方法。
（3）熟悉串的基本操作。
（4）通过串匹配算法的实现，掌握朴素的模式匹配算法。
【实验内容】实现朴素的模式匹配算法：要求能够实现从键盘输入主串S和子串T，并且能够从键盘指定S的第pos位为开始匹配的位置，如果匹配成功，则在屏幕输出S中符合匹配的位置，即S中与T匹配的子序列第一个字符的序号，否则，返回0。
【实验步骤】（1）在Microsoft Visual C++中创建应用程序L2。
（2）在程序中创建字符串的存储函数InitStr()，使用数组的0号单元存储字符串的长度。
（3）创建字符串的匹配函数Index()。
（4）创建主函数，实现从键盘上输入主串S、子串T，并能够指定开始匹配的位置。
（5）编译连接程序，执行并观察程序的运行效果。
【参考源代码】#include <stdio.h>#include <string.h>#define MAXSIZE 100// 字符串的最大存储长度typedef char SString[MAXSIZE+1];// 使用0号单元存储长度void InitStr(SString rs){char stmp[MAXSIZE];int i;gets(stmp);rs[0]=strlen(stmp);for (i=1;i<=rs[0];i++)rs[i]=stmp[i-1];rs[i]='\0';}int Index(SString S, SString T, int pos){// 返回T在S中第pos个字符后首次出现的位置，若不存在则返回0int i = pos,j = 1;while(i <= S[0] && j <= T[0]){if (S[i] == T[j]) // 匹配继续比较后继字符{++i;++j;}else // 不匹配，指针后退，重新开始匹配{i = i-j+2;j = 1;}}if(j>T[0])return i-T[0]; //匹配成功返回T在S中第pos个字符后首次出现的位置else return 0;} // Indexvoid main (){SString sstr;SString dstr;int pos;int n;printf("请输入主串：");InitStr(sstr);printf("请输入子串：");InitStr(dstr);printf("请输入开始匹配的位置：");scanf("%d",&pos);n=Index(sstr, dstr, pos);printf("%d\n",n);}【运行结果】运行示例：主串输入：sit please子串输入：please匹配位置输入：2运行结果如附图2所示。
算法与数据结构实践考核上机练习题1-5（201103）
算法与数据结构实践考核上机练习题1-5（201103）算法与数据结构上机考试练习题1-5（201103）（一）顺序表基本操作及应用一、顺序表基本操作1、考核要求实现顺序表动态存储结构的创建、查找、插入、删除、遍历等基本操作。
2、数据结构定义参考typedef struct {int *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量}SqList;3、基本操作定义参考bool InitList(SqList &L) // 构造一个空的顺序表int LocateElem(SqList L, int e)// 查找表中第1个与e相等的元素，返回元素的位序bool ListInsert(SqList &L,int i, int e)// 在顺序表中第i个位置之前插入数据元素ebool ListDelete(SqList &L,int i)// 删除顺序表中的第i个数据元素bool ListTraverse(SqList L)//遍历顺序表4、程序验收从键盘录入基础数据，测试各基本操作模块的功能。
测试流程：（1）创建空表，输出初始化结构数据。
（2）在表尾依次插入1 2 3 4 5 6 7 8 9 10，并遍历输出。
（3）查找值为12的元素，并给出查询结果。
（4）删除值为9的元素，并遍历输出。
5、程序运行结果参考初始化L后：L.elem=2086 L.length=0 L.listsize=10在L的表尾依次插入1～10后：L.elem=1 2 3 4 5 6 7 8 9 10 没有值为12的元素依次输出L的元素：L.elem =1 2 3 4 5 6 7 8 9 10二、顺序表基本应用1、考核要求应用顺序表的基本操作实现直接插入排序。
2、程序验收例如：初始数据 1 6 5 3 4 2排序后 1 2 3 4 5 6一、单链表基本操作1、考核要求实现单链表结构的创建、查找、插入、删除、遍历等基本操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构与算法上机作业第三章树一、选择题1、在一棵树中,如果结点A有3个兄弟,B就是A得双亲,则B得度为 DA、1B、2C、3D、42、深度为h得完全二叉树至少有 D 个结点,至多有 B 个结点A、2hB、2h-1C、2h+1D、2h-13、具有n个结点得满二叉树有 C 个叶结点。
A、n/2B、(n-1)/2C、(n+1)/2D、n/2+14、一棵具有25个叶结点得完全二叉树最多有 C 个结点。
A、48B、49C、50D、515、已知二叉树得先根遍历序列就是ABCDEF,中根遍历序列就是CBAEDF,则后根遍历序列就是 A 。
A、CBEFDAB、FEDCBAC、CBEDFAD、不定6、具有10个叶结点得二叉树中有 B 个度为2得结点。
A、8B、9C、10D、117、一棵非空二叉树得先序遍历序列与后序遍历序列正好相反,则该二叉树一定满足B 。
A、所有非叶结点均无左孩子B、所有非叶结点均无右孩子C、只有一个叶子结点D、A与B同时成立8、在线索二叉树中,t所指结点没有左子树得充要条件就是 D 。
A、t->left=NULLB、t->ltag=TRUEC、t->ltag=TRUE且t->left=NULLD、以上都不对9、n个结点得线索二叉树上含有得线索数为 C 。
A、2nB、n-1C、n+1D、n10、二叉树按照某种顺序线索化后,任一结点都有指向其前驱与后继得线索,这种说法 B 。
A、正确B、错误C、不确定D、都有可能11、具有n(n>1)个结点得完全二叉树中,结点i(2i>n)得左孩子结点就是 D 。
A、2iB、2i+1C、2i-1D、不存在12、具有64个结点得完全二叉树得深度为 C 。
A、5B、6C、7D、813、将一颗有100个结点得完全二叉树从上到下、从左到右一次对结点进行编号,根结点得编号为1,则编号为45得结点得右孩子得编号为 D 。
A、46B、47C、90D、9114、在结点数为n得堆中插入一个结点时,复杂度为 C 。
A、O(n)B、O(n2)C、O(log2n)D、O(log n2)15、两个二叉树就是等价得,则它们满足 D 。
A、它们都为空B、它们得左右子树都具有相同得结构C、它们对应得结点包含相同得信息D、A、B与C16、包含n个元素得堆得高度为 C 。
(符号「a表示取不小a最小整数)A、nB、「log2nC、「log2(n+1)D、n+117、以下说法错误得就是 B 。
A、存在这样得二叉树,对其采用任何次序得遍历其结点访问序列均相同B、二叉树就是树得特殊情形C、由树转换成二叉树,其根结点得右子树总就是空得D、在二叉树中只有一棵子树得情形下,也要指出就是左子树还就是右子树18、设F就是一个森林,B就是由F变换得到得二叉树。
若F中有n个非终端结点,则B中没有右孩子得结点有 C 个。
A、n-1B、nC、n+1D、n+219、将一棵树T转换为二叉树B,则T得后根序列就是B得 B 。
A、先根序列B、中根序列C、后根序列D、层次序列20、将一棵树转换为二叉树后,这颗二叉树得形态就是 B 。
A、唯一得,根结点没有左孩子B、唯一得,根结点没有右孩子C、有多种,根结点都没有左孩子D、有多种,根结点都没有右孩子21、设树T得度为4,其中度为1, 2, 3, 4得结点个数分别为4, 2, 1, 1,则T中得叶结点得个数为 D 。
A、5B、6C、7D、822、设森林F中有三棵树,第一、第二、第三棵树得结点个数分别为M1, M2, M3。
与森林F 对应得二叉树根结点得右子树上得结点个数为 D 。
A、M1-1B、M1+M2C、M2D、M2+M323、若以二叉树得任一结点出发到根得路径上所经过得结点序列按其关键字有序,则该二叉树就是 C 。
A、二叉排序树B、哈夫曼树C、堆D、线索二叉树24、用5个权值{3, 2, 4, 5, 1}构造得哈夫曼树得带权路径长度就是 C 。
A、32B、33C、34D、15二、填空题1、一棵二叉树有67个结点,结点得度就是0与2。
问这棵二叉树中度为2得结点有33 个。
2、含A, B, C三个结点得不同形态得二叉树有0 棵。
3、含有4个度为2得结点与5个叶子结点得完全二叉树,有 1 个度为1得结点。
4、具有100个结点得完全二叉树得叶子结点数为50 。
5、在用左右链表示得具有n个结点得二叉树中,共有2n 个指针域,其中n-1 个指针域用于指向其左右孩子,剩下得n+1 个指针域就是空得。
6、如果一颗完全二叉树得任意一个非终结结点得元素都大于等于其左儿子结点与右儿子结点(如果有得话)得元素,则称此完全二叉树为最大堆。
7、堆就是一种特殊形式得完全二叉树二叉树,对于最大堆而言,其根结点得元素得值应该就是所有结点元素中最大得得。
8、二叉树得复制就是指按照一棵已知得二叉树复制一个副本,使两者等价。
复制二叉树最长用得方法就是后根遍历递归算法。
9、在定义堆时,通常采用数组方式定义相应得二叉树,这样可以很容易实现其相关操作。
10、在构建选择树时,根据孩子结点得获胜者确定她们双亲结点所得到得选择树称为胜者树。
根据孩子结点得失败者确定她们双亲结点所得到得选择树称为败者树。
11、树得表示方法包括数组、邻接表与左右链。
12、表达式(a+b*(c-d))-e/f得波兰式(前缀式)就是-+a*b-cd/ef ,逆波兰式(后缀式)就是abcd-*+e/f- 。
13、设F就是由T1、T2、T3三棵树组成得森林,与F对应得二叉树为B。
已知T1, T2, T3得结点数分别为n1, n2与n3,则二叉树B得左子树中有n1-1 个结点,二叉树B得右子树中有n2+n3 个结点。
14、设二叉树得中根序列为ABCDEFG,后根序列为BDCAFGE。
则该二叉树得先根序列为EGCBDGF 。
该二叉树对应得森林中包含 2 棵树。
15、先根次序遍历森林等同于按先根遍历对应得二叉树,后根次序遍历森林等同与按中根遍历对应得二叉树。
16、一棵哈夫曼树有19个结点,则其叶子结点得个数为10 。
17、设有数据WG={7, 19, 2, 6, 32, 3, 21, 10}叶节点权重集合,则所构建哈夫曼树得高就是6 ,带权路径长度WPL为261 。
18、设有一份电文中共使用6个字符a, b, c, d, e, f,其中出现频率依次为2,3,4,7,8,19,则字符c 得哈夫曼编码就是001 ,电文编码得总长度为96 。
20、在有n个结点得哈夫曼树中,叶子结点总数为(n+1)/2 ,非叶结点得总数为(n-1)/2 。
三、试分别画出具有4个结点得二叉树得所有不同形态。
四、已知一棵二叉树得中根序列与后根序列分别就是BDCEAHFG与DECBHGFA,请画出此二叉树。
五、已知非空二叉树T,写一个算法,求度为2得结点得个数。
要求:1、定义二叉树得抽象数据类型与型BTREE,并定义基本操作。
2、编写函数count2(BTREE T),返回度为2得节点得个数。
3、在主函数中,构建一个二叉树,并验证所编写得算法。
六、用递归方法写一个算法,求二叉树得叶子结点数int leafnum(BTREE T)。
要求:1、定义二叉树得抽象数据类型与型BTREE,并定义基本操作。
2、编写函数leafnum(BTREE T),返回树T得叶子节点得个数。
在主函数中,构建一个二叉树,并验证所编写得算法。
七、画出下图所表示得二叉树得中序线索二叉树与先序线索二叉树。
八、已知二叉树得先根序列就是AEFBGCDHIKJ,中根序列就是EFAGBCHKIJD,画出此二叉树,并画出后序线索二叉树。
九、在中序线索二叉树中插入一个结点Q作为树中某个结点P得左孩子,试给出相应得算法。
要求:1、定义中序线索二叉树得型THTREE以及基本操作。
2、定义函数void LInsert(THTREE P, THTREE Q); 实现题目要求得操作。
在主函数中,利用操作RInsert与LInsert构造一个线索二叉树,并中序输出二叉树得结点得元素,验证结果。
十、假设现在有如下得元素:7、16、49、82、5、31、6、2、44。
画出将每一个元素插入堆中以后得最大堆。
要求:利用基本操作Insert得基本原理,先用第一个元素7构成一个二叉树,然后将第二个元素16插入该二叉树中,再将第三个元素49插入堆中,……,直到最后一个元素插入为止。
上述过程要求画图完成。
十一、编写一个函数,在最大堆中查找任意元素,并分析其时间复杂度。
要求:1、定义最大堆得型HEAP及其基本操作。
2、定义函数int Find(HEAP H, Elementtype e),查找e就是否为堆得元素,如果就是,返回该元素在堆中得位置,如果不就是,返回0。
(提示:利用最大堆得元素特点进行查找,可降低复杂度)在主函数中首先构建一个二叉树,然后验证所构造得函数。
十二、给定叶子结点得权值集合{15, 3,14, 2, 6, 9, 16, 17},构造相应得哈夫曼树,并计算其带权路径长度。
十三、已知n=9与一组等价关系:1≡5、6≡8、7≡2、9≡8、3≡7、4≡2、9≡3试应用抽象数据类型MFSET设计一个算法,按输入得等价关系进行等价分类。
十四、画出下图所示得森林经转换后所对应得二叉树,并指出在二叉树中某结点为叶子结点时,所对应得森林中结点应满足得条件。
十五、已知森林F得先根序列为:ABCDEFGHIJKL,后根序列为:CBEFDGAJIKLH,试画出森林B,然后再将B转换为森林。
所对应得树结构,并写出该表达式得波兰表示式与逆波与位置得型position。
:BTREE convert(char *express),其中参数express为四则混合运算表达式,返回值为生成得树。
4、实现计算四则混合运算得值得函数:double puter(BTREE bt),其中,参数bt为四则运算所对应得树,返回值为计算结果。
提示:先求树得得波兰表达式,然后利用栈结构计算表达式得值。
在主函数中进行测试,求2+3*(5+8)/4-5得值。
要求:1、上述作业要求在单独完成;2、完成后,于规定期限内提交到ftp服务器得相应目录中中,注意,在提交时将所编写得程序统一拷贝到一个Word文件中,文件名格式为“学号+姓名”三typedef char datatype;struct node{node *lchild;datatype data;node *rchild;};typedef node *BTREE;void CreateBTREE(BTREE &BT,char *&str)//先根输入树{char ch;ch=*str++;if(ch=='#')BT=NULL;else{BT=new node;BT->data=ch;CreateBTREE(BT->lchild,str);CreateBTREE(BT->rchild,str);}}void Empty(BTREE BT){BT=NULL;}bool IsEmpty(BTREE BT)//判断就是否为空{if(BT==NULL)return true;elsereturn false;}BTREE CreateBT(datatype v,BTREE ltree,BTREE rtree)//用左右子树建立二叉树{BTREE root;root=new node;root->data=v;root->lchild=ltree;root->rchild=rtree;return root;}BTREE Lchild(BTREE BT)//返回左子树{return BT->lchild;}BTREE Rchild(BTREE BT)//返回右子树{return BT->rchild;}datatype Data(BTREE BT)//返回节点元素值{return BT->data;}void visit(datatype dt){cout<<dt;}void PreOrder(BTREE BT)//先根顺序遍历{if(!IsEmpty(BT)){visit(Data(BT));PreOrder(Lchild(BT));PreOrder(Rchild(BT));}}void InOrder(BTREE BT)//中根顺序遍历{if(!IsEmpty(BT)){PreOrder(Lchild(BT));visit(Data(BT));PreOrder(Rchild(BT));}}void PostOrder(BTREE BT)//后根顺序遍历{if(!IsEmpty(BT)){PreOrder(Lchild(BT));PreOrder(Rchild(BT));visit(Data(BT));}}int count2(BTREE BT){if(BT==NULL)return 0;else{if((BT->lchild)&&(BT->rchild))return 1+count2(Lchild(BT))+count2(Rchild(BT));if((BT->lchild)&&(BT->rchild==NULL))return count2(Lchild(BT));if((BT->lchild==NULL)&&(BT->rchild))return count2(Rchild(BT));}}int leafnum(BTREE BT){static int count=0;if(BT->lchild==NULL&&BT->rchild==NULL)return ++count;else{leafnum(Lchild(BT));leafnum(Rchild(BT));}}int main(){BTREE BT=NULL;char *str="abc##d##ef##g##";CreateBTREE(BT,str);cout<<"度为2得节点得个数:"<<count2(BT)<<endl;cout<<"叶子节点个数:"<<leafnum(BT)<<endl;}七using namespace std;typedef char datatype;struct node{node *lchild;node *rchild;bool ltag;bool rtag;datatype data;};typedef node *THTREE;THTREE InPre(THTREE P)//求中序前驱(右子树得最左节点) {THTREE Q=P->lchild;if(P->ltag==true)while(Q->rtag==true)Q=Q->rchild;return Q;}THTREE InNext(THTREE P)//求中序后继(左子树得最右节点) {THTREE Q=P->rchild;if(P->rtag==true)while(Q->ltag==true)Q=Q->lchild;return Q;}//二叉树中插入一个结点Q作为树中某个结点P得左孩子void LInsert(THTREE P,THTREE Q){THTREE W;Q->lchild=P->lchild;Q->ltag=P->ltag;Q->rchild=P;Q->rtag=false;P->lchild=Q;P->ltag=true;if(Q->ltag==true)//如果P节点有左孩子{W=InPre(Q);W->rchild=Q;}}void RInsert(THTREE P,THTREE Q){THTREE W;Q->rchild=P->rchild;Q->rtag=P->rtag;Q->lchild=P;Q->ltag=false;P->rchild=Q;P->rtag=true;if(Q->rtag==true)//如果P节点有右孩子{W=InNext(Q);W->lchild=Q;}}void ThInOrder(THTREE HEAD){THTREE temp;temp=HEAD;do{temp=InNext(temp);if(temp!=HEAD)cout<<(temp->data);}while(temp!=HEAD);}int main(){node *HEAD=new node;node *A=new node;HEAD->data='!';A->data='A';HEAD->lchild=A;HEAD->rchild=HEAD;HEAD->ltag=true;HEAD->rtag=true;A->lchild=HEAD;A->rchild=HEAD;A->ltag=false;A->rtag=false;node *B=new node;B->data='B';node *C=new node;C->data='C';node *D=new node;D->data='D';node *E=new node;E->data='E';node *F=new node;F->data='F';node *G=new node;G->data='G';LInsert(A,B);RInsert(A,C);LInsert(B,D);RInsert(B,E);LInsert(C,F);RInsert(C,G);ThInOrder(HEAD); }十i=++heap、n;while(i!=1&&(element、data>heap、elements[i/2]、data)){heap、elements[i]=heap、elements[i/2];i/=2;}}heap、elements[i]=element;}Elementtype DeleteMax(HEAP &heap)//删除堆中得最大元素{int parent=1,child=2;Elementtype element,tmp;if(!HeapEmpty(heap)){element=heap、elements[1];tmp=heap、elements[heap、n--];while(child<=heap、n){if((child<heap、n)&&(heap、elements[child]、data<heap、elements[child+1]、data)) child++;if(tmp、data>=heap、elements[child]、data)break;heap、elements[parent]=heap、elements[child];parent=child;child*=2;}heap、elements[parent]=tmp;return element;}}int Find(HEAP &H,Elementtype e)//查找e就是否为堆中元素{int i=H、n,j;if(e、data==H、elements[1]、data)return 1;if(i!=0){if(e、data==H、elements[i]、data)return i;else if((e、data<H、elements[i/2]、data)&&(e、data<H、elements[i/4]、data)){j=i/4+1;while(j<i){if(e、data==H、elements[j]、data)return j;j++;}return 0;}elsei/=4;}}int main(){HEAP H;H、n=0;Elementtype element;int data[]={7,16,49,82,5,31,6,2,44};for(int i=0;i<9;i++){element、data=data[i];Insert(H,element);}cout<<"最大堆元素为:"<<endl;for(int i=1;i<=9;i++){cout<<H、elements[i]、data<<"\t";}cout<<endl;cout<<"请输入要查找得元素"<<endl;cin>>element、data;cout<<"该元素在堆中得位置为"<<Find(H,element)<<endl; }十三#define n 9struct node{int father;int count;};void Union(int A,int B,MFSET C)//如果集合擦C[A] C[B]不相交{if(C[A]、count>C[B]、count){C[B]、father=A;C[A]、count=C[A]、count+C[B]、count;//并入A }else{C[A]、father=B;C[B]、count=C[A]、count+C[B]、count;//并入B }}int Find(int x,MFSET C)//求包含x得集合{int f;f=x;while(C[f]、father!=0)f=C[f]、father;return f;}void Initial(int A,MFSET C){C[A]、father=0;//集合A只包含元素A,个数为1;C[A]、count=1;}void Equivalence(MFSET S){int i,j,m,k;for(i=1;i<=n+1;i++)Initial(i,S);//使集合i只包含元素icin>>i;cin>>j;//读入第一个等价对while(!(i==0&&j==0))//等价对未读完,输入0 0结束{k=Find(i,S);//求i得根m=Find(j,S);//求j得根if(k!=m) //若k=m,说明i,j已经在一棵树中,不需要合并Union(k,m,S);cin>>i;cin>>j;}}int main(){MFSET S;Equivalence(S);int r[n+1][n+1]={},k;for(int i=1;i<=n;i++){k=Find(i,S);r[k][0]++;r[k][r[k][0]]=i;}for(int i=1;i<=n;i++){if(r[i][0]>0){for(int j=1;j<=r[i][0];j++)cout<<r[i][j]<<"\t";}cout<<endl;}}十四。