| 显示联大系统河南理工大学数据结构所有答案 |
|
设二叉树以二叉链表的形式存储，有关类型定义如下： typedef struct BiTNode { // 结点结构 int data; struct BiTNode *lchild, *rchild; // 左右孩子指针 } BiTNode
|
答案是：
if|else
|
|
已知栈的顺序存储结构定义如下： typedef int SElemType ; typedef struct { SElemType *base; // 栈底指针 SElemType *top; // 栈顶指针 int stacksize;
|
答案是：while|printf
|
|
)已知单链表中结点结构定义如下： typedef int ElemType ; typedef struct LNode { ElemType data; struct LNode *next; } LNode, *Linklist 下面是
|
答案是：while|else
|
|
设二叉树以二叉链表的形式存储，有关类型定义如下： typedef struct BiTNode { // 结点结构 int data; struct BiTNode *lchild, *rchild; // 左右孩子指针 } BiTNode
|
答案是：
if|else
|
|
假设线性表的顺序存储结构类型定义如下： typedef int ElemType ; typedef struct { ElemType *elem; // 存储空间基址 int length; // 线性表当前长度 int listsiz
|
答案是：
for|if
|
|
Tw状态的含义。
|
答案是：存储器|8284A|Tw|READY|总线周期
|
|
8088和8086的比较
|
答案是：CPU|指令队列|外部数据总线|引脚特性|周期状态信号
|
|
利用8255A（端口地址为60H~63H）与打印机相连，完成打印控制功能。8255A的A口作为数据口与打印机连接，采用向量中断方式（连接到8259的IR5）完成工作。设与打印机的连接信号仅有STB#和BUSY两个；8259端口地址为20H~
|
答案是：PU输出数据|8255A|输出端口|选通信号|请求信号INTR
|
|
设一组初始记录关键字为(72，73，71，23，94，16，5)，则以记录关键字72为基准的一趟快速排序结果为
|
答案是：(5，16，71，23，72，94，73)
|
|
快速排序是最好的一程排序方法
A.正确
B.错误
|
答案是：参考答案：错
|
|
有一种简单的排序算法，叫做计数排序。这种排序算法对一个待排序的表进行排序，并将排序结果存放到另一个新的表中。必须注意的是，表中所有待排序的关键字互不相同，计数排序算法针对表中的每个记录，扫描待排序的表一趟，统计表中有多少个记录的关键字比该记
|
答案是：① typedef struct {int key; datatype info }RecType ② void CountSort(RecType a[],b[],int n) //计数排序算法，将a中记录排序放入b中 {for(i=0;i
|
|
借助于快速排序的算法思想，在一组无序的记录中查找给定关键字值等于key的记录。设此组记录存放于数组r[l..n]中。若查找成功，则输出该记录在r数组中的位置及其值，否则显示“not find”信息。请简要说明算法思想并编写算法。
|
答案是：int index (RecType R[],int l,h,datatype key) {int i=l,j=h; while (ikey) j--; if (R[j].key==key) return j; while (i<=j && R[i].key
|
|
编写算法，对n个关键字取整数值的记录序列进行整理，以使所有关键字为负值的记录排在关键字为非负值的记录之前，要求： ① 采用顺序存储结构，至多使用一个记录的辅助存储空间； ② 算法的时间复杂度为O(n)。
|
答案是：void process (int A[n]){ low = 0; high = n-1; while ( low0) high++; if (low
|
|
设有顺序放置的n个桶，每个桶中装有一粒砾石，每粒砾石的颜色是红，白，蓝之一。要求重新安排这些砾石，使得所有红色砾石在前，所有白色砾石居中，所有蓝色砾石居后，重新安排时对每粒砾石的颜色只能看一次，并且只允许交换操作来调整砾石的位置。
|
答案是：void QkSort(rectype r[],int n) { // r为含有n个元素的线性表，元素是具有红、白和兰色的砾石，用顺序存储结构存储， //本算法对其排序，使所有红色砾石在前，白色居中，兰色在最后。 int i=1,j=1,k=n,temp; while (k!=j){ while (r[k].key==3) k--;// 当前元素是兰色砾石，指针左移 if (r[k].key==1) // 当前元素是红色砾石 if (i>=j){temp=r[k];r[k]=r[i];r[i]=temp; i++;} //左侧只有红色砾石，交换r[k]和r[i] else {temp=r[j];r[j]=r[i];r[i]=temp; j++; //左侧已有红色和白色砾石，先交换白色砾石到位 temp=r[k];r[k]=r[i];r[i]=temp; i++; //白色砾石（i所指）和待定砾石（j所指） } //再交换r[k]和r[i]，使红色砾石入位。 if (r[k].key==2) if (i<=j) { temp=r[k];r[k]=r[j];r[j]=temp; j++;} // 左侧已有白色砾石，交换r[k]和r[j] else { temp=r[k];r[k]=r[i];r[i]=temp; j=i+1;} //i、j分别指向红、白色砾石的后一位置 }//while if (r[k]==2) j++; /* 处理最后一粒砾石 else if (r[k]==1) { temp=r[j];r[j]=r[i];r[i]=temp; i++; j++; } //最后红、白、兰色砾石的个数分别为: i-1;j-i;n-j+1 }//结束QkSor算法
|
|
有n个记录存储在带头结点的双向链表中，现用双向冒泡排序法对其按上升序进行排序，请写出这种排序的算法。（注：双向冒泡排序即相邻两趟排序向相反方向冒泡）。
|
答案是：typedef struct node { ElemType data; struct node *prior,*next; }node，*DLinkedList; void TwoWayBubbleSort(DLinkedList la) //对存储在带头结点的双向链表la中的元素进行双向起泡排序。 {int exchange=1; // 设标记 DLinkedList p,temp,tail; head=la //双向链表头，算法过程中是向下起泡的开始结点 tail=null; //双向链表尾，算法过程中是向上起泡的开始结点 while (exchange) {p=head->next; //p是工作指针，指向当前结点 exchange=0; //假定本趟无交换 while (p->next!=tail) // 向下（右）起泡，一趟有一最大元素沉底 if (p->data>p->next->data) //交换两结点指针，涉及6条链 {temp=p->next; exchange=1;//有交换 p->next=temp->next;temp->next->prior=p //先将结点从链表上摘下 temp->next=p; p->prior->next=temp; //将temp插到p结点前 temp->prior=p->prior; p->prior=temp; } else p=p->next; //无交换，指针后移 tail=p; //准备向上起泡 p=tail->prior; while (exchange && p->prior!=head) //向上（左）起泡，一趟有一最小元素冒出 if (p->dataprior->data) //交换两结点指针，涉及6条链 {temp=p->prior; exchange=1; //有交换 p->prior=temp->prior;temp->prior->next=p； //先将temp结点从链表上摘下 temp->prior=p; p->next->prior=temp; //将temp插到p结点后（右） temp->next=p->next; p->next=temp; } else p=p->prior; //无交换，指针前移 head=p; //准备向下起泡 }// while (exchange) } //算法结束
|
|
试以单链表为存储结构，实现简单选择排序算法
|
答案是：void LinkedListSelectSort(LinkedList head) //本算法一趟找出一个关键字最小的结点，其数据和当前结点进行交换;若要交换指针，则须记下 //当前结点和最小结点的前驱指针 p=head->next; while(p!=null) {q=p->next; r=p; //设r是指向关键字最小的结点的指针 while (q!=null) {if(q->datadata) r=q; q:=q->next; } if(r!=p) r->data<-->p->data; p=p->next; }
|
|
对22个记录的有序表作折半查找，查找失败时，至少需要比较___个关键字。
|
答案是：
4
|
|
m阶B-树的非叶结点至少有m/2 (m为偶数)或m/2+1（m为奇数）棵子树。
A.正确
B.错误
|
答案是：参考答案：对
|
|
分别写出在散列表中插入和删除关键字为K的一个记录的算法，设散列函数为H，解决冲突的方法为链地址法。
|
答案是：bool insert(){ int data; cin>>data; int ant=hash(data); LinkList p=HT[ant]; //初始化散列表 while (p->next){ if(p->next->data==data) return false; p=p->next; } //找到插入位置 LinkList s; s=new LNode; s->data=data; s->next=p->next; p->next=s; //插入该结点 return true; } bool deletes(){ int data; cin>>data; int ant=hash(data); LinkList p=HT[ant]; //初始化散列表 while (p->next){ if(p->next->data==data){ LinkList s=p->next; p->next=s->next; delete s; //删除该结点 return true; } //找到删除位置 p=p->next； //遍历下一个结点 } return false; }
|
|
假设一棵平衡二叉树的每个结点都表明了平衡因子b，试设计一个算法，求平衡二叉树的高度。
|
答案是：int Height（BSTree t） // 求平衡二叉树t的高度 {level=0；p=t； while（p） {level++； // 树的高度增1 if（p->bf<0）p=p->rchild；//bf=-1 沿右分枝向下 //bf是平衡因子，是二叉树t结点的一个域，因篇幅所限，没有写出其存储定义 else p=p->lchild； //bf>=0 沿左分枝向下 }//while return （level）；//平衡二叉树的高度 } //算法结束
|
|
已知二叉树T的结点形式为（lling,data,count,rlink），在树中查找值为X的结点，若找到，则记数（count）加1，否则，作为一个新结点插入树中，插入后仍为二叉排序树，写出其非递归算法。
|
答案是：void SearchBST(BiTree &T,int target){ BiTree s,q,f; //以数据值target,新建结点s s=new BiTNode; s->data.x=target; s->data.count=0; s->lchild=s->rchild=NULL; if(!T){ T=s; return ; } //如果该树为空则跳出该函数 f=NULL; q=T; while (q){ if (q->data.x==target){ q->data.count++; return ; } //如果找到该值则计数加一 f=q; if (q->data.x>target) //如果查找值比目标值大，则为该树左孩子 q=q->lchild; else //否则为右孩子 q=q->rchild; } //将新结点插入树中 if(f->data.x>target) f->lchild=s; else f->rchild=s; }
|
|
已知二叉排序树采用二叉链表存储结构，根结点的指针为T，链结点的结构为（lchild,data,rchild），其中lchild，rchild分别指向该结点左、右孩子的指针，data域存放结点的数据信息。请写出递归算法，从小到大输出二叉排序树
|
答案是：void Print（BSTree t） // 中序输出以t为根的二叉排序树的结点 {if（t）{Print（t->lchild）； Coutdatarchild；//沿右分枝找第一个值≥x的结点 bst=p; //bst所指结点是值≥x的结点的树的根 if（p） {f=p; p=p->lchild ；//找第一个值data≥x）//沿左分枝向下，找第一个值lchild ；} //f是p的双亲结点的指针，指向第一个值≥x的结点 if(p) f->lchild=null; //双亲与找到的第一个值
|
|
试写一个判别给定二叉树是否为二叉排序树的算法。
|
答案是：#define true 1 #define false 0 typedef struct node {datatype data; struct node *lchild,*rchild;} *BTree; void JudgeBST（BTree T,int flag） // 判断二叉树是否是二叉排序树，本算法结束后，在调用程序中由flag得出结论。 { if（T!=null && flag） { Judgebst（T->lchild,flag）；// 中序遍历左子树 if（pre==null）pre=T；// 中序遍历的第一个结点不必判断 else if（pre->datadata）pre=T；//前驱指针指向当前结点 else{flag=flase；} //不是完全二叉树 Judgebst （T->rchild,flag）；// 中序遍历右子树 }//JudgeBST算法结束
|
|
试写出折半查找的递归算法。
|
答案是：int BinSrch（rectype r[ ]，int k，low，high） //在长为n的有序表中查找关键字k，若查找成功，返回k所在位置，查找失败返回0。 {if（low≤high） //low和high分别是有序表的下界和上界 {mid=（low+high）/2； if（r[mid].key==k）return （mid）； else if（r[mid].key>k）return （BinSrch（r,k，mid+1，high））; else return （BinSrch（r,k，low，mid-1））; } else return （0）；//查找失败。 }//算法结束
|
|
设无向图G中有n个顶点e条边，所有顶点的度数之和为m，则e和m有______关系。
|
答案是：
m=2e
|
|
对连通图进行深度优先遍历可以访问到该图中的所有顶点。
A.正确
B.错误
|
答案是：参考答案：对
|
|
采用邻接表存储结构，编写一个算法，判别无向图中任意给定的两个顶点之间是否存在一条长度为为k的简单路径。
|
答案是：int visited[MAXSIZE]; int exist_path_len(ALGraph G,int i,int j,int k) //判断邻接表方式存储的有向图G的顶点i到j是否存在长度为k的简单路径 {if(i==j&&k==0) return 1; //找到了一条路径,且长度符合要求 else if(k>0) {visited[i]=1; for(p=G.vertices[i].firstarc;p;p=p->nextarc) {l=p->adjvex; if(!visited[l]) if(exist_path_len(G,l,j,k-1)) return 1; //剩余路径长度减一 }//for visited[i]=0; //本题允许曾经被访问过的结点出现在另一条路径中 }//else return 0; //没找到 }//exist_path_len
|
|
试基于图的深度优先搜索策略写一算法，判别以邻接表方式存储的有向图中是否存在由顶点vi到顶点vj的路径（i≠j）。
|
答案是：int visited[MAXSIZE]; //指示顶点是否在当前路径上 int level＝1;//递归进行的层数 int exist_path_DFS(ALGraph G,int i,int j)//深度优先判断有向图G中顶点i到顶点j 是否有路径,是则返回1,否则返回0 { if(i==j) return 1; //i就是j else { visited[i]=1; for(p=G.vertices[i].firstarc;p;p=p->nextarc，level--) { level++; k=p->adjvex; if(!visited[k]&&exist_path(k,j)) return 1;//i下游的顶点到j有路径 }//for }//else if (level==1) return 0; }//exist_path_DFS
|
|
设计一个算法，求图G中距离顶点v的最短路径长度最大的一个顶点，设v可达其余各个顶点。
|
答案是：int ShortestPath_MAX(AMGraph G, int v0){ //用Dijkstra算法求距离顶点v0的最短路径长度最大的一个顶点m n=G.vexnum; //n为G中顶点的个数 for(v = 0; v
|
|
一个连通图采用邻接表作为存储结构，设计一个算法，实现从顶点v出发的深度优先遍历的非递归过程。
|
答案是：Void DFSn(Graph G,int v) { //从第v个顶点出发非递归实现深度优先遍历图G Stack s; SetEmpty(s); Push(s,v); While(!StackEmpty(s)) { //栈空时第v个顶点所在的连通分量已遍历完 Pop(s,k); If(!visited[k]) { visited[k]=TRUE; VisitFunc(k); //访问第k个顶点 //将第k个顶点的所有邻接点进栈 for(w=FirstAdjVex(G,k);w;w=NextAdjVex(G,k,w)) { if(!visited[w]&&w!=GetTop(s)) Push(s,w); //图中有环时w==GetTop(s) } } }
|
|
分别以邻接矩阵和邻接表作为存储结构，实现以下图的基本操作： ① 增加一个新顶点v，InsertVex(G, v)； ② 删除顶点v及其相关的边，DeleteVex(G, v); ③ 增加一条边，InsertArc(G, v, w); ④ 删
|
答案是：假设图G为有向无权图，以邻接矩阵作为存储结构四个算法分别如下： ① 增加一个新顶点v Status Insert_Vex(MGraph &G, char v)//在邻接矩阵表示的图G上插入顶点v { if(G.vexnum+1)>MAX_VERTEX_NUM return INFEASIBLE; G.vexs[++G.vexnum]=v; return OK; }//Insert_Vex ② 删除顶点v及其相关的边， Status Delete_Vex(MGraph &G,char v)//在邻接矩阵表示的图G上删除顶点v { n=G.vexnum; if((m=LocateVex(G,v))<0) return ERROR; G.vexs[m]<->G.vexs[n]; //将待删除顶点交换到最后一个顶点 for(i=0;i Status Insert_Arc(MGraph &G,char v,char w)//在邻接矩阵表示的图G上插入边(v,w) { if((i=LocateVex(G,v))<0) return ERROR; if((j=LocateVex(G,w))<0) return ERROR; if(i==j) return ERROR; if(!G.arcs[j].adj) { G.arcs[j].adj=1; G.arcnum++; } return OK; }//Insert_Arc ④ 删除一条边 Status Delete_Arc(MGraph &G,char v,char w)//在邻接矩阵表示的图G上删除边(v,w) { if((i=LocateVex(G,v))<0) return ERROR; if((j=LocateVex(G,w))<0) return ERROR; if(G.arcs[j].adj) { G.arcs[j].adj=0; G.arcnum--; } return OK; }//Delete_Arc 以邻接表作为存储结构，本题只给出Insert_Arc算法.其余算法类似。 Status Insert_Arc(ALGraph &G,char v,char w)//在邻接表表示的图G上插入边(v,w) { if((i=LocateVex(G,v))<0) return ERROR; if((j=LocateVex(G,w))<0) return ERROR; p=new ArcNode; p->adjvex=j;p->nextarc=NULL; if(!G.vertices.firstarc) G.vertices.firstarc=p; else { for(q=G.vertices.firstarc;q->q->nextarc;q=q->nextarc) if(q->adjvex==j) return ERROR; //边已经存在 q->nextarc=p; } G.arcnum++; return OK; }//Insert_Arc
|
|
设一棵二叉树的中序遍历序列为BDCA，后序遍历序列为DBAC，则这棵二叉树的先序遍历序列为____________________。
|
答案是：CBDA
|
|
由树转化成二叉树，该二叉树的右子树不一定为空。
A.正确
B.错误
|
答案是：参考答案：错
|
|
输出二叉树中从每个叶子结点到根结点的路径。
|
答案是：void AllPath(BTNode *b,ElemType path[],int pathlen) {int i; if (b!=NULL) {if (b->lchild==NULL && b->rchild==NULL) //*b为叶子结点 {cout << " " << b->data << "到根结点路径:" << b->data; for (i=pathlen-1;i>=0;i--) cout << endl; } else {path[pathlen]=b->data; //将当前结点放入路径中 pathlen++; //路径长度增1 AllPath(b->lchild,path,pathlen); //递归扫描左子树 AllPath(b->rchild,path,pathlen); //递归扫描右子树 pathlen--; //恢复环境 } }// if (b!=NULL) }//算法结束
|
|
求任意二叉树中第一条最长的路径长度，并输出此路径上各结点的值。
|
答案是：void LongestPath(BiTree bt)//求二叉树中的第一条最长路径长度 {BiTree p=bt,l[],s[]; //l, s是栈，元素是二叉树结点指针，l中保留当前最长路径中的结点 int i，top=0,tag[],longest=0; while(p || top>0) {while(p) {s[++top]=p；tag[top]=0; p=p->Lc;} //沿左分枝向下 if(tag[top]==1) //当前结点的右分枝已遍历 {if(!s[top]->Lc && !s[top]->Rc) //只有到叶子结点时，才查看路径长度 if(top>longest) {for(i=1;i<=top;i++) l[i]=s[i]; longest=top; top--;} //保留当前最长路径到l栈，记住最高栈顶指针，退栈 } else if(top>0) {tag[top]=1; p=s[top].Rc;} //沿右子分枝向下 }//while(p!=null||top>0) }//结束LongestPath
|
|
用按层次顺序遍历二叉树的方法，统计树中具有度为1的结点数目。
|
答案是：int Level(BiTree bt) //层次遍历二叉树，并统计度为1的结点的个数 {int num=0; //num统计度为1的结点的个数 if(bt){QueueInit(Q); QueueIn(Q,bt);//Q是以二叉树结点指针为元素的队列 while(!QueueEmpty(Q)) {p=QueueOut(Q); coutlchild && !p->rchild ||!p->lchild && p->rchild)num++; //度为1的结点 if(p->lchild) QueueIn(Q,p->lchild); //非空左子女入队 if(p->rchild) QueueIn(Q,p->rchild); //非空右子女入队 } // while(!QueueEmpty(Q)) }//if(bt) return(num); }//返回度为1的结点的个数
|
|
计算二叉树最大的宽度（二叉树的最大宽度是指二叉树所有层中结点个数的最大值）。
|
答案是：int Width(BiTree bt)//求二叉树bt的最大宽度 {if (bt==null) return (0); //空二叉树宽度为0 else {BiTree Q[];//Q是队列，元素为二叉树结点指针，容量足够大 front=1;rear=1;last=1; //front队头指针,rear队尾指针,last同层最右结点在队列中的位置 temp=0; maxw=0; //temp记局部宽度, maxw记最大宽度 Q[rear]=bt; //根结点入队列 while(front<=last) {p=Q[front++]; temp++; //同层元素数加1 if (p->lchild!=null) Q[++rear]=p->lchild; //左子女入队 if (p->rchild!=null) Q[++rear]=p->rchild; //右子女入队 if (front>last) //一层结束， {last=rear; if(temp>maxw) maxw=temp; //last指向下层最右元素, 更新当前最大宽度 temp=0; }//if }//while return (maxw); }//结束width
|
|
设计二叉树的双序遍历算法（双序遍历是指对于二叉树的每一个结点来说，先访问这个结点，再按双序遍历它的左子树，然后再一次访问这个结点，接下来按双序遍历它的右子树）。
|
答案是：void DoubleTraverse(BiTree T) { if(T == NULL) return; else if(T->lchild==NULL&&T->rchild==NULL) coutlchild); //递归遍历左子树 coutrchild); //递归遍历右子树 } }
|
|
交换二叉树每个结点的左孩子和右孩子。
|
答案是：void ChangeLR(BiTree &T) { BiTree temp; if(T->lchild==NULL&&T->rchild==NULL) return; else { temp = T->lchild; T->lchild = T->rchild; T->rchild = temp; }//交换左右孩子 ChangeLR(T->lchild); //递归交换左子树 ChangeLR(T->rchild); //递归交换右子树 }
|
|
判别两棵树是否相等。
|
答案是：int compareTree(TreeNode* tree1, TreeNode* tree2) //用分治的方法做，比较当前根，然后比较左子树和右子树 {bool tree1IsNull = (tree1==NULL); bool tree2IsNull = (tree2==NULL); if(tree1IsNull != tree2IsNull) { return 1; } if(tree1IsNull && tree2IsNull) {//如果两个都是NULL，则相等 return 0; }//如果根节点不相等，直接返回不相等，否则的话，看看他们孩子相等不相等 if(tree1->c != tree2->c) { return 1; } return (compareTree(tree1->left,tree2->left)&compareTree(tree1->right,tree2->right)) (compareTree(tree1->left,tree2->right)&compareTree(tree1->right,tree2->left)); }//算法结束
|
|
以二叉链表作为二叉树的存储结构，编写以下算法： （1）统计二叉树的叶结点个数。
|
答案是：int LeafNodeCount(BiTree T) { if(T==NULL) return 0; //如果是空树，则叶子结点个数为0 else if(T->lchild==NULL&&T->rchild==NULL) return 1; //判断结点是否是叶子结点（左孩子右孩子都为空），若是则返回1 else return LeafNodeCount(T->lchild)+LeafNodeCount(T->rchild); }
|
|
试找出满足下列条件的二叉树 ① 先序序列与后序序列相同 ②中序序列与后序序列相同 ③ 先序序列与中序序列相同 ④中序序列与层次遍历序列相同
|
答案是：
先序遍历二叉树的顺序是“根—左子树—右子树”，中序遍历“左子树—根—右子树”，后序遍历顺序是：“左子树—右子树―根＂，根据以上原则有 ① 或为空树，或为只有根结点的二叉树 ② 或为空树，或为任一结点至多只有左子树的二叉树． ③ 或为空树，或为任一结点至多只有右子树的二叉树． ④ 或为空树，或为任一结点至多只有右子树的二叉树
|
|
二维数组S，行下标i从0到7，列下标j从0 到9，每个元素占3个字节，若从首地址S开始以列序为主序将元素连续存放在存储器内，则元素S [4][7]的起始地址为 。
|
答案是：
S+180
|
|
串是元素类型为字符型的线性表。
A.正确
B.错误
|
答案是：参考答案：对
|
|
设任意n个整数存放于数组A(1:n)中，试编写算法，将所有正数排在所有负数前面（要求算法复杂度为0(n)）。
|
答案是：void Arrange(int A[],int n) //n个整数存于数组A中，本算法将数组中所有正数排在所有负数的前面 {int i=0,j=n-1,x; //用类C编写，数组下标从0开始 while(i0) i++; while(i
|
|
设二维数组a[1..m, 1..n] 含有m*n 个整数。 ① 写一个算法判断a中所有元素是否互不相同?输出相关信息(yes/no)； ② 试分析算法的时间复杂度。
|
答案是：int JudgEqual(ing a[m][n],int m,n) //判断二维数组中所有元素是否互不相同，如是，返回1；否则，返回0。 {for(i=0;i
|
|
已知字符串S1中存放一段英文，写出算法format(s1,s2,s3,n),将其按给定的长度n格式化成两端对齐的字符串S2, 其多余的字符送S3。
|
答案是：void format (char *s1,*s2,*s3) //将字符串s1拆分成字符串s2和字符串s3，要求字符串s2是长n且两端对齐 {char *p=s1, *q=s2; int i=0; while(*p!= '\0' && *p== ' ') p++;//滤掉s1左端空格 if(*p== '\0') {cout<<"字符串s1为空串或空格串"<
|
|
编写算法，实现下面函数的功能。函数void insert(char*s,char*t,int pos)将字符串t插入到字符串s中，插入位置为pos。假设分配给字符串s的空间足够让字符串t插入。（说明：不得使用任何库函数）
|
答案是：void insert(char *s,char *t,int pos) //将字符串t插入字符串s的第pos个位置。 {int i=1,x=0; char *p=s,*q=t; //p，q分别为字符串s和t的工作指针 if(pos<1) {cout<<“pos参数位置非法”<=pos ;j--){*(p+x)=*p; p--;}//串s的pos后的子串右移，空出串t的位置。 q--; //指针q回退到串t的最后一个字符 for(j=1;j<=x;j++) *p--=*q--; //将t串插入到s的pos位置上
|
|
写一个递归算法来实现字符串逆序存储，要求不另设串存储空间。
|
答案是：void InvertStore(char A[]) //字符串逆序存储的递归算法。 {char ch; static int i = 0;//需要使用静态变量 cin>>ch; if (ch!= '.') //规定'.'是字符串输入结束标志 {InvertStore(A); A[i++] = ch;//字符串逆序存储 } A[i] = '\0'; //字符串结尾标记 }
|
|
写一个算法统计在输入字符串中各个不同字符出现的频度并将结果存入文件（字符串中的合法字符为A-Z这26个字母和0-9这10个数字）。
|
答案是：void Count（） //统计输入字符串中数字字符和字母字符的个数。 ｛int i，num[36]； char ch； for（i＝0；i<36；i++）num[i]＝０；// 初始化 while（（ch＝getchar（））!=‘#’） //‘#’表示输入字符串结束。 if（‘0’<=ch<=‘9’）｛i=ch－48;num[i]++；｝ // 数字字符 else if（‘A’<=ch<=‘Z’）｛i=ch-65+10;num[i]++；｝// 字母字符 for（i=0；i<10；i++） // 输出数字字符的个数 cout<<“数字”<
|
|
请将香蕉banana用工具 H( )—Head( )，T( )—Tail( )从L中取出。 L=(apple,(orange,(strawberry,(banana)),peach),pear)
|
答案是：
H（H（T（H（T（H（T（L）））））））
|
|
数组A中，每个元素A[i,j]的长度均为32个二进位,行下标从-1到9，列下标从1到11，从首地址S开始连续存放主存储器中，主存储器字长为16位。求： ① 存放该数组所需多少单元？ ② 存放数组第4列所有元素至少需多少单元？ ③ 数组按行存
|
答案是：
每个元素32个二进制位，主存字长16位，故每个元素占2个字长，行下标可平移至1到11。 （1）242 （2）22 （3）s+182 （4）s+142
|
|
设目标为t=“abcaabbabcabaacbacba”,模式为p=“abcabaa” ① 计算模式p的naxtval函数值； ② 不写出算法,只画出利用KMP算法进行模式匹配时每一趟的匹配过程。
|
答案是：
① p的nextval函数值为0110132。（p的next函数值为0111232）。 ② 利用KMP(改进的nextval)算法，每趟匹配过程如下： 第一趟匹配： abcaabbabcabaacbacba abcab(i=5,j=5) 第二趟匹配： abcaabbabcabaacbacba abc(i=7,j=3) 第三趟匹配： abcaabbabcabaacbacba a(i=7,j=1) 第四趟匹配： abcaabbabcabaac bacba (成功) abcabaa(i=15,j=8)
|
|
已知模式串t=‘abcaabbabcab’写出用KMP法求得的每个字符对应的next和nextval函数值。
|
答案是：模式串t的next和nextval值如下： j 1 2 3 4 5 6 7 8 9 10 11 12 t串 a b c a a b b a b c a b next[j] 0 1 1 1 2 2 3 1 2 3 4 5 nextval[j] 0 1 1 0 2 1 3 0 1 1 0 5
|
|
不论是入队列操作还是入栈操作，在顺序存储结构上都需要考虑“溢出”情况。
|
答案是：
对
|
|
最大容量为n的循环队列，队尾指针是rear，队头是front，若牺牲一个空间不用，则队列满的条件是____________________。
|
答案是：(rear+1)%n==front
|
|
已知f为单链表的表头指针, 链表中存储的都是整型数据，试写出实现下列运算的递归算法： ① 求链表中的最大整数； ② 求链表的结点个数； ③ 求所有整数的平均值。
|
答案是：① int GetMax(LinkList p) { if(!p->next) return p->data; else { int max=GetMax(p->next); return p->data>=max ? p->data:max; } } ② int GetLength(LinkList p) { if(!p->next) return 1; else { return GetLength(p->next)+1; } } ③ double GetAverage(LinkList p , int n) { if(!p->next) return p->data; else { double ave=GetAverage(p->next,n-1); return (ave*(n-1)+p->data)/n; } }
|
|
如果允许在循环队列的两端都可以进行插入和删除操作。要求： ① 写出循环队列的类型定义； ② 写出“从队尾删除”和“从队头插入”的算法。
|
答案是：① #define M 队列可能达到的最大长度 typedef struct {elemtp data[M]; int front,rear; }cycqueue; ② elemtp delqueue ( cycqueue Q) //Q是如上定义的循环队列，本算法实现从队尾删除，若删除成功，返回被删除元素，否则给出出错信息。 {if (Q.front==Q.rear) { cout<<"队列空"<
|
|
假设以数组Q[m]存放循环队列中的元素, 同时设置一个标志tag，以tag == 0和tag == 1来区别在队头指针(front)和队尾指针(rear)相等时，队列状态为“空”还是“满”。试编写与此结构相应的插入(enqueue)和删除(
|
答案是：(1)初始化 SeQueue QueueInit(SeQueue Q) {//初始化队列 Q.front=Q.rear=0; Q.tag=0; return Q; } (2)入队 SeQueue QueueIn(SeQueue Q,int e) {//入队列 if((Q.tag==1) && (Q.rear==Q.front)) cout<<"队列已满"<
|
|
假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素站点(注意不设头指针) ，试编写相应的置空队、判队空 、入队和出队等算法。
|
答案是：typedef struct queuenode {Datatype data; struct queuenode *next; }QueueNode; //以上是结点类型的定义 typedef struct {queuenode *rear; }LinkQueue; //只设一个指向队尾元素的指针 (1) 置空队 void InitQueue( LinkQueue *Q) { //置空队：就是使头结点成为队尾元素 QueueNode *s; Q->rear = Q->rear->next;//将队尾指针指向头结点 while (Q->rear!=Q->rear->next)//当队列非空，将队中元素逐个出队 {s=Q->rear->next; Q->rear->next=s->next; delete s; }//回收结点空间 } (2) 判队空 int EmptyQueue( LinkQueue *Q) { //判队空。当头结点的next指针指向自己时为空队 return Q->rear->next->next==Q->rear->next; } (3) 入队 void EnQueue( LinkQueue *Q, Datatype x) { //入队。也就是在尾结点处插入元素 QueueNode *p=new QueueNode;//申请新结点 p->data=x; p->next=Q->rear->next;//初始化新结点并链入 Q-rear->next=p; Q->rear=p;//将尾指针移至新结点 } (4) 出队 Datatype DeQueue( LinkQueue *Q) {//出队,把头结点之后的元素摘下 Datatype t; QueueNode *p; if(EmptyQueue( Q )) Error("Queue underflow"); p=Q->rear->next->next; //p指向将要摘下的结点 x=p->data; //保存结点中数据 if (p==Q->rear) {//当队列中只有一个结点时，p结点出队后，要将队尾指针指向头结点 Q->rear = Q->rear->next; Q->rear->next=p->next; } else Q->rear->next->next=p->next;//摘下结点p delete p;//释放被删结点 return x; }
|
|
目前为：
1/4
页
首页 上页 下页 尾页
|
