数据结构与算法上机作业
数据结构第五章 查找 答案
数据结构与算法上机作业第五章查找一、选择题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的表,采用分块查找,每块最佳长度为()。
- 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;}}十四。