ptr什么意思

渥瑞达北美IT培训

一、简答题。(共14题,共0分,每题0分)

=10,j=10,k=3;k*=i+j;k最后的值是?

答：k=60

ok

2.写出程序结果:

voidFunc(charstr[100])

{

printf("%dn",sizeof(str));

}

答：4或者8（如果操作系统为32位则为4,64位则为8）

是地址吗

3.写出sizeof(structname2)的结果

structname2{

charstr;

intnum;

shortx;

}

不会！看结构

答：此题考察结构对齐的知识，结果为12

4.写出sizeof(structname1)的结果

structname1{

charstr;

shortx;

intnum;

}

不会！

答：同样考察的是结构对齐的知识，结果为8

5.A.c和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会

不会有问题?这两个static变量会保存到哪里（栈还是堆或者其他的）?

答：没有问题，static变量只在当前文件中有效，也就是说static变量的作用

域属于所在的文件域。

渥瑞达北美IT培训

static变量保存在全局/静态区

6.(void*)ptr和(*(void**))ptr的结果是否相同？

答：相同。首先第一个（void*）ptr将ptr转换为空指针类型(一级指针)，（*

（void**））ptr相当于先将ptr转换为空类型指针（二级指针）。二级指针是

指向指针的指针，在前面加上*（解指针），也就是空类型指针了（一级指针）。

7.#defineDOUBLE(x)x+x，i=5*DOUBLE(5)；i是多少？

答:i=5*5+5=30;看书上的结构理解下意思

8.下面的声明都是什么意思？

constinta;

intconsta;

constint*a;

int*consta;

intconst*consta;

答：第一个定义常量a，第二个也是定义常量a，第三个定义常量指针a，第四

个定义指针常量a，第五个定义指向常量的指针常量（相当于const引用）。

9.关键字const是什么含意？

答：修饰基本类型，比如int类型为常量。

修饰指针分为两种情况：指针常量或者常量指针。

修饰类的成员函数，则在此函数中无法修改类中数据成员的值。

修饰返回值意味着返回值不可被改变

修饰函数参数，意味着函数参数不能被有意或者无意修改。

……while和while……do有什么区别？

答：do…while先执行循环再判断条件，while…do先进行判断再执行循环。

11.语句for(；1；)有什么问题？它是什么意思？

他的意思是循环条件永远为真，不停地进行循环操作，除非循环体中有强制退出

循环的语句才能终止循环，其实功能就相当于while(1)

渥瑞达北美IT培训

答：无限循环

12.如何引用一个已经定义过的全局变量？

答：题目说的有点不太清楚，如果是引用其它文件中定义的全局变量用extern，

如果是在本文件中引用的话用作用域运算符::是在c++中的

()结构中条件表达式的类型可以是什么类型？

答：整型，字符型，常量，枚举类型

14..h头文件中的ifndef/define/endif的作用？

答：预编译命令，一般是用来防止头文件多重包含结构？

二、问答题。(共63题,共0分,每题0分)

1.关键字static的作用是什么？

第一：隐藏。static全局变量只在本文件中可访问，其它文件无法访问。

第二：持久保存变量的内容。static变量一经初始化便到程序运行结束后才

会被释放。

第三：默认初始化为变量会被编译器默认初始化为0

[3];

a[0]=0;a[1]=1;a[2]=2;

int*p,*q;

p=a;

q=&a[2];

则a[q-p]=a[2]

这段程序执行完之后数组中元素的值分别是什么？q-p=2

答：0，1，2

渥瑞达北美IT培训

3.根据a的值，完成b的初始化，并将b的值返回

intfunc(floata)

{

intb;

switch(a)

{

ca1:30;

break;

ca2:20;

ca3:16;

default:0

}

returnb;

}

此程序段有什么错误，如果有请指出

答：只能用整型或者字符型或者枚举类型，float类型不正确。

后面没有加break

4.写出程序运行结果

intsum(inta)

{

autointc=0;

staticintb=3;

c+=1;

b+=2;

return(a+b+c);

}

voidmain()

{

intI;

渥瑞达北美IT培训

inta=2;

for(I=0;I<5;I++)

{

printf("%d,",sum(a));

}

}

