下面的程序各自独立,请问执行下面的四个TestMemory 函数各有什么样的结果?
①void GetMemory(char * p)
{
p = (char * )malloc(100);
}
void TestMemory (void)
{
char *str = NULL;
GetMemory (str);
strcpy(str, "hello world");
prinff(str);
}
② char * GetMemory (void)
{
char p[ ] = "hello world";
return p;
}
void TestMemory (void)
{
char * str = NULL;
str = GetMemory();
printf(str);
}
③void GetMemory(char * * p, int num)
{
* p = (char * )malloc(num);
}
void TestMemory (void)
{
char * str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello" );
printf(sir);
}
④void TestMemory (void)
{
char *str = (char * )malloe(100);
strepy (str, "hello" );
free (str );
if(str ! = NULL)
{
strepy(str, "world" );
printf(str);
}
}
第1题
阅读以下应用程序说明和C程序,将C程序段中(1)—(7)空缺处的语句填写完整。
[说明]
打保龄球是用一个滚球去打出10个站立的柱,将柱击倒。一局分10轮,每轮可滚球一次或多次,以击倒的柱数为依据计分。一局得分为10轮得分之和,而每轮的得分不仅与本轮滚球情况有关,还可能与后续一两轮的滚球情况有关。即某轮某次滚球击倒的柱数不仅要计入本轮得分,还可能会计入前一两轮得分。具体的滚球击柱规则和计分方法如下:
1) 若某一轮的第一次滚球击倒全部10个柱,则本轮不再滚球(若是第10轮则还需另加两次滚球)。该轮得分为本次倒柱数(即10)与以后两次滚球所击倒柱数之和。
2) 若某一轮的第一次滚球未击倒10个柱,则可对剩下未倒的柱再滚球一次。如果这两次滚球击倒全部10个柱,则本轮不再滚球(若是第10轮则还需另加一次滚球),该轮得分为本次倒柱数10与以后一次滚球所击倒柱数之和。
3) 若某一轮的两次滚球未击倒全部10个柱,则本轮不再继续滚球,该轮得分为这两次滚球击倒的柱数之和。
总之,若一轮中一次滚球或两次滚球击倒10个柱,则本轮得分是本轮首次滚球开始的连续3次滚球击倒柱数之和(其中有一次或两次不是本轮滚球)。若一轮内二次滚球击倒柱数不足10个,则本轮得分即为这两次击倒柱数之和。表3-15是打保龄球计分的某个实例说明。
以下[C程序]是模拟打一局保龄球的过程,统计各轮得分和累计总分。程序交互地逐轮逐次输入一次滚球击倒的柱数,计算该轮得分和累计总分。为记录一轮内击倒10柱,但还暂不能计算该轮得分和累计总分的情况,程序引入变量ok,用来记录当前已完成完整计算的轮次。程序每输入一次滚球击倒柱数,就检查还未完成完整计算的轮次,并计算。
[C程序]
include<stdio.h>
define N 13
struct { int n; /* 一轮内滚球次球 */
int f; /* 第一次击倒柱数 */
int s; /* 第一次击倒柱数 */
int score; /* 本轮得分 */
int total; /* 至本轮累计总分 */
int m; /* 完成本轮得分计算,还需滚球次数 */
} a[N];
int k = 0; /* 已完成完整计算的轮次数 */
int ball(int i, int n, int max) /* 完成一次滚球,输入正确击倒柱数 */
{ int d, j, k;
static c=1;
while (1)
{ if(i <= 10)
printf(" 输入第%d轮的第%d次滚球击倒柱数。(<=%d)\n", i, n, max );
else
printf(" 输入附加的第%d次滚球击倒柱数。(<=%d)\n", C++, max);
scanf("%d , &d);
if (d >=0 && d <= max) break;
printf(" 不合理的击倒柱数,请重新输入。\n")
)
if (ok <(1) )
{ /* 对以前未完成计算的轮次分别计算得分与累计总分*/
for(j = ok+1;(2); j++)
{ a[j].score += d;
if (--a[j].m == 0)
{ a[j].total = ( (3) ) + a[j].score;
k =(4);
}
}
}
return d;
}
main ( )
{ int i, first, second, k; /* i表示轮次 */
for ( i = 1 ; ok < 10 ; i++)
a[i].score = a[i].f = first = ball(i,1,10);
if ( first == 10)
a[i].m = 2;
a[i].n = 1;
if (first < 10 && (i <= 10 || i == 11 && ok < 10 ))
{ /* 处理第2次滚球 */
(5)= second = ball i,2,10-first);
if (first + second == 10)
a[i].m = 1;
第2题
假设该商务交流中心当前各个房间的情况如表2-14所示。
当输入M=3,R=0时,该算法的输出是(1)。
当输入M=2,R=1时,该算法的输出是(2)。
第4题
阅读以下说明,Java代码将应填入(n)处的字句写在对应栏内。
【说明】
链表和栈对象的共同特征是:在数据上执行的操作与在每个对象中实体存储的基本类型无关。例如,一个栈存储实体后,只要保证最后存储的项最先用,最先存储的项最后用,则栈的操作可以从链表的操作中派生得到。程序6-1实现了链表的操作,程序6-2实现了栈操作。
import java.io.*;
class Node //定义结点
{ private String m_content;
private Node m_next;
Node(String str)
{ m_content=str;
m_next=null; }
Node(String str,Node next)
{ m_content=str;
m_next=next; }
String getData() //获取结点数据域
{ return m_content;}
void setNext(Node next] //设置下一个结点值
{ m_next=next; }
Node getNext() //返回下一个结点
{ return m_next; )
}
【程序6-1】
class List
{ Node Head;
List()
{ Head=null; }
void insert(String str) //将数据str的结点插入在整个链表前面
{ if(Head==null)
Head=new Node(str);
else
(1)
}
void append(String str) //将数据str的结点插入在整个链表尾部
{ Node tempnode=Head;
it(tempnode==null)
Heed=new Node(str);
else
{ white(tempnode.getNext()!=null)
(2)
(3) }
}
String get() //移出链表第一个结点,并返回该结点的数据域
{ Srting temp=new String();
if(Head==null)
{ System.out.println("Errow! from empty list!")
System.exit(0); }
else
{ temp=Head.getData();
(4) }
return temp;
}
}
【程序6-2】
class Stack extends List
{ void push(String str) //进栈
{ (5) }
String pop() //出栈
{ return get();}
}
第5题
阅读下列程序说明和C程序,把应填入其中(n)处的字句,写在对应栏内。
【程序说明】
对角线下元素全为0的矩阵称为上三角矩阵,设对于一个n×n的上三角矩阵a,为节约存贮,只将它的上三角元素按行主序连续存放在数组b中。下面的函数trans在不引入工作数组的情况下,实现将a改为按列主序连续存放在数组b中。
设n=5,
b=(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)
经调用trans函数后,b变为
b=(1,2,6,3,7,10,4,8,11,13,5,9,12,14,15)
函数tans对数组元素的存贮位置作调整。调整过程中存在若干个循环传送链:
b(i1)→b(i2)→b(ij)→b(i1)1≤j<n
例如,考察调整后的数组元素b(2)(值为6),与该元素相关的位置调整将形成下面的循环传送链:
b(2)→b(3)→b(6)→……→b(12)→b(9)→b(5)→b(2)
关键是确定循环传送链的下标i1,i2,…,ij,以及在考察调整后的元素b(k)(k;3,4,…)时能判定b(k)是已被传送过的某传送链上的元素。
函数ctr(k,n)计算调整后的数组b的第k个元素b(k)在原数组b中的位置,该位置作为函数ctr(k,n)的返回值。函数ctr根据k确定它在矩阵中的行号i和列号j(注意行号和列号均从 0算起),然后按矩阵存放原则计算出它在b中的位置。
【程序】
trans(b,n)
int n,b[]
{
int m,k,r,cc,rr;
int w;
m=(n+1)*n/2-4;
k=2;
while(m>0)
{
r=ctr(k,n);
if(r==k)
m--;
else
{
cc=k;rr=r;
while (1)
{
cc=rr,rr=ctr(cc,n);
}
if (2)
{
cc=k;rr=r;w=b[k];
while (3)
{
b[cc]=b[rr];m--;
cc=rr,rr=ctf(cc,n);
}
b[cc]-w; (4);
}
}
k++;
}
}
ctr( k,n )
int k,n
{
int i,j;
i=k;j=0;
while (5)
i - =++j ;
return(i*n+j-i*(i+1)/2);
}
第6题
阅读以下说明和C语言函数,将应填入(n)处的字句写在对应栏内。
【说明】
将A,B,C,D,E,F这6个变量排成如图(a)所示的三角形,这6个变量分别取[1,6]中的整数,且均不相同。求使三角形三条边上的变量之和相等的全部解。图(b)就是一个解。
程序引入变量a,b,c,d,e,f,并让它们分别顺序取1~6的整数,在它们互不相同的条件下,测试由它们排列成的如图(a)所示的三角形三条边上的变量之和是否相等,如果相等即为一种符合要求的排列,就输出它们。
【程序】
void main()
{ int a, b, c, d, e, f;
for(a=1;a<=6;a++)
for(b=1;b<=6;b++) {
if((1)) continue;
for(c==1;c<=6;c++) {
if((2))continue;
for(d=1;d<=6;d++) {
if((3)) continue;
for(e=1;e<=6;e++) {
if((4)) continue;
f=21-(a+b+c+d+e);
if((5)){
printf("%6d",a);
printf("%4d%4d",b,f);
printf("%2d%4d%4d",c,d,e);
scanf("%*c"); /*按回车键,继续找解*/
}
}
}
}
}
}
第7题
阅读以下函数说明和C语言函数,将应填入(n)处的字句写在对应栏内。
【函数2.1】
void sort(char *s,int num)
{int i,j--num;
char t;
while(j-->1)
for(i=0;i<j;i++)
if(s[i]>s[i+1])
{t=s[i];
s[i]=s[i+1];
s[i+1]=t;
}
void main()
{char *s="CEAedea";
sort(s,5);
printf("%s",s);
}
上述程序的结果是(1)
【函数2.2】
void main()
{ union {int ig[6];
Char s[12];} try;
try. ig[0]=0x4542; try.ig[1]=0x2049;
try. ig[2]=0x494a; try.ig[3]=0x474e;
try. ig[4]=0x0a21; try.ig[5]=0x0000;
pintf("%s",try, s);
}
上述程序的结果是(2)
【函数2.3】
void main()
{ char *letter[5]= { "ab","efgh","ijk","nmop","st"};
char **p;
int i;
p=letter;
for(i=0;i<4;i++) .
printf("%s",p[i]);
}
上述程序的结果是(3)
【函数2.4】
main()
{int i=4,j=6,k=8,*p=&I,*q=&j,*r=&k;
int x,y,z;
x=p==&i;
y=3*-*p/(*q)+7;
z=*(r=&k)=*p**q;
printf("x=%d,y=%d,z=%d",x,y,z);
}
上述程序的结果是(4)
【函数2.5】
int a[]={5,4,3,2,1 };
void main()
{int i;
int f=a[0];
int x=2;
for(i=0;i<5;i++)
f+=f*x+a[i];
printf("%d",f);
}
上述程序的结果是(5)
第8题
阅读下列函数说明和C函数,将应填入(n)处的字句写在对应栏内。
[说明]
链式存储的队列称为链队。根据队列的FIFO原则,为了操作上的方便,可以使用带头指针front和尾指针rear的单链表来实现链队。若链队元素的数据类型为datatype,则链队结构描述如下:
typedef struct node
{ datatypedata;
structnode *next;
} QNode; /*链队结点的类型*/
typedef struct
{ QNnode *front,*rear;
} LQueue; /*将头尾指针封装在一起的链队*/
以下这种链队的几个例子:
设q是一个指向链队的指针,即LQueue *q。下面各函数的功能说明如下:
(1) LQueue *Init_LQueue():创建并返回一个带头尾结点的空链队;
(2) intEmpty_LQueue( LQueue *q):判断链队q是否空;
(3) void In_LQueue(LQueue *q, datatypex):将数据x压入链队q;
(4) int Out_LQueue(LQuere *q, datatype *x):弹出链队q的第一个元素x,若成功则返回返回1否则返回0。
[函数]
LQueae *Init_LQueue()
{ LQueue *q, *p;
q=malloc(sizeof(LQueue)); /*申请链队指针*/
P=malloc(sized(QNode));/*申请头尾指针结点*/
p->next=NULL;
(1)=p;
return q;
}
int Empty_LQueue(LQueue *q)
{ if(q->front (2) q>rear) return 0;
else return 1;
}
void In_LQueue(LQueue *q, datatype x)
{ QNoda *p;
p=malloc(sizeof(QNnode));/*申请新接点*/
p->data=x;
p->next=NULL;
(3)=p;
q->rear=p;
}
int Out_LQueue(LQueue *q, datatype *x)
{ QNnode *p;
if(Empty_LQueue(q)) return 0; /*队空,操作失败*/
else{
p=q->front->next;
*x=(4);
(5)=p->next;
free(p);
if (q->front->next= =NULL)q->rear=q->front;
return 1;
}
}
第9题
阅读下列函数说明和C函数,将应填入(n)处的字句写在对应栏内。
[函数2.1说明]
Fibonacci数列中头两个数均为1,从第三个数开始,每个数等于前两个数之和。下述程序计算Fibonacci数列中前15个数,并以每行5个数的格式输出。
[函数2.1]
include <stdio.h>
main()
{ int i,f,f1=1,f2=1;
printf("%5d%5d",f1,f2);
for(i=3;i<=15;i++){
f=(1);
printf("%5d",f);
if((2)= =0) printf("\n");
f1=12;
(3);
}
}
[函数2.2说明]
函数fun(char *str1,char *str2)的功能是将字符串str2拼接到str1之后。
[函数2.2]
fun(char *str1,char *str2)
{ int i,j;
for(i=0;str1[i]!='\0';i++);
for(j=0;str2[j]!='\0';j++) (4);
(5);
}
第10题
下而程序实现十进制向其他进制的转换。
[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;
}
}
为了保护您的账号安全,请在“上学吧”公众号进行验证,点击“官网服务”-“账号验证”后输入验证码“”完成验证,验证成功后方可继续查看答案!