阅读以下函数说明和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)处的字句写在对应栏内。

[说明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)处的字句写在答题纸的对应栏内。【说明】本题给出四个函数,它们的功能分别是: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);}

●试题三阅读下列函数说明和C函数,将应填入(n)处的字句写在答题纸的对应栏内。【函数3说明】函数DeleteNode(Bitree*r,int e)的功能是:在树根结点指针为r的二叉查找(排序)树上删除键值为e的结点,若删除成功,则函数返回0,否则函数返回-1。二叉查找树结点的类型定义为:typedef struct Tnode{int data;/*结点的键值*/struct Tnode*Lchild,*Rchild;/*指向左、右子树的指针*/}*Bitree;在二叉查找树上删除一个结点时,要考虑三种情况:①若待删除的结点p是叶子结点,则直接删除该结点;②若待删除的结点p只有一个子结点,则将这个子结点与待删除结点的父结点直接连接,然后删除结点p;③若待删除的结点p有两个子结点,则在其左子树上,用中序遍历寻找关键值最大的结点s ,用结点s的值代替结点p的值,然后删除结点s,结点s必属于上述①、②情况之一。【函数3】int DeleteNode(Bitree*r,int e){Bitree p=*r,pp,s,c;while( (1) ){/*从树根结点出发查找键值为e的结点*/pp=p;if(e<p->data)p=p->Lchild;else p=p->Rchild;}if(!p)return-1;/*查找失败*/if(p->Lchild p->Rchild) { /*处理情况③*/s= (2) ;pp=p;while( (3) ){pp=s;s=s->Rchild;}p->data=s->data;p=s;}/*处理情况①、②*/if( (4) )c=p->Lchild;else c=p->Rchild;if(p==*r)*r=c;else if( (5) )pp->Lchild=c;else pp->Rchild=c;free(p);return 0;}

阅读下列C函数和函数说明,将应填入(n)处的字句写在对应栏内。【说明】函数DeleteNode (Bitree *r, int e)的功能是:在树根结点指针为r的二叉查找(排序)树上删除键值为e的结点,若删除成功,则函数返回0,否则函数返回-1。二叉查找树结点的类型定义为:typedef struct Tnode{int data; /*结点的键值*/struct Tnode *Lchild, *Rchild; /*指向左、右子树的指针*/}*Bitree:在二叉查找树上删除一个结点时,要考虑3种情况:①若待删除的结点p是叶子结点,则直接删除该结点;②若待删除的结点p只有一个子结点,则将这个子结点与待删除结点的父结点直接连接,然后删除结点p;③若待删除的结点p有两个子结点,则在其左子树上,用中序遍历寻找关键值最大的结点s,用结点s的值代替结点p的值,然后删除结点s,结点s必属于上述①、②情况之一。【函数】int DeleteNode (Bitree *r,int e) {Bitree p=*r,pp,s,c;while ( (1) ){ /*从树根结点出发查找键值为e的结点*/pp=p;if(e<p->data) p=p->Lchild;else p=p->Rchild;}if(!P) return-1; /*查找失败*/if(p->Lchild p->Rchild) {/*处理情况③*/s=(2);pp=pwhile (3) {pp=s;s=s->Rchild;}p->data=s->data; p=s;}/*处理情况①、②*/if ( (4) ) c=p->Lchild;else c=p->Rchild;if(p==*r) *r=c;else if ( (5) ) pp->Lchild=c;else pp->Rchild=c;free (p);return 0;}

试题四阅读下列函数说明和C函数,将应填入 (n) 处的字句写在答题纸的对应栏内。[函数说明]函数DeleteNode(Bitree *r,int e)的功能是:在树根结点指针为r的二叉查找(排序)树上删除键值为e的结点,若删除成功,则函数返回0,否则函数返回-1。二叉查找树结点的类型定义为:typedef struct Tnode{int data;struct Tnode *Lchild,*Rchild;}*Bitree;在二叉查找树上删除一个结点时,要考虑三种情况:1若待删除的结点p是叶子结点,则直接删除该结点;2若待删除的结点p只有一个子结点,则将这个子结点与待删除结点的父结点直接连接,然后删除结点p;3若待删除的结点p有两个子结点,则在其左子树上,用中序遍历寻找关键值最大的结点s,用结点s的值代替结点p的值,然后删除结点s,结点s必属于上述1、2情况之一。[函数代码]int DeleteNode(Bitree *r,int e) {Bitreep = *r, pp, s, c;while( (1) ) { /*从树根结点出发查找键值为e的结点*/pp = p;if ( e p-data) p = p - Lchild;else p = p-Rchild;}if(!p) return –1; /* 查找失败 */if(p-Lchild p-Rchild) { /* 处理情况3 */s = (2);pp = p;while ( (3) ) { pp = s; s = s- Rchild; }p-data = s -data; p = s;}/*处理情况1、2*/if( (4) ) c = p - Lchild;elsec = p - Rchild;if(p == *r) *r = c;elseif ( (5) ) pp - Lchild = c;elsepp-Rchild = c;free(p);return 0;}