答：8，10，12，14，16

5.写出输出结果

voidg(int**);

intmain()

{

intline[10],i;

int*p=line;

for(i=0;i<10;i++)

{

*p=i;

g(&p);

}

for(i=0;i<10;i++)

printf("%dn",line[i]);

return0;

}

voidg(int**p)

{

(**p)++;

(*p)++;

}

答：

渥瑞达北美IT培训

6.写出输出结果

intmain()

{

inta[5]={1,2,3,4,5};

int*ptr=(int*)(&a+1);//解释解释1

printf("%d,%d",*(a+1),*(ptr-1));

}

答：2，5

7.写出下面的结果

charstr1[]="abc";

charstr2[]="abc";

constcharstr3[]="abc";

constcharstr4[]="abc";

constchar*str5="abc";

constchar*str6="abc";

char*str7="abc";

char*str8="abc";

printf(“%d”,str1==str2);//数组名就是

printf(“%d”,str3==str4);

printf(“%d”,str5==str6);

printf(“%d”,str7==str8);

答：0011

8.以下3个有什么区别


char*constp;

charconst*p；

constchar*p；

渥瑞达北美IT培训

答：第一个是指针常量，第二个是常量指针，第三个也是常量指针

edshortarray[]={1,2,3,4,5,6,7};

inti=3;

*(array+i)=?

答：4

10.i最后等于多少?

inti=1;

intj=i++;

if((i>j++)&&(i++==j))i+=j;

答：5

11.写一个“标准”宏

1>输入两个参数，输出较小的一个

2>表明1年中有多少秒（忽略闰年问题）

答：此题的考察点是防止数据太大int类型表示不了，现在不用担心（int占4

个字节）

1.#defineMin(a,b)((a)<=(b)?(a):(b))

2.#defineSECONDS_PER_YEAR(60*60*24*365UL

考察内容：

1).#define语法的基本知识（例如：不能以分号结束，括号的使用，等等）

2).意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号

L,告诉编译器这个常数是的长整型数。

3).如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好

的起点。

渥瑞达北美IT培训

12.什么是预编译,何时需要预编译?

答：预编译又称为预处理，主要做一些文本的替换工作。比如#include包含文

件代码，#define宏定义的替换，条件编译等等。

预编译代码有助于在开发周期中缩短编译时间，特别是在以下的情况中：

1.总是使用不经常改动的大型代码体

2.程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选

项。在这种情况下可以将所有包含文件编译为一个预编译头。

用于创建预编译头文件的第一次编译所花费的时间比后面的编译稍长一些，通

过包含预编译代码可以加快后面的编译速度。

13.阐述堆和栈的区别

答：1.申请方式。栈由编译器自动申请空间，堆需要程序员手动申请空间。

2.申请后的系统响应。栈的剩余空间大于所申请的空间，系统为程序提供内存，

否则退出。堆申请方式是链表式申请，遍历空闲内存链表，找到大于申请空间

的内存，从空闲内存链表中删除，分配给程序。

3.申请大小的限制。栈在windows下是向低地址扩展的数据结构，是一块连续

的内存区域，大小是固定的。（一般是2m）堆是向高地址扩展的数据结构，是

不连续的内存区域。

4.申请效率，栈分配速度较快，堆分配速度较慢，容易产生内存碎片。

还有其它的一些区别，课下大家自己去学习一下。

14.简要描述c程序的内存分配

答：C语言内存分配主要分为5块

1.栈。存放局部变量，函数参数等。由编译器自动申请空间，自动释放。

2.堆。由程序员手动申请、释放空间。

3.常量存储区。一般是常量字符串

4.静态/全局区。存储的是静态变量或者全局变量。初始化后等到程序结束后

内存才会被释放

5.程序代码区。存放函数体的二进制代码。

渥瑞达北美IT培训

全局变量与普通的全局变量有什么区别？static局部变量和普通局

部变量有什么区别？static函数与普通函数有什么区别？

答：全局变量只能在本文件中访问，而全局变量可以通过extern在其

它文件中访问

局部变量存储在全局/静态区中，一经初始化直到程序结束后才会被释

放。普通的局部变量存储在栈中。

函数只能在本文件中访问，普通函数可以在其它文件中访问。

