以下算法是求取某带头结点的单链表的长度，请补充完整代码。 int LinkLength（LinkList L) { Node* p=L-＞next; int i=0; ...... //补充此处代码 return i; //返回链表长度 }
以下算法是求取某带头结点的单链表的长度，请补充完整代码。 int LinkLength（LinkList L) { Node* p=L-＞next; int i=0; ...... //补充此处代码 return i; //返回链表长度 }
参考答案和解析
head -＞next==NULL
相关考题：
函数 main() 的功能是 : 在带头结点的单链表中查找数据域中值最小的结点 . 请填空#include stdio.hstruct node{ int data;struct node *next;};int min(struct node *first)/* 指针 first 为链表头指针 */{ strct node *p; int m;p=first-next; m=p-data;p=p-next;for(;p!=NULL;p= _[20]_______ )if(p-datam) m=p-data;return m;}
●试题三阅读下列说明和C代码，将应填入(n)处的字句写在答题纸的对应栏内。【说明】本题给出四个函数，它们的功能分别是：1.int push(PNODE *top，int e)是进栈函数，形参top是栈顶指针的指针，形参e是入栈元素。2.int pop(PNODE *top，int *e)是出栈函数，形参top是栈顶指针的指针，形参e作为返回出栈元素使用。3.int enQueue(PNODE *tail，int e)是入队函数，形参tail是队尾指针的指针，形参e是入队元素。4.int deQueue(PNODE *tail，int *e)是出队函数，形参tail是队尾指针的指针，形参e作为返回出队元素使用。以上四个函数中，返回值为0表示操作成功，返回值为-1表示操作失败。栈是用链表实现的；队是用带有辅助结点(头结点)的单向循环链表实现的。两种链表的结点类型均为：typedef struct node{int value；struct node *next；}NODE，*PNODE；【函数1】int push(PNODE *top，int e){PNODE p=(PNODE)malloc (sizeof(NODE))；if (!p) return-1；p- value =e；(1) ；.*top=p；return 0；}【函数2】int pop (PNODE *top，int *e){PNODE p=*top；if(p==NULL)return-1；*e=p-value；(2) ；free(p)；return 0；}【函数3】int enQueue (PNODE *tail，int e){PNODE p，t；t=*tail；p=(PNODE)malloc(sizeof(NODE))；if(!p)return-l；p-value=e；p-next=t-next；(3) ；*tail=p；return 0；}【函数4】int deQueue(PNODE *tail，int *e){PNODE p，q；if((*tail)-next==*tail)return -1；p=(*tail)-next；q=p-next；*e=q-value；(4) =q-next；if(*tail==q) (5) ；free(q)；return 0；}
●试题二阅读下列函数说明和C代码，将应填入(n)处的字句写在答题纸的对应栏内。【说明2．1】L为一个带头结点的循环链表。函数deletenode(LinkList L，int c)的功能是删除L中数据域data的值大于c的所有结点，并由这些结点组建成一个新的带头结点的循环链表，其头指针作为函数的返回值。【函数2．1】LinkList deletenode(LinkList L，int c){LinkList Lc，p，pre；pre=L；p= (1) ；Lc=(LinkList)malloc(sizeof(ListNode))；Lc-next=Lc；while(p!=L)if(p-datac){(2) ;(3) ；Lc-next=p；p=pre-next；}else{pre=p；p=pre-next；}return Lc；}【说明2．2】递归函数dec_to_k_2(int n，int k)的功能是将十进制正整数n转换成k(2≤k≤9)进制数，并打印。【函数2．2】dec_to_k_2(int n，int k){∥将十进制正整数n转换成k(2≤k≤9)进制数if(n!=0){dec_to_k_2( (4) ，k)；printf("％d"， (5) )；}}
●试题三阅读下列函数说明和C代码，将应填入(n)处的字句写在答题纸的对应栏内。【说明3．1】假设以带头结点的单循环链表作非递减有序线性表的存储结构。函数deleteklist(LinkList head)的功能是删除表中所有数值相同的多余元素，并释放结点空间。例如：链表初始元素为：(7，10，10，21，30，42，42，42，51，70)经算法操作后变为：(7，10，21，30，42，51，70)【函数3．1】void deleteklist(LinkList head){LinkNode*p，*q；p=head-next；while(p!=head){q=p-next；while( (1) ){(2) ；free(q)；q=p-next；}p=p-next；}}【说明3．2】已知一棵完全二叉树存放于一个一维数组T［n］中，T［n］中存放的是各结点的值。下面的程序的功能是：从T［0］开始顺序读出各结点的值，建立该二叉树的二叉链表表示。【函数3．2】#includeistream．htypedef struct node {int data；stuct node leftChild，rightchild；}BintreeNode；typedef BintreeNode*BinaryTree；void ConstrncTree(int T［］，int n，int i，BintreeNode*＆ptr){if(i=n) (3) ；∥置根指针为空else{ptr=-(BTNode*)malloc(sizeof(BTNode))ptr-data=T［i］；ConstrucTree(T，n，2*i+1， (4) )；ConstrucTree(T，n， (5) ，ptr-rightchild)；}}main(void){/*根据顺序存储结构建立二叉链表*／Binarytree bitree；int n；printf("please enter the number of node:＼n％s"；n)；int*A=(int*)malloc(n*sizeof(int))；for(int i=0；i＜n；i＋＋)scanf("％d，A+i)；/*从键盘输入结点值*/for(int i=0；i＜n；i＋＋)printf("％d"，A［i］)；ConstructTree(A，n，0，bitree)；}
mystrlen函数的功能是计算str所指字符中的长度，并作为函数值返回，请填空。int mystrlen(char * str){ int i；for(i=0；【 】!='\0'；i++)；return(i)；}
●试题四阅读下列程序说明，将在空缺处填入正确的内容。【程序说明】定义一个多边形结构：struct polygon实现以下内容： (1) 建立该结构的链表：create函数是创建链表，每输入一个结点的数据，就把该结点加入到链表当中，它返回创建的链表的头指针。 (2) 显示链表的各个结点数据：结点数据包括：多边形顶点数、各顶点的纵横坐标、当多边形顶点数为0时，链表创建结束。 (3) 编写一个函数disp，删除链表中的所有结点。需要注意的是：要先释放结点数据内存，再删除结点，如果在释放结点数据内存单元之前删除结点，则无法找到结点数据内存单元的地址，也就无法释放数据的内存单元。【程序】#include"iostream.h"#include"iomanip.h"struct polygon{int n；int *x；int *y；polygon *next；}；void Push(polygon* head，int n){polygon*newNode=new polygon；newNode=new polygon；newNode－next= (1) ；newNode－x=new int[n]；newNode－y=new int[n]；newNode－n= (2) ；for(int i=0；i= (3) ；i++){cout"请输入多边形各顶点x、y坐标，坐标值之间用空格分隔："；cinnewNode-x[i]newNode-y[i]；}(4) =head；// 在head前不需要额外的*head=newNode；}polygon *create(){polygon*head=NULL；polygon*tail；int n；cout"请输入多边形顶点的个数(顶点个数为0时结束)："；cinn；if(n==0)return (5) ；Push(head， (6) ；tail=head；cout"请输入多边形顶点的个数(顶点个数为0时结束)："；cinn；while(n!=0){Push(tail－next， (7) ；//在tail－next增加结点tail=tail－next；//advance tail to point to last nodecout"请输入多边形顶点的个数(顶点个数为0时结束)："；cinn；}return head；}void disp(polygon*head){int i，No=1；coutsetw (10) "x"setw (6) "y"endl；while(head!=NULL){cout"第"No"结点："endl;for(i=0；i=head－n－１；i++)coutsetw (10) head－x[i]setw (6) head－y[i]endl；(8) ；head= (9) ;}//Match while statement}void del(polygon*head){polygon*p；while(head!=NULL){p= (10) ；head=head－next；delete p－x；delete P－y；deletep；}//Match while statement}void main(){polygon*head；head=create()；disp(head)；del(head)；}
已知bead指向一个带头结点的单向链表，链表中每个结点包含数据域(data)和指针域(next)，数据域为整型。以下函数求出链表中所有连接点数据域的和值作为函数值返回。请在横线处填入正确内容。{ int data； struct link *next；}main(){ struct link *head；sam(______)；{stmct link *p；int s=0；p=head-＞next；while(p){s+=p-＞data；p=p-＞next；}return(s)；}
阅读下列说明和C代码，将应填入(n)处的字句写在对应栏内。【说明】本题给出四个函数，它们的功能分别是：1．int push(PNODE*top，int e)是进栈函数，形参top是栈顶指针的指针，形参e是入栈元素。2．int pop(PNODE*top，int*e)是出栈函数，形参top是栈顶指针的指针，形参e作为返回出栈元素使用。3．int enQueue(PNODE*tail，int e)是入队函数，形参tail是队尾指针的指针，形参e是入队元素。4．int deQueue(PNODE*tail，int*e)是出队函数，形参tail是队尾指针的指针，形参e作为返回出队元素使用。以上四个函数中，返回值为。表示操作成功，返回值为-1表示操作失败。栈是用链表实现的；队是用带有辅助结点(头结点)的单向循环链表实现的。两种链表的结点类型均为：typedef struct node {int value;struct node * next;} NODE, * PNODE;【函数1】int push(PNOOE * top,int e){PNODE p = (PNODE) malloc (sizeof (NODE));if (! p) return-1;p-＞value=e;(1);*top=p;return 0;}【函数2】int pop (PNODE * top,int * e){PNODE p = * top;if(p == NULL) return-1;* e = p-＞value;(2);free(p);return 0;}【函数3】int enQueue (PNODE * tail,int e){ PNODE p,t;t= *tail;p = (PNODE) malloc(sizeof(NODE));if(!p) return-1;p-＞value=e;p-＞next=t-＞next;(3);* tail = p;return 0;}【函数4】int deQueue(PNODE * tail,int * e){ PNODE p,q;if(( * tail)-＞next == * tail) return-1;p= (* tail)-＞next;q = p -＞next;* e =q -＞value;(4)=q-＞next;if(,tail==q) (5);free(q);return 0;}
函数min()的功能是:在带头结点的单链表中查找数据域中值最小的结点。请填空includestruc 函数min()的功能是：在带头结点的单链表中查找数据域中值最小的结点。请填空include ＜stdio.h＞struct node{ int data;struct node *next;};int min(struct node *first)/*指针first为链表头指针*/{ struct node *p; int m;p=first-＞next; re=p-＞data; p=p-＞next;for( ;p!=NULL;p=【 】)if(p-＞data＜m ) re=p-＞data;return m;}
阅读以下函数说明和C语言函数，将应填入(n)处的字句写在对应栏内。[说明1]L为一个带头结点的循环链表。函数LinkList deletenode(LinkList L,int c)的功能是删除L中数据域data的值大于C的所有结点，并由这些结点组建成一个新的带头结点的循环链表，其头指针作为函数的返回值。[C函数1]LinkList deletenode(LinkList L,int c){LinkList Lc,P,pre;pre=L;p=(1);Lc=(LinkList)malloc(sizeof(Listnode));Lc-＞next=Lc;while(P!=L)if(p-＞data＞C){(2);(3);Lc-＞next=p;p=pre-＞next;}else{pre=p;p=pre-＞next;}return Lc;}[说明2]递归函数dec_to_k_2(int n,int k)的功能是将十进制正整数n转换成k(2≤k≤9)进制数，并打印。[C函数2]dec to k 2(int n,int k){ if(n!=O){dec to k 2( (4) ,k);printf("%d", (5) );}}
阅读下列函数说明和C代码，将应填入(n)处的字句写在对应栏内。【说明2.1】L为一个带头结点的循环链表。函数deletenode(LinkList L, int c)的功能是删除L中数据域data的值大于c的所有结点，并由这些结点组建成一个新的带头结点的循环链表，其头指针作为函数的返回值。【函数2.1】LinkList deletenode(LinkList L, int c){LinkList Lc,p,pre;pre=L;p=(1);Lc=(LinkList)malloc(sizeof(ListNode) );Lc-＞next=Lcwhile(p!=L)if(p-＞data＞c){(2);(3);Lc-＞next=p;p=pre-＞next;}else{pre=p;p=pre-＞next;}return Lc;}【说明2.2】递归函数dec_to_k_2(int n, int k)的功能是将十进制正整数n转换成k＜2≤k≤9)进制数，并打印。【函数2.2】dec_to_k_2(int n, int k){ /*将十进制正整数n转换成k(2≤k≤9)进制数*/if(n!=0){dec_to_k_2((4),k);printf("%d",(5));}}
执行下列语句后指针及链表的示意图为(43)。L = (LinkList) malloc ( sizeof (LNode) );P = L;for(i =0;i ＜=3;i ++) {P→next = (LinkList) malloc (sizeof (LNode));P = P→next;P→data = i * i + 1;}A．B．C．D．
下列给定程序中，是建立一个带头结点的单向链表，并用随机函数为各结点数据域赋值。函数fun的作用是求出单向链表结点(不包括头结点)数据域中的最大值，并且作为函数值返回。请改正程序指定部位的错误，使它能得到正确结果。[注意] 不要改动main函数，不得增行或删行，也不得更改程序的结构。[试题源程序]include＜stdio.h＞include＜stdlib.h＞typedef struct aa{int data;struct aa *next;}NODE;fun(NODE *h){int max=-1;NODE *p;/***********found************/p=h;while(p){if(p-＞data＞max)max=p-＞data;/************found************/p=h-＞next;}return max;}outresult(int s, FILE *Pf){fprintf(pf, "\nThe max in link: %d\n", s);}NODE *creatlink(int n, int m){NODE *h, *p, *s, *q;int i, x;h=p=(NODE *)malloc(sizeof(NODE));h-＞data=9999;for(i=1; i＜=n; i++){s=(NODE *)malloc(sizeof(NODE));s-＞data=rand()%m; s-＞next=p-＞next;p-＞next=s; p=p-＞next;}p-＞next=NULL;return h;}outlink(NODE *h, FILE *pf){NODE *p;p=h-＞next;fprintf(Pf, "\nTHE LIST:\n\n HEAD");while(P){fprintf(pf, "-＞%d", P-＞datA); p=p-＞next;}fprintf(pf, "\n");}main(){NODE *head; int m;head=cteatlink(12,100);outlink(head, stdout);m=fun(head);printf("\nTHE RESULT"\n");outresult(m, stdout);}
阅读以下说明和 C 代码，填补代码中的空缺，将解答填入答题纸的对应栏内。 【说明】 函数 GetListElemPtr(LinkList L，int i)的功能是查找含头结点单链表的第i个元素。若找到，则返回指向该结点的指针，否则返回空指针。 函数DelListElem(LinkList L，int i，ElemType *e) 的功能是删除含头结点单链表的第 i个元素结点，若成功则返回 SUCCESS ，并由参数e 带回被删除元素的值，否则返回ERROR 。 例如，某含头结点单链表 L 如图 4-1 (a) 所示，删除第 3 个元素结点后的单链表如 图 4-1 (b) 所示。图4-1define SUCCESS 0 define ERROR -1 typedef int Status; typedef int ElemType; 链表的结点类型定义如下: typedef struct Node{ ElemType data; struct Node *next; }Node ,*LinkList; 【C 代码】 LinkList GetListElemPtr(LinkList L ，int i) { /* L是含头结点的单链表的头指针，在该单链表中查找第i个元素结点: 若找到，则返回该元素结点的指针，否则返回NULL */ LinkList p; int k; /*用于元素结点计数*/ if (i1 ∣∣ !L ∣∣ !L-next) return NULL; k = 1; P = L-next; / *令p指向第1个元素所在结点*/ while (p （1） ) { /*查找第i个元素所在结点*/ （2） ; ++k; } return p; } Status DelListElem(LinkList L ，int i ，ElemType *e) { /*在含头结点的单链表L中，删除第i个元素，并由e带回其值*/ LinkList p，q; /*令p指向第i个元素的前驱结点*/ if (i==1) （3） ； else p = GetListElemPtr(L ，i-1); if (!p ∣∣ !p-next) return ERROR; /*不存在第i个元素*/ q = (4) ； /*令q指向待删除的结点*/ p-next = q-next; /*从链表中删除结点*/ (5) ； /*通过参数e带回被删除结点的数据*/ free(q); return SUCCESS; }
阅读以下说明和 C 函数，填补代码中的空缺，将解答填入答题纸的对应栏内。 【说明】 函数 Combine(LinkList La，LinkList Lb)的功能是:将元素呈递减排列的两个含头结 点单链表合并为元素值呈递增(或非递减)方式排列的单链表，并返回合并所得单链表 的头指针。例如，元素递减排列的单链表 La 和 Lb 如图 4-1 所示，合并所得的单链表如图 4-2 所示。图 4-1 合并前的两个链表示意图图 4-2 合并后所得链表示意图设链表结点类型定义如下： typedef struct Node{ int data; struct Node *next; }Node ,*LinkList; 【C 函数】 LinkList Combine(LinkList La ，LinkList Lb) { //La 和 Lb 为含头结点且元素呈递减排列的单链表的头指针 //函数返回值是将 La 和 Lb 合并所得单链表的头指针 //且合并所得链表的元素值呈递增（或非递减)方式排列 （1） Lc ,tp ,pa ,pb;; //Lc 为结果链表的头指针 ，其他为临时指针 if (!La) return NULL; pa = La-next; //pa 指向 La 链表的第一个元素结点 if (!La) return NULL; pa = La-next; //pb 指向 Lb 链表的第一个元素结点 Lc = La; //取 La 链表的头结点为合并所得链表的头结点 Lc-next = NULL; while ( （2） ){ //pa 和 pb 所指结点均存在(即两个链表都没有到达表尾) //令tp指向 pa 和 pb 所指结点中的较大者 if (pa-data pb-data) { tp = pa; pa = pa-next; } else{ tp = pb; pb = pb-next; } （3） = Lc-next; //tp 所指结点插入 Lc 链表的头结点之后 Lc-next = （4） ; } tp = (pa)? pa : pb; //设置 tp 为剩余结点所形成链表的头指针 //将剩余的结点合并入结果链表中， pa 作为临时指针使用 while (tp) { pa = tp-next; tp-next = Lc-next; Lc-next = tp; （5） ; } return Lc; }
int AA(LNode *HL , ElemType x){int n=0; LNode *p=HL;while (p!=NULL){if (p->data= =x) n++;p=p->next; }return n;}对于结点类型为LNode的单链表，以上算法的功能为：()
阅读以下说明和C代码，填补代码中的空缺，将解答填入答题纸的对应栏内。[说明]函数GetListElemPtr(LinkList L，int i)的功能是查找含头结点单链表的第i个元素。若找到，则返回指向该结点的指针，否则返回空指针。函数DelListElem(LinkList L,int i,ElemType *e)的功能是删除含头结点单链表的第i个元素结点，若成功则返回SUCCESS，并由参数e带回被删除元素的值，否则返回ERROR。例如，某含头结点单链表L如下图(a)所示，删除第3个元素结点后的单链表如下图(b)所示。1.jpg#define SUCCESS 0 #define ERROR -1 typedef intStatus; typedef intElemType;链表的结点类型定义如下：typedef struct Node{ ElemType data; struct Node *next; }Node,*LinkList; [C代码] LinkListGetListElemPtr(LinkList L,int i) { /*L是含头结点的单链表的头指针,在该单链表中查找第i个元素结点; 若找到,则返回该元素结点的指针,否则返回NULL */ LinkList p; int k; /*用于元素结点计数*/ if(i＜1 || !L || !L-＞next) return NULL; k=1; p=L-＞next; /*令p指向第1个元素所在结点*/ while(p ++k; } return p; } StatusDelListElem(LinkList L,int i,ElemType *e) { /*在含头结点的单链表L中,删除第i个元素,并由e带回其值*/ LinkList p,q; /*令P指向第i个元素的前驱结点*/ if(i==1) ______; else p=GetListElemPtr(L,i-1); if(!P || !p-＞next) return ERROR; /*不存在第i个元素*/ q=______; /*令q指向待删除的结点*/ p-＞next=q-＞next; //从链表中删除结点*/ ______; /*通过参数e带回被删除结点的数据*/ free(q); return SUCCESS; }
阅读以下说明和C函数，填补代码中的空缺，将解答填入答题纸的对应栏内。[说明]函数ReverseList(LinkList headptr)的功能是将含有头结点的单链表就地逆置。处理思路是将链表中的指针逆转，即将原链表看成由两部分组成：已经完成逆置的部分和未完成逆置的部分，令s指向未逆置部分的第一个结点，并将该结点插入已完成部分的表头(头结点之后)，直到全部结点的指针域都修改完成为止。例如，某单链表如图1所示，逆置过程中指针s的变化情况如图2所示。链表结点类型定义如下：typedef struct Node{ int data; Struct Node *next; }Node,*LinkList; [C函数] void ReverseList(LinkList headptr) { //含头结点的单链表就地逆置,headptr为头指针 LinkList p,s; if(______) return; //空链表(仅有头结点)时无需处理 P=______; //令P指向第一个元素结点 if(!P-＞next) return; //链表中仅有一个元素结点时无需处理 s=p-＞next; //s指向第二个元素结点 ______ =NULL; //设置第一个元素结点的指针域为空 while(s){ p=s; //令p指向未处理链表的第一个结点 s= ______; p-＞next=headptr-＞next; //将p所指结点插入已完成部分的表头 headptr-＞next= ______; } }
阅读以下说明和C函数，填补代码中的空缺，将解答填入答题纸的对应栏内。[说明]函数Combine(LinkList La，LinkList Lb)的功能是：将元素呈递减排列的两个含头结点单链表合并为元素值呈递增(或非递减)方式排列的单链表，并返回合并所得单链表的头指针。例如，元素递减排列的单链表La和Lb如图1所示，合并所得的单链表如图2所示。设链表结点类型定义如下：typedef Struct Node{ int data; struct Node*next; }Node,*LinkList; [C函数] LinkListCombine(LinkList La,LinkList Lb) { //La和Lb为含头结点且元素呈递减排列的单链表的头指针 //函数返回值是将La和Lb合并所得单链表的头指针 //且合并所得链表的元素值呈递增(或非递减)方式排列 ______Lc,tp,pa,pb; //Lc为结果链表的头指针,其他为临时指针 if(!La)returnNULL; pa=La-＞next; //pa指向La链表的第一个元素结点 if(!Lb) returnNULL; pb=Lb-＞next; //pb指向Lb链表的第一个元素结点 Lc=La; //取La链表的头结点为合并所得链表的头结点 Lc-＞next=NULL; while(______) { //pa和pb所指结点均存在(即两个链表都没有到达表尾) //令tp指向pa和pb所指结点中的较大者 if(pa-＞data＞pb-＞data){ tp=pa; pa=pa-＞next; } else{ tp=pb; pb=pb-＞next; } ______ =Lc-＞next; //tp所指结点插入Lc链表的头结点之后 Lc-＞next=______; } tp=(pa)?pa:pb; //设置tp为剩余结点所形成链表的头指针 //将剩余的结点合并入结果链表中,pa作为临时指针使用 while (tp) { pa=tp-＞next; tp-＞next=Lc-＞next; Lc-＞next=tp; ______; } return Lc; }
函数实现单链表的插入算法，请在空格处将算法补充完整。int ListInsert(LinkList L,int i,ElemType e){ LNode *p,*s;int j; p=L;j=0; while((p!=NULL)(jnext;j++; } if(p==NULL||ji-1) return ERROR; s=(LNode *)malloc(sizeof(LNode)); s-data=e; (1) ; (2) ; return OK;}/*ListInsert*/
函数GetElem实现返回单链表的第i个元素，请在空格处将算法补充完整。 int GetElem(LinkList L,int i,Elemtype *e){ LinkList p；int j；p=L-next;j=1; while(pji) return ERROR;*e= (2) ;return OK;}
写出算法的功能。int L(head){ node * head; int n=0; node *p; p=head; while(p!=NULL) { p=p-next; n++; } return(n); }
函数实现单链表的删除算法，请在空格处将算法补充完整。int ListDelete(LinkList L,int i,ElemType *s){ LNode *p,*q; int j; p=L;j=0; while(( （1） )(jnext;j++; } if(p-next==NULL||ji-1) return ERROR; q=p-next; （2） ; *s=q-data; free(q); return OK;}/*listDelete*/
填空题函数实现单链表的删除算法，请在空格处将算法补充完整。int ListDelete(LinkList L,int i,ElemType *s){ LNode *p,*q; int j; p=L;j=0; while(( （1） )(jnext;j++; } if(p-next==NULL||ji-1) return ERROR; q=p-next; （2） ; *s=q-data; free(q); return OK;}/*listDelete*/
填空题函数实现单链表的插入算法，请在空格处将算法补充完整。int ListInsert(LinkList L,int i,ElemType e){ LNode *p,*s;int j; p=L;j=0; while((p!=NULL)(jnext;j++; } if(p==NULL||ji-1) return ERROR; s=(LNode *)malloc(sizeof(LNode)); s-data=e; (1) ; (2) ; return OK;}/*ListInsert*/
问答题下列给定程序是建立一个带头结点的单向链表，并用随机函数为各结点赋值。函数fun（）的功能是：将单向链表结点（不包括头结点）数据域为偶数的值累加起来，并作为函数值返回。 请改正函数fun中的错误，使它能得出正确的结果。 注意：部分源程序在文件MODII.C中，不要改动main函数，不得增行或删行，也不得更改程序的结构! 试题程序：#include #include #include typedef struct aa{ int data; struct aa *next;}NODE;int fun(NODE *h){ int sum=0; NODE *p; p=h-next; /*********found*********/ while(p-next) { if(p-data%2==0) sum+=p-data; /*********found*********/ p=h-next; } return sum;}NODE *creatlink(int n){ NODE *h,*p,*s; int i; h=p=(NODE *)malloc(sizeof(NODE)); for(i=1;idata=rand()%16; s-next=p-next; p-next=s; p=p-next; } p-next=NULL; return h;}outlink(NODE *h){ NODE *p; p=h-next; printf("The LIST: HEAD"); while(p) { printf("-%d",p-data); p=p-next; } printf("");}main(){ NODE *head; int sum; system("CLS"); head=creatlink(10); outlink(head); sum=fun(head); printf("SUM=%d",sum);}
问答题设某带头结头的单链表的结点结构说明如下：typedef struct nodel{int data struct nodel*next；}node；试设计一个算法：void copy（node*headl，node*head2），将以head1为头指针的单链表复制到一个不带有头结点且以head2为头指针的单链表中。
填空题函数GetElem实现返回单链表的第i个元素，请在空格处将算法补充完整。 int GetElem(LinkList L,int i,Elemtype *e){ LinkList p；int j；p=L-next;j=1; while(pji) return ERROR;*e= (2) ;return OK;}