阅读下列函数说明和C函数,将应填入(n)处。【函数3说明】函数DeleteNode(Bitree * r,int e)的功能是:在树根结点指针为r的二叉查找(排序)树上删除键值为e的结点,若删除成功,则函数返回0,否则函数返回-1。二叉查找树结点的类型定义为:typedef struct Tnode{int data; /*结点的键值*/struct Tnode * Lchild,*Rchild; /*指向左、右子树的指针*/} * Bitree;在二叉查找树上删除一个结点时,要考虑三种情况:①若待删除的结点p是叶子结点,则直接删除该结点;②若待删除的结点p只有一个子结点,则将这个子结点与待删除结点的父结点直接连接,然后删除结点P;③若待删除的结点p有两个子结点,则在其左子树上,用中序遍历寻找关键值最大的结点s,用结点s的值代替结点p的值,然后删除结点s,结点s必属于上述①、②情况之一。【函数3】int DeleteNode(Bitree * r,int e){Bitree p=*r,pp,s,c;while((1)){ /*从树根结点出发查找键值为e的结点*/pp=p;if(e<p->data)p=p->Lchild;else p=p->Rchild;{if(!p)return-1; /*查找失败*/if(p->Lchild p->Rchild){/*处理情况③*/s=(2); pp=p;while((3)){pp=s;s=s->Rchild;}p->data=s->data;p=s;}/*处理情况①、②*/if((4))c=p->Lchild;else c=p->Rchild;if(p==*r)*r=c;else if((5))pp->Lchild=c;else pp->Rchild=c;free(p);return 0;}

已知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语言中,可以用typedef声明新的类型名来代替已有的类型名,比如有学生链表结点: typedef struct node{ int data; struct node * link; }NODE, * LinkList; 下述说法正确的是______。A.NODE是结构体struct node的别名B.* LinkList也是结构体struct node的别名C.LinkList也是结构体struct node的别名D.LinkList等价于node*

阅读下列函数说明和C代码,将应填入(n)处的字句写在对应栏内。【说明】设有一个带表头结点的双向循环链表L,每个结点有4个数据成员:指向前驱结点的指针prior、指向后继结点的指针next、存放数据的成员data和访问频度freq。所有结点的freq初始时都为0。每当在链表上进行一次L.Locate(x)操作时,令元素值x的结点的访问频度 freq加1,并将该结点前移,链接到现它的访问频度相等的结点后面,使得链表中所有结点保持按访问频度递减的顺序排列,以使频繁访问的结点总是靠近表头。【函数】void Locate( int x){ <结点类型说明>* p =first -> next;while(p!=frist(1))P=P->next;if(p! =first) /*链表中存在x*/{(2);<结点类型说明>* current = P; /*从链表中摘下这个结点*/Current -> prior -> next = current -> next;Current -> next -> prior = current -> prior;P = current -> prior; /*寻找重新插入的位置*/While(p! =first (3))p=p->prior;Current-> next =(4); /*插入在P之后*?Current -> prior = P;P -> next -> prior = current;P->next=(5);}else printf("Sorry. Not find! \n"); /*没找到*/}

函数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)处的字句写在对应栏内。【说明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));}}

链表的定位函数loc(I:integer):pointer; {寻找链表中的第I个结点的指针}procedure loc(L:linklist; I:integer):pointer;var p:pointer;j:integer;

单链表的删除操作procedure delete(L:linklist; I:integer);var p,q:pointer;

执行下列语句后指针及链表的示意图为(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.

阅读以下说明和 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; }

阅读以下说明和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*/

填空题函数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;}