16.局部变量能否和全局变量重名，如果可以，请说明原因？

答：可以。局部变量会屏蔽全局变量

17.使用枚举的好处？

答：代码的可读性就好一些

18.全局变量和局部变量在内存中的存储是否有区别？如果有，是什么区别？

答：全局变量存储在全局数据区，初始化后直到程序运行结束后才会释放内存。

局部变量存储在栈上，作用域在其被定义的函数或者块中，出了这个作用域就

会被释放。

19.#include与#include"file.h"的区别？

答：<>一般用来引用系统定义的头文件，“”一般用来引用自定义头文件。

渥瑞达北美IT培训

20.“引用”与指针的区别是什么？

答：引用是变量的别名，指针保存的是变量的地址。也就是说引用是直接操作

变量本身，而指针是间接操作变量。

21.已知strcpy函数的原型是：

char*strcpy(char*strDest,constchar*strSrc);

1.不调用库函数，实现strcpy函数。

2.解释为什么要返回char*。

答：*strcpy(char*strDest,constchar*strSrc)

{

char*strDestCopy=strDest;

if(strDest==NULL||strSrc==NULL)

{

throw("invalidarguments");

}

while((*strDestCopy++=*strSrc++)!='0');

returnstrDest;

}

2.支持链式表达式

22.判断一个字符串是不是回文，当字符串是回文时,函数返回字符串:yes!,否

则函数返回字符串:no。所谓回文即正向与反向的拼写都一样，例如:adgda。

答：

#include

#include

#defineN100

char*judgeStrings(char*str);

intmain()

{

渥瑞达北美IT培训

chara[N];

printf("请输入要判断的回文字符串：");

scanf("%s",a);

printf("%sn",judgeStrings(a));

return0;

}

char*judgeStrings(char*str)

