对于带头节点的单链表L1，其节点类型为LinkList，指出以下算法的功能。 void fun（LinkList *L，ElemType x，ElemType y) { LinkList *p=L-next; while （p!=NULL) { if （p-data==x) p-data=y; p=p-next; } }
对于带头节点的单链表L1，其节点类型为LinkList，指出以下算法的功能。 void fun（LinkList *&L，ElemType x，ElemType y) { LinkList *p=L->next; while （p!=NULL) { if （p->data==x) p->data=y; p=p->next; } }
参考答案和解析
表头节点的指针域 next 与 L 的值相等
相关考题：
函数 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)处的字句写在答题纸的对应栏内。【说明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) )；}}
在单链表中,指针p指向元素为x的结点,实现删除x节点的后继结点的语句是()。 A、p=p->next;B、p->next=p->next->next;C、p->next=p;D、p->next->next=p->next->next->next;
函数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)处的字句写在对应栏内。【说明】本程序将两个从小到大的有序链表合成一个新的从小到大的有序链表。链表的每一项由类 Node描述，而链表由List描述，类List的成员函数有以下几个：creatList(): 创建从小到大的有序链表。multiplyList(List L1, Llst L2): 将链表L1和链表L2合并。print(): 打印链表。【C++代码】include ＜iostream＞using namespace std;class List;class Node{friend class List;public:Node(int data){(1);}private:int data;Node *next;};class List{public：List(){list=NULL;}void multiplyList(List L1, List L2);void creatList();void print();private:Node *list;};void List::creatList(){Node *p, *u, *pre;int dara;list=NULL;wbile(1){cout＜＜"输入链表的一项: (小于零，结束链表) "＜＜endl;cin＞＞data;if(dara＜0)break;//小于零，结束输入p=list;while(p !=NULL dara＞p-＞data){//查找插入点pre=p;p=p-＞next;}u=(2);if(p==list)list=u;else pre-＞next=u;(3);}}void List::multiplyList(List L1, List L2){Node *pL1, *pL2, *pL, *u;list = NULL;pL1 = L1.list;pL2 = L2.11st;while(pL1 != NULL pL2 != NULL){if(pL1-＞data ＜ pL2-＞data){u = new Node(pL1-＞data);pL1 = pL1-＞next;}else{u = new Node(pL2-＞data);pL2 = pL2-＞next;}if(list == NULL){list =(4);}else{pL-＞next=u;pL=u;}}pL1 = (pL1 != NULL)? pL1:pL2;while(pL1 != NULL){u=(5);pL1 = pL1-＞next;if(list == NULL){list=pL=u;}else{pL-＞next=u;pL=u;}}}void List::print(){Node *p;p = list;while(p !=NULL){cout＜＜p-＞data＜＜"\t";p=p-＞next;&
现有以下结构体说明和变量定义，如图所示，指针p、q、r分别指定一个链表中连续的3个结点。A.q->；next=r->；next；p->；next=r；r——>；next=q；B.Q->；next=r；q->；next=r->；next；r——>；next=q；C.Q->；next=r->；next；r->；next=q；p——>；next=r；D.qnext=q；p->；next=r；q->；next=r->；next；
阅读下列函数说明和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．
设有指针p指向带表头结点的单链表，现将指针p指向节点的后继节点删除(不考虑节点值及空间回收)，其操作是______。其中p^.next表示p所指节点的链域，q是一个临时指针变量，初始值为null。A．p：=p^.nextB．q：=p^.next；p^.next：=q^.nextC．p^.next：=q；q^.next：=pD．p：=q^.next；q^.next=p
阅读以下说明和 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*/
下列算法将单链表中值重复的结点删除，使所得的结果表中各结点值均不相同，试完成该算法。 void DelSameNode（LinkList L） //L是带头结点的单链表，删除其中的值重复的结点// {ListNode * p，*q，*r； p=L-next； //p初始指向开始结点// while（p）{ //处理当前结点p// q=p； r=q-next； do { //删除与结点*p的值相同的结点// while（rr-data!=p-data）{ q=r； r=r-next； } if（r）{ //结点*r的值与*p的值相同，删除*r// q-next=r-next； free（r）； r=（）； } }while（ r ）； p=p-next； } }
函数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 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*/
填空题设线性链表的存储结构如下： struct node {ELEMTP data； /*数据域*/ struct node *next； /*指针域*/ } 试完成下列在链表中值为x的结点前插入一个值为y的新结点。如果x值不存在，则把新结点插在表尾的算法。 void inserty（struct node *head，ELEMTP x，ELEMTP y） {s=（struct node *）malloc（sizeof（struct node））； （）； if（）{s-nexr=head；head=s；} else { q=head；p=q-next； while（p-dqta!=xp-next!=NULL）{q=p；（）} if（p-data= = x）{q-next=s；s-next=p；} else{p-next=s；s-next=NULL；} } }
填空题函数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;}