更多"【说明】
本程序将两个从小到大的有序链表合成一个新的从小到大的有序"的相关试题:
[多项选择]【说明】
本程序将两个从小到大的有序链表合成一个新的从小到大的有序链表。链表的每一项由类 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
[简答题]【说明】本程序将两个从小到大的有序链表合成一个新的从小到大的有序链表。链表的每一项由类Node描述，而链表由类List描述。类List的成员函数有以下几个。
①createList（ ）：创建从小到大的有序链表。
②multiplyList(List L1，List L2)：将链表L1和链表L2合并。
③print（ ）；打印链表。
# include ＜iostream.h＞
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 createList( );
void print( );
private:
Node *list;
};
void List::createList( )
{ Node *p, *u, *pm;
int data;
list = NULL;
while (1)
{ cout＜＜"输入链表的一项: (小于零，结束链表)"＜＜end1;
cin ＞＞ data;
if(data＜0)break; //小于零，结束输入
p = list;
while (p != NULL && data ＞ p-＞data) //查找插入点
{ pre = p;
p = p-＞next;
}
u= (2) :
if(p==list)
list = u;
else
pre-＞next = u;
(3) :
}
void List::multiplyList (List
[单项选择]将两个长度为n的递增有序表归并成一个长度为2n的递增有序表，最少需要进行关键字比较（）次。
A. 1
B. n-1
C. n
D. 2n
[简答题]【说明】
本程序可以将字符串s1中出现的所有s2子串替换成s3，形成一个新串，但不破坏字符串s1。
【代码】
#include＜stdio.h＞
#include＜stdlib.h＞
#include＜string.h＞
char*replace(char *s1, char *s2,char *s3)
{ char *p, *q, *r, *s; int |2，|3, i=0;
|2=strlen(s2);
|3=strlen(s3);
p=s1;
while((p=strstr(p,s2))!=NULL)
{ i++; /* 统计s2串出现的次数*/
(1) ;
}
i= (2) ;
s=r=(char*)malloc(i); /*分配动态内存存放新字符串*/
p=s1;
while(1)
{ q=strstr(p, s2); /* s2串是否在s1中出现，q是首次出现的位置*/
if(q!=NULL)
{ i=q-p;
(3) ;
r+=i;
(4) ;
r+=|3;
p=q+|2; /*将指向s1串的指针移到s2子串出现的位置后，
为下一次循环做好准备*/
}
else /*q为空，表示剩余的s1串中已经没有s2*/
{ (5) ;
break; /*终止循环*/
}
}
return(s); /*返回指向所形成的新串的指针*/
}
void main（ ）
{ char *a="sabcababde", *b="ab", *c="efg", *d;
d=replace(a, b, c); printf("result=%s/n", d); free(d);
}
[单项选择]有n个结点的有序单链表中插入一个新结点并保持有序的运算的时间复杂度为______。
A. O(1)
B. O(logn)
C. O(n)
D. O(n2)
[单项选择]在具有n个结点的有序单链表中插入一个新结点并使链表仍然有序的时间复杂度是（）。
A. O(1)
B. O(n)
C. O(nlogn)
D. O(n2)
[简答题][说明]
本程序包含的函数及其功能说明如下：
(1)函数first_insert（ ）的功能是在已知链表的首表元之前插入一个指定值的表元；
(2)函数reverse_copy（ ）的功能是按已知链表复制出一个新链表，但新链表的表元链接顺序与
已知链表的表元链接顺序相反；
(3)函数Print_link（ ）用来输出链表中各表元的值；
(4)函数free_link（ ）用来释放链表全部表元空间。
[程序]
#include ＜stdio. h ＞
#include ＜malloe. h ＞
typodef struct node
int val;
struct node * next;
NODE;
void first_insert(NODE * * p,int v)
NODE *q = (NODE *) malloe(sizeof(NODE));
q->val = v; q-＞next = *p; /* 为新表元赋值*/
* p = (1) ;
NODE * reverse_copy( NODE * p)
NODE * u;
for(u=NULL; p!=NULL; p=p-＞next) first_insert( (2) );
return u; void printlink(NODE * p )
for(; (3) ) prinff("%d/t", p->val);
printf(" /n");void free_link( NODE * p)
NODE * u;
while(p! =NULL) u=p->next;free(p); (4) ;
void main( ) NODE * link1 , * link2;
int i;
link1 = NULL;
for(i=1; i＜= 10; i+ + )first_insert(&linkl, i);
link2 = reverse_copy(link1 );
[简答题][说明]
本程序使用类来管理员工的通讯地址信息。已知程序的输出为：
输出记录：5
姓名：王丽华
街道地址：中华路15号
市：襄樊市
省：湖北省
邮政编码：430070
[Java代码]
public class Employee{
protected String (1) ;
protected String street;
protected String city;
protected String prov;
protected String post;
protected int no;
public Empbyee（ ）{}
public Employee(String name,String street,String city,String prov,String post, (2) ){
this.name=name;
this.street=street;
this.city=city;
this.prov=prov;
this.post=post;
this.no=no;
}
public static void main(String[]args){
Employee emp=new Employee(“王华”，“中华路15号”，“武汉市”，“湖北省”，“430070”，1);
emp.changeName(“王丽华”);
(3) (“襄樊市”);
emp.changeNo(5);
(4) ;
}
void changeName(String name){this.name=name;}
void changeStreet(String street){this.street=street;}
void changeCity(String city){this.city=city;}
void changeProv(String prov){this.prov=prov;}
void changeNo(int no){ (5) ;}
void display（ ）{
System.out.println(“输出记录：”+this.no);
System.o
[简答题][说明]
本程序使用类来管理员工的通讯地址信息。已知程序的输出为：
输出记录：5
姓名：王丽华
街道地址：中华路15号
市：襄樊市
省；湖北省
邮政编码：430070
[C++程序]
#include ＜ iostream, h ＞
#include ＜ string, h ＞
class employee.
protected:
char name[10];
char street[ 20 ];
char city[10];
char (1) [10];
char post[7];
int no;
(2) :
(3) (char [] ,char [] ,char [] ,char [] ,char [] ,int);
void changename ( char n [] ) strcpy ( name, n);
void changestreet( char s[] ) strcpy(street,s) ;
void changecity ( char c [] ) strcpy ( city, c );
void changeprov( char p [] ) strcpy(prov,p);
void changeno(int nnm) (4) ;
void display( );
;
employee:: (3) (char n[] ,char s[] ,char c[] ,char p1[] ,char p2[] ,int nam)
strcpy(name,n);
strcpy ( street, s);
strcpy ( city, c);
strcpy ( prov, p1 );
strcpy ( post, p2 );
no = nam;
[简答题]【程序5说明】
著名的四色定理指出任何平面区域图均可用四种颜色着色，使相邻区域着不同的颜色。本程序对给定的区域图找出所有可能的不超过四种颜色的着色方案。
程序中用1～4表示四种颜色。要着色的N个区域用0～N-1编号，区域相邻关系用 adj[][]矩阵表示，矩阵的i行j列的元素为1，表示区域i与区域j相邻；矩阵的i行j列的元素为0，表示区域i与区域j不相邻。数组color[]用来存储着色结果，color[i]的值为区域i所着颜色。
【程序5】
#include＜stdio.h＞
#define N 10
void output(int color[])/*输出一种着色方案*/
int i；
for(i=0；i＜N；i++)
printf("%4d"，color[i])；
printf("/n")；
int back (int * ip，int color[])/*回溯*/
int c=4；
while(c==4)
if(*ip＜=0)return 0；
－－(*ip)；
c= (1) ；
color[*ip]=-1；
return c；
/*检查区域i，对c种颜色的可用性*/
int colorOk(int i，int c，int [][N]，int color[]
int j；
for(j=0；j＜i；j++)
if( (2) )
return 0；
return 1；
/*为区域i选一种可着的颜色*/
int select (int i，int c，int adj[][N]，int color[])
int k；
for(k=c；k＜=4；k++)
if(colorOK( (3) ))
return k；
return 0；
int coloring(int adj[][N])
