有以下程序段typedef struct node { int data; struct node *next; } *NODE;NODE p;以下叙述正确的是A)p 是指向 struct node 结构变量的指针的指针B)NODE p ；语句出错C)p 是指向 struct node 结构变量的指针D)p 是 struct node 结构变量

阅读以下说明和C++程序，将应填入(n)处的字句写在对应栏内。

[说明]

下面程序实现十进制向其它进制的转换。

[C++程序]

include"ioStream.h"

include"math.h"

include

typedef struct node {

int data;

node*next;

}Node;

Class Transform.

{

DUDlic:

void Trans(int d,int i); //d为数字;i为进制

void print();

private:

Node*top;

};

void Transform.:Trans(int d,int i)

{

int m,n=0;

Node*P;

while(d＞0)

{

(1);

d=d/i;

p=new Node;

if(!n){

p-＞data=m;

(2);

(3);

n++;

}

else{

p-＞data=m;

(4);

(5);

}

}

}

void Transform.:print()

{

Node*P;

while(top!=NULL)

{

p=top;

if(p-＞data＞9)

cout＜＜data+55;

else

cout＜＜data;

top=p-＞next;

delete p;

}

}

Simplify the following Boolean expression

!((i ==12) || (j > 15))

struct Node {

int value;

Node* next;

};

1.1 Get the value of the Nth node from last node in the linked list.

PARAM HEAD: the first element in the linked list:

PARAM n: the number of the node counted reversely

RETURN: the value of the node, or -1 if not exists

int GetValue(Node* HEAD, int n)

{

}

1.2 Delete a node WITHOUT using the HEAD pointer.

PARAM p: A pointer pointed to a node in the middle of the linked list.

RETURN: void

void Delete(Node* p)

{

}

1.3 Insert a new node before p WITHOUT using the HEAD pointer

PARAM p: A pointer pointed to a node in the middle of the linked list.

PARAM value: new Node value

RETURN: void

void Insert(Node* p, int value)

{

}

Question 2:

Please write a String class with following features:

下而程序实现十进制向其他进制的转换。

[C++程序]

include"ioStream．h"

include"math．h"

include ＜conio．h＞

typedef struct node{

int data；

node *next；

}Node；

class Transform

{

public：

void Trans(int d，int i)； //d为数字；i为进制

void print();

private：

Node *top；

}；

void Transform.:Trans(int d,int i)

{

int m，n=0；

Node *P；

while(d＞0)

{

(1) ;

d=d/i；

p=new Node；

if(!n){

P-＞data=m；

(2) j

(3) ;

n++;

}

else{

p-＞data=m；

(4) ；

(5) ；

}

}

}

void Transform.:print()

{

Node *P;

while(top!=NULL)

{

p=top；

if(P-＞data＞9)

cout＜＜data+55：

else

cout＜＜data；

top=p-＞next；

delete P;

}

}

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

&

下列给定程序中，是建立一个带头结点的单向链表，并用随机函数为各结点数据域赋值。函数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);

}