{

if(str==NULL)

throw"error:strisNULL";

intlen=strlen(str);

for(inti=0;i

{

if(str[i]!=str[len-i-1])

return"no";

}

return"yes!";

}

23.递规反向输出字符串的例子,可谓是反序的经典例程,那么任意输入一字符

串，利用递归将其反向输出.

#include

#defineN20

voidgetReverChar(char*str);

intmain()

{

chara[N];

printf("请输入要反序的字符串：");

scanf("%s",a);

getReverChar(a);

printf("n");

return0;

}

voidgetReverChar(char*str)

{

if(*str=='0')

return;

el

{

getReverChar(str+1);

printf("%c",*str);

渥瑞达北美IT培训

}

}

24.用指针的方法，将字符串“ABCD1234efgh”前后对调显示

#include

#include

intmain()

{

chara[]="ABCD1234efgh";

char*p=a;

intlen=strlen(a);

for(inti=0;i

{

chartemp=a[i];

a[i]=a[len-i-1];

a[len-i-1]=temp;

}

printf("%sn",a);

return0;

}

25.两个字符串，s,t;把t字符串插入到s字符串中，s字符串有足够的空间存

放t字符串

答：#include

#include

#defineN100

intmain()

{

chars[N]="HelloWorld";

char*t="welcometoBeijing";

intsLen=strlen(s);

inttLen=strlen(t);

intpos;

printf("请输入要插入的位置：");

渥瑞达北美IT培训

scanf("%d",&pos);

if(pos>sLen||pos<0)

return0;

//先将s字符数组后面的字符放到后面（采用前插法，从0开始）

for(inti=0;i

{

s[pos+tLen+i]=s[pos+i];

}

//再放心的插入t字符数组

for(inti=0;i

{

s[pos+i]=t[i];

}

s[sLen+tLen]='0';

printf("%sn",s);

return0;

}

26.已知strcmp的原型是

intstrcmp(constchar*str1,constchar*str2)，不调用库函数，实现strcmp

函数

答：#include

#include

#defineN100

intstrcmp(constchar*str1,constchar*str2);

intmain()

{

chars[N];

chart[N];

printf("请输入要比较的一个字符串：");

scanf("%s",s);

printf("请输入要比较的另一个字符串：");

scanf("%s",t);

printf("%dn",strcmp1(s,t));

return0;

}

intstrcmp(constchar*str1,constchar*str2)

{

intlen1=strlen(str1);

intlen2=strlen(str2);

intmaxLen=len1>len2?len1:len2;

for(inti=0;i

渥瑞达北美IT培训

{

if(str1[i]>str2[i])

return1;

elif(str1[i]

return-1;

}

return0;

}

27.找出错误

#include“string.h”

voidmain(void)

{char*src="hello,world";

char*dest=NULL;

dest=(char*)malloc(strlen(src));

intlen=strlen(str);

char*d=dest;

char*s=src[len];

while(len--!=0)

d++=s--;

printf("%s",dest);

}

答：.h用<>括起来。

=(char*)malloc(strlen(src));申请的空间不够，需要改为dest=

(char*)malloc(strlen(src)+1);

=strlen(str);改为intlen=strlen(src);

*s=src[len];改为char*s=src[len-1];

5.d++=s--;改为*d++=*s--;

6.需要在printf(“%s”,dest);上面加上一行代码：*d=‘0’;

28.写出输出结果

#include

voidfoo(intm,intn)

{

printf("m=%d,n=%dn",m,n);

}

intmain()

渥瑞达北美IT培训

{

intb=3;

foo(b+=3,++b);

printf("b=%dn",b);

return0;

}

答：此题考察的有一些难度，深入到了编译器级别。编译器实现的不一样，那

么结果也是不一样的。在vc6.0下面，结果为：747在vs2012结果为77

7。在xcode下面是677.

29.分析：

intarr[]={6,7,8,9,10};

int*ptr=arr;

*(ptr++)+=123;

printf(“%d%d”,*ptr,*(++ptr));

答：此题和上一题目类似，考察的是printf()函数的参数入栈顺序，从右往左

的运算。所以结果为：88

30.对下面程序进行分析，若有错误，请写出一个正确的程序段

voidtest2()

{

charstring[10],str1[10];

inti;

for(i=0;i<10;i++)

{

str1[i]='a';

}

strcpy(string,str1);

}

答：错误，主要是str1[10]字符数组没哟0。所以应该如下修改:

for(i=0;i<9;i++)

{

str[i]=‘a’;

}

str[i]=‘0’;

渥瑞达北美IT培训

31.请问一下程序将输出什么结果？

char*RetMemory(void)

{

charp[]=“hellowworld”;

returnp;

}

voidTest(void)

{

char*str=NULL;

str=RetMemory();

printf(str);

}

答：此程序存在的问题是RetMemory(void)函数返回的是局部变量的地址，然后

str指向这个地址，但是实际上这块地址已经让编译器给释放，编译器有可能把

这块内存分配给其它的变量。所以如果内存没有被修改的话输出结果为hello

world,如果被修改则输出结果未知。

32.分析下面的程序：

voidGetMemory(char**p,intnum)

{

*p=(char*)malloc(num);

}

intmain()

{

char*str=NULL;

GetMemory(&str,100);

strcpy(str,"hello");

free(str);

if(str!=NULL)

{

strcpy(str,"world");

}

printf("nstris%s",str);

getchar();

}

答：程序存在的问题是：GetMemory函数成功的为str分配了一块堆上的内存，

但是后来被释放掉了。由于释放后没有将指针置为空，故str肯定不会为NULL。

接着调用strcpy()函数为str指向的空间赋值。这是非法的，str指向的是已

经被释放的内存，故拷贝会失败。

渥瑞达北美IT培训

33.下面的语句会出现什么结果？

charszstr[10];

strcpy(szstr,"");

答：编译不通过，字符数组szstr空间为10，但是字符串为11个（加上0）,

故字符数组空间不够存下字符串。

34.下面的程序会出现什么结果

#include

#include

voidgetmemory(char*p)

{

p=(char*)malloc(100);

strcpy(p,"helloworld");

}

intmain()

{

char*str=NULL;

getmemory(str);

printf("%s/n",str);

free(str);

return0;

}

答：程序存在的问题是str没有指向申请出来的空间，str还是为NULL。free

（）函数释放堆上的空间，可是str并没有指向堆上的空间，故程序会出错。

35.请问以下代码有什么问题：

intmain()

{

chara;

char*str=&a;

渥瑞达北美IT培训

strcpy(str,"hello");

printf(str);

return0;

}

答：字符指针str指向的是一个单一的字符，调用strcpy（）方法赋值的时候，

只能赋一个字符，很明显程序赋的是“hello”6个字符，故程序会发生错误。

36.请找出下面代码中的所有错误

说明：以下代码是把一个字符串倒序，如“abcd”倒序后变为“dcba”

1、#include"string.h"

2、main()

3、{

4、char*src="hello,world";

5、char*dest=NULL;

6、intlen=strlen(src);

7、dest=(char*)malloc(len);

8、char*d=dest;

9、char*s=src[len];

10、while(len--!=0)

11、d++=s--;

12、printf("%s",dest);

13、return0;

14、}

答：请看上面27题

37.有以下程序

#inlcude

intmain()

{

chara[7]="a00a00";

inti,j;

i=sizeof(a);

j=strlen(a);

printf("%d%dn",i,j);

return0;

渥瑞达北美IT培训

}此程序的输出结果是什么？

答：72sizeof是求变量或者类型所占的字节数，chara[7]数组声明了7个

元素的空间，故7个字节，strlen（）函数用来求字符串的长度，原理是找字

符串中的‘0’，在字符数组a中第三个位置找到0，故返回2（不包括

0）

38.问main函数既然不会被其它函数调用，为什么要返回1？

intmain()

{

intx=3;

printf("%d",x);

return1;

}

答：main函数的返回值用于说明程序的退出状态。如果返回0表示程序正常退

出；返回其它的数字的含义则由系统决定。通常，返回非0代表程序异常退出。

main函数的返回值是返回给执行这个进程的进程。

39.交换两个变量的值，不使用第三个变量。

即a=3,b=5,交换之后a=5,b=3;

答：

a=a+b;

b=a–b;

a=a–b;

40.下面这个程序执行后会有什么错误或者效果:

#defineMAX255

intmain()

{

unsignedcharA[MAX],i;//i被定义为unsignedchar

for(i=0;i<=MAX;i++)

A[i]=i;

}

渥瑞达北美IT培训

答：无限循环。此题i被定义为unsignedchar类型，占一个字节，所以表示

的数的个数为256个数，也就是0~255.当i=255,此时再让i+1,则i会重新

变为0.所以i永远小于等于MAX，一直循环下去。

41.描述一下typedef的作用

答：为已知类型定义类型的别名

42.动态内存分配（Dynamicmemoryallocation）

下面的代码片段的输出是什么，为什么？


char*ptr;


if((ptr=(char*)malloc(0))==NULL)


puts("Gotanullpointer");


el


puts("Gotavalidpointer");

答：输出Gotavalidpointer。malloc(0)不返回NULL

43.用C语言如何实现死循环呢？

答：while(1)或者for(;1;)

44.简述数组与指针的区别？

答：数组与指针有很大的不同。数组拥有元素的空间，而指针没有，指针只

能保存地址。还有，指针可以随便改变指向，但是数组不可以。

渥瑞达北美IT培训

45.已知strcmp的原型是

intstrcmp(constchar*str1,constchar*str2)，谈谈你对其参数中const的理解.

答：const用来修饰指针，为常量指针，即指针的指向可以发生变化，但是无法

通过*操作来修改指针所指向的变量。主要是防止在strcmp函数中，程序员有

意或者无意的修改str2变量

46.写出下列代码的输出内容

#include

intinc(inta)

{

return(++a);

}

intmulti(int*a,int*b,int*c)

{

return(*c=*a**b);

}

typedefint(FUNC1)(intin);

typedefint(FUNC2)(int*,int*,int*);

voidshow(FUNC2fun,intarg1,int*arg2)

{

FUNC1*p=&inc;

inttemp=p(arg1);

fun(&temp,&arg1,arg2);

printf("%dn",*arg2);

}

main()

{

inta;

show(multi,10,&a);

return0;

}

答：此题主要是typedefint(FUNC1)(int,int);的作用，还记得我们学过的函

渥瑞达北美IT培训

数指针吗？没错，这就是定义一个函数指针（FUNC1是指针类型，指向返回值为

int，带有两个int类型参数的函数）。知道了这一点，就很容易计算出结果为

110

47.请写出下列代码的输出内容

#include

intmain()

{

inta,b,c,d;

a=10;

b=a++;

c=++a;

d=10*a++;

printf("b，c，d：%d，%d，%d"，b，c，d）;

return0;

}

答：1012120

48.求函数返回值，输入x=9999;(如果可以，写出此程序实现的功能)

intfunc（x）

{

intcountx=0;

while(x)

{

countx++;

x=x&(x-1);

}

returncountx;

}

答：这是统计9999的二进制数值中有多少个1的函数，且有

9999＝9×1024＋512＋256＋15

9×1024中含有1的个数为2；

512中含有1的个数为1；

渥瑞达北美IT培训

256中含有1的个数为1；

15中含有1的个数为4；

故共有1的个数为8，结果为8。

1000-1=0111，正好是原数取反。这就是原理。

用这种方法来求1的个数是很效率很高的。

不必去一个一个地移位。循环次数最少。

49.下面的函数实现在一个数上加一个数，有什么错误？请改正。

intadd_n(intn)

{

staticinti=100;

i+=n;

returni;

}

答：static变量存储在全局/静态区,只初始化一次，后面的数都是在i的基础

上增加的。

50.用变量a给出下面的定义

a)一个整型数（Aninteger）

b)一个指向整型数的指针（Apointertoaninteger）

c)一个指向指针的的指针，它指向的指针是指向一个整型数（Apointertoa

pointertoaninteger）

d)一个有10个整型数的数组（Anarrayof10integers）

e)一个有10个指针的数组，该指针是指向一个整型数的（Anarrayof10

pointerstointegers）

f)一个指向有10个整型数数组的指针（Apointertoanarrayof10integers）

g)一个指向函数的指针，该函数有一个整型参数并返回一个整型数（Apointer

toafunctionthattakesanintegerasanargumentandreturnsaninteger）

h)一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并

返回一个整型数（Anarrayoftenpointerstofunctionsthattakean

integer

argumentandreturnaninteger）

答：a)inta;

b）int*a;

c)int**a;

d)inta[10];

渥瑞达北美IT培训

e)int*a[10];

f)int(*a)[10]

g)int(*a)(intb);

h)typedefint(*POINT)(int);

POINTa[10];

51.求1000！的未尾有几个0（用素数相乘的方法来做，如72=2*2*2*3*3）

答：分析：先把1000!质因数分解，其质因数中2的个数比5的个数多

因为2*5=10

所以1000！中有多少个因数5，1000！的末尾就有多少个0

因为5（1000！）＝[1000/5]+[1000/25]+[1000/125]+[1000/625}

=200+40+8+1=249

所以1000！的末尾就有249个0

编程：

#include

intmain()

{

intsum=0;

intnum;

printf("请输入数据：");

scanf("%d",&num);

for(inti=5;i<=num;i=i*5)

{

sum=sum+num/i;

}

printf("共有%d个零n",sum);

return0;

}

52.输出和为一个给定整数的所有组合

例如n=5

5=1+4；5=2+3（相加的数不能重复）(不考虑负数)

则输出

1，4；2，3。

答：

#include

#include

渥瑞达北美IT培训

intmain(intargc,char*argv[])

{

unsignedlongintnum=0;

scanf("%d",&num);

intmid=0;

for(inti=1;i<=num/2;i++)

{

mid=num-i;

if(mid!=i)

printf("%d=%d+%dn",num,i,mid);

}

return0;

}

53.有以下表达式：

inta=248;

intb=4;

intconstc=21;

constint*d=&a;

int*conste=&b;

intconst*f=&a;

请问下列表达式哪些会被编译器禁止？为什么？

*c=32;

d=&b;

*d=43;

e=34;

e=&a;

f=0x321f;

答：*c=32不可以，c不是指针类型

*d=43不可以，d是常量指针，无法修改指向的变量的值

e=34不可以，类型不匹配

e=&a不可以，e是指针常量，无法改变指针

f=0x321f不可以，类型不匹配

54.编程实现：找出两个字符串中最大公共子字符串,如"abccade","dgcadde"

渥瑞达北美IT培训

的最大子串为"cad"

答：#include

#include

#include

#defineN100

intmain()

{

inta[N][N];//矩阵

charstr1[N];

charstr2[N];

intmaxSubStrLength=0;//最大子串的长度

intsubStringIndex=0;//最大子串的末尾index

inti;

intj;

printf("请输入第一个字符串：");

scanf("%s",str1);

printf("请输入第二个字符串：");

scanf("%s",str2);

intstrLen1=strlen(str1);

intstrLen2=strlen(str2);

//构造矩形

for(i=0;i

{

for(j=0;j

{

if(str1[i]!=str2[j])

a[i][j]=0;

el

{

if(i==0||j==0)

{

a[i][j]=1;

}

el

{

a[i][j]=a[i-1][j-1]+1;

}

}

if(a[i][j]>maxSubStrLength)

{

maxSubStrLength=a[i][j];

subStringIndex=i;

}

渥瑞达北美IT培训

}

}

//显示矩阵

for(i=0;i

{

for(j=0;j

printf("%d",a[i][j]);

printf("n");

}

for(i=0;i

printf("%c",str1[subStringIndex-maxSubStrLength+i+1]);

printf("n");

return0;

}

55.实现子串定位intFindSubStr(constchar*MainStr,constchar

*SubStr)

答：#include

#include

#defineN100

intFindSubStr(constchar*MainStr,constchar*SubStr);

intmain()

{

charstr1[N];

charstr2[N];

printf("输入主字符串：");

scanf("%s",str1);

printf("输入子字符串：");

scanf("%s",str2);

intindex=FindSubStr(str1,str2);

if(index==-1)

printf("未找到！n");

el

printf("找到，下标为：%dn",index);

return0;

}

渥瑞达北美IT培训

intFindSubStr(constchar*MainStr,constchar*SubStr)

{

intindex=0;

intcount=0;

intstrlen1=strlen(MainStr);

intstrlen2=strlen(SubStr);

if(strlen1

return-1;

for(inti=0;i<=strlen1-strlen2;i++)

{

for(intj=0;j

{

index=i+j;

if(MainStr[i+j]==SubStr[j])

{

count++;

}el{count=0;break;}

}

if(count==strlen2)

returnindex-strlen2+1;

}

56.写一段程序，找出数组中第k大小的数，输出数所在的位置。例如{2，4，

3，4，7}中，第一大的数是7，位置在4。第二大、第三大的数都是4，位置在1、

3随便输出哪一个均可。函数接口为：intfind_orderk(constint*narry,const

intn,constintk)

答：#include

#include

#include

#defineN5

intfind_orderk(constint*narry,constintn,constintk);

intmain()

{

intarray[N];

intk;

printf("请输入%d个数：",N);

for(inti=0;i

渥瑞达北美IT培训

scanf("%d",&array[i]);

printf("输入第K大小的数：");

scanf("%d",&k);

intn=find_orderk(array,N,k);

printf("第%d大小的数在%d位置n",k,n);

return0;

}

//函数参数的意思，第一个数组名字，第二个多少个元素，第三个第k大小的数

intfind_orderk(constint*narry,constintn,constintk)

{

if(k<=0&&k>n)

return-1;

int*ptr=(int*)malloc(sizeof(int)*n);

for(inti=0;i

ptr[i]=narry[i];

for(inti=0;i

for(intj=0;j

{

if(ptr[j]>ptr[j+1])

{

inttemp=ptr[j];

ptr[j]=ptr[j+1];

ptr[j+1]=temp;

}

}

for(inti=0;i

{

if(ptr[k-1]==narry[i])

{

free(ptr);

returni+1;

}

}

}

57.已知一个单向链表的头，请写出删除其某一个结点的算法，要求，先找到

此结点，然后删除。

答：#include

structlink

渥瑞达北美IT培训

{

chardata;

structlink*next;

};

intmain()

{

return0;

}

//删除某一个节点，利用值匹配来删除

voidremoveNode(structlink*head,chardata)

{

structlink*p=head;

structlink*q=head;

if(head==NULL)

return;

if(head->data==data)

{

head=head->next;

free(q);

q=NULL;

return;

}

q=p->next;

while(q)

{

if(q->data==data)

{

p->next=q->next;

free(q);

q=NULL;

return;

}

p=q;

q=q->next;

}

printf("未找到要删除的节点!n");

}

58.单链表的建立，把'a'--'z'26个字母插入到链表中，并且倒序，还要打印！

渥瑞达北美IT培训

答：#include

#include

structlink

{

chardata;

structlink*next;

};

structlink*createLink();

voiddisplayLink(structlink*head);

voidfreeLink(structlink*head);

structlink*reverLink(structlink*head);

intmain()

{

structlink*head=createLink();

displayLink(head);

structlink*reLink=reverLink(head);

displayLink(reLink);

freeLink(reLink);

return0;

}

structlink*createLink()

{

structlink*head=(structlink*)malloc(sizeof(structlink));

head->data='a';

head->next=NULL;

structlink*p=head;

structlink*q=head;

for(chari='a'+1;i<='z';i++)

{

q=(structlink*)malloc(sizeof(structlink));

q->data=i;

q->next=NULL;

p->next=q;

p=q;

}

returnhead;

}

voiddisplayLink(structlink*head)

{

while(head!=NULL)

{

渥瑞达北美IT培训

printf("%c",head->data);

head=head->next;

}

printf("n");

}

voidfreeLink(structlink*head)

{

structlink*p=head;

while(p!=NULL)

{

p=head->next;

free(head);

head=p;

}

}

structlink*reverLink(structlink*head)

{

if(head==NULL&&head->next==NULL)

returnhead;

structlink*p=head;

structlink*q=head->next;

structlink*m=NULL;

while(q!=NULL)

{

m=q->next;

q->next=p;

p=q;

q=m;

}

head->next=NULL;

returnp;

}

59.一个单向链表，不知道头节点,一个指针指向其中的一个节点，问如何删除

这个指针指向的节点？

答：不知道头节点，又是单链表，肯定无法访问到此指针指向的前一个节点。

怎么办呢？只能采用一种方法：将此指针指向的节点的值改成此指针指向的下

一个节点的值，然后将下一个节点删掉。

渥瑞达北美IT培训

60.简单介绍一下二叉树。

答：百度一下

//树结构

structBTree

{

structBTree*lChild;

structBTree*rChild;

chardata;

};

//对树操作函数

voidoperateTree(BTree*tree);

voidpreOrder(BTree*tree);//前序遍历

voidmidOrder(BTree*tree);//中序遍历

voidpostOrder(BTree*tree);//后序遍历

intmain(intargc,constchar*argv[])

{

return0;

}

voidoperateTree(BTree*tree)

{

printf("%c",tree->data);

}

voidpreOrder(BTree*tree)

{

if(tree==NULL)

return;

operateTree(tree);

if(tree->lChild!=NULL)

preOrder(tree);

渥瑞达北美IT培训

if(tree->rChild!=NULL)

preOrder(tree->rChild);

}

voidmidOrder(BTree*tree)

{

if(tree==NULL)

return;

if(tree->lChild!=NULL)

midOrder(tree->lChild);

operateTree(tree);

if(tree->rChild!=NULL)

midOrder(tree->rChild);

}

voidpostOrder(BTree*tree)

{

if(tree==NULL)

return;

if(tree->lChild!=NULL)

postOrder(tree->lChild);

if(tree->rChild!=NULL)

postOrder(tree->rChild);

operateTree(tree);

}

61.用代码实现二叉树的后序遍历。

答：

voidpostOrder(BTree*tree)

{

if(tree==NULL)

return;

if(tree->lChild!=NULL)

postOrder(tree->lChild);

if(tree->rChild!=NULL)

postOrder(tree->rChild);

operateTree(tree);

}

62.用代码实现二叉树的中序遍历。

渥瑞达北美IT培训

voidmidOrder(BTree*tree)

{

if(tree==NULL)

return;

if(tree->lChild!=NULL)

midOrder(tree->lChild);

operateTree(tree);

if(tree->rChild!=NULL)

midOrder(tree->rChild);

}

63.用程序实现二叉树的前序遍历。

voidpreOrder(BTree*tree)

{

if(tree==NULL)

return;

operateTree(tree);

if(tree->lChild!=NULL)

preOrder(tree);

if(tree->rChild!=NULL)

preOrder(tree->rChild);

}