当前位置：首页 > 教学范文 > 试题试卷> c语言面试题

c语言面试题

时间：2023-09-01 08:48:07 试题试卷收藏本文下载本文

c语言面试题（共10篇）由网友“小蛮啊小蛮”投稿提供，下面是小编收集整理的c语言面试题，供大家参考借鉴，希望可以帮助到有需要的朋友。

c语言面试题

篇1：c语言面试题及答案

11. 指向常量的指针和常指针的区别

答案：指向常量的指针所指向的内容不能被修改但能够指向其它的量，而常指针是指向的内容可以被修改但指针不能再指向其它地方。

12. if (a=b)

printf(“a==b”)

else

printf(“a!=b”);

输出结果为：

A.a==b B.a!=b C.不一定 D.不能运行

答案：不一定，这要根据b的内容来决定。通常再编程时不要使用此类的赋值语句。

13.在内联函数中使用static变量，比如

inline test

{ static couter = 0;

counter++;

}

会有什么问题?

答案：会造成多次定义该变量，因此再内联函数中禁止定义静态变量

14. F是一个结构类型，有如下定义：

F f1,f2;

问：f1=f2;语句是否成立?

答案：该语句成立，不过有的编译器不支持。实际上编译器也是用内存拷贝函数来实现的。

15.全局变量、局部变量、模块变量在内存空间中如何存放?(数据区or栈空间?)

答案：全局变量在全局空间分配，局部变量在栈空间分配，模块变量在全局空间分配。

16.struct A{

......

union {

int x;

.....

};

}

struct A a;

问：a.x这样的表示法是否成立?

答案：成立

如果结构定义改为如下定义

.struct A{

......

int x;

union {

int x;

.....

};

}

那a.x表示法是否成立?

答案：不成立，编译时会报x变量重定义

17. #define REDEF(name,arg1,arg...) \

_##name (arg1,##arg)

问：以下两个语句宏展开的结果

REDEF(test_fn1,int a,int b);

REDEF(test_fn2,int a);

答案：

_test_fn1(int a ,int b)

_test_fn2(int a);

注意：在VC中不支持，gcc才支持该参数宏函数。

18. fnxxxx_max(char str[])

{

putchar str[0];

str++; //(1)

printf(“%s”,str);

}

main()

{

char str[20]={“ABCDEFG”};

fnxxxx_max(str);

str++; //(2)

printf(“%s”,str);

}

问：语句(1)和语句(2)是否成立?

答案：语句(1)成立，语句(2)不成立

19.#define SRR 0x001;

#define SRT 0x002;

#define SRI 0x0900;

EVENT = SRR|SRT|SRI

问：上面的语句有什么问题?EVENT的值会是多少?

答案：宏展开后变为：

EVENT = 0x001; 0x002;0x0900;

因此EVENT的值为0x001,所以在编程时一定要小心，一定不要在常量宏定义的后面加上分号。

篇2：C语言面试题大12

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

#include

int main()

{

char str[] = “ABCD1234efgh”;

int length = strlen(str);

char * p1 = str;

char * p2 = str + length - 1;

while(p1 < p2)

{

char c = *p1;

*p1 = *p2;

*p2 = c;

++p1;

--p2;

}

printf(“str now is %s”,str);

system(“pause”);

return 0;

}

2、有一分数序列：1/2,1/4,1/6,1/8……，用函数调用的方法，求此数列前20项的和

#include

double getValue()

{

double result = 0;

int i = 2;

while(i < 42)

{

result += 1.0 / i;//一定要使用1.0做除数，不能用1，否则结果将自动转化成整数，即0.000000

i += 2;

}

return result;

}

int main()

{

printf(“result is %f”, getValue());

system(“pause”);

return 0;

}

Top

回复人：free131(白日?做梦!) ( ) 信誉：100 -4-17 10:18:33 得分:0

有一个数组a[1000]存放0--1000;要求每隔二个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置，

以7个数为例：

{0,1,2,3,4,5,6,7} 0-->1-->2(删除)-->3-->4-->5(删除)-->6-->7-->0(删除)，如此循环直到最后一个数被删除。

方法1：数组

#include

using namespace std;

#define null 1000

int main()

{

int arr[1000];

for (int i=0;i<1000;++i)

arr[i]=i;

int j=0;

int count=0;

while(count<999)

{

while(arr[j%1000]==null)

j=(++j)%1000;

while(arr[j%1000]==null)

j=(++j)%1000;

while(arr[j%1000]==null)

j=(++j)%1000;

arr[j]=null;

++count;

}

while(arr[j]==null)

j=(++j)%1000;

cout<<< p>

return 0;

}方法2：链表

#include

using namespace std;

#define null 0

struct node

{

int data;

node* next;

};

int main()

{

node* head=new node;

head->data=0;

head->next=null;

node* p=head;

for(int i=1;i<1000;i++)

{

node* tmp=new node;

tmp->data=i;

tmp->next=null;

head->next=tmp;

head=head->next;

}

head->next=p;

while(p!=p->next)

{

p->next->next=p->next->next->next;

p=p->next->next;

}

cout

return 0;

}

方法3：通用算法

#include

#define MAXLINE 1000 //元素个数

MAXLINE 元素个数

a[] 元素数组

R[] 指针场

suffix 下标

index 返回最后的下标序号

values 返回最后的下标对应的值

start 从第几个开始

K 间隔

int find_n(int a[],int R[],int K,int& index,int& values,int s=0) {

int suffix;

int front_node,current_node;

suffix=0;

if(s==0) {

current_node=0;

front_node=MAXLINE-1;

}

else {

current_node=s;

front_node=s-1;

}

while(R[front_node]!=front_node) {

printf(“%d”,a[current_node]);

R[front_node]=R[current_node];

if(K==1) {

current_node=R[front_node];

continue;

}

for(int i=0;i< p>

front_node=R[front_node];

}

current_node=R[front_node];

}

index=front_node;

values=a[front_node];

return 0;

}

int main(void) {

int a[MAXLINE],R[MAXLINE],suffix,index,values,start,i,K;

suffix=index=values=start=0;

K=2;

for(i=0;i

a[i]=i;

R[i]=i+1;

}

R[i-1]=0;

find_n(a,R,K,index,values,2);

printf(“the value is %d,%d”,index,values);

return 0;

}

试题：

void test2()

{

char string[10], str1[10];

int i;

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

{

str1[i] = “a”;

}

strcpy( string, str1 );

}

解答：对试题2，如果面试者指出字符数组str1不能在数组内结束可以给3分;如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10 分;

str1不能在数组内结束:因为str1的存储为：{a,a,a,a,a,a,a,a,a,a},没有“\0”(字符串结束符)，所以不能结束

strcpy( char *s1,char *s2)他的工作原理是，扫描s2指向的内存，逐个字符付到s1所指向的内存，直到碰到“\0”,因为str1结尾没有“\0”，所以具有不确定性，不知道他后面还会付什么东东，

正确应如下

void test2()

{

char string[10], str1[10];

int i;

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

{

str1[i] = “a”+i; //把abcdefghi赋值给字符数组

}

str[i]=“\0”;//加上结束符

strcpy( string, str1 );

}

第二个code题是实现strcmp

int StrCmp(const char *str1, const char *str2)

做是做对了，没有抄搞，比较乱

int StrCmp(const char *str1, const char *str2)

{

assert(str1 && srt2);

while (*str1 && *str2 && *str1 == *str2) {

str1++, str2++;

}

if (*str1 && *str2)

return (*str1-*str2);

elseif (*str1 && *str2==0)

return 1;

elseif (*str1 = = 0 && *str2)

return -1;

else

return 0;

}

int StrCmp(const char *str1, const char *str2)

{

//省略判断空指针(自己保证)

while(*str1 && *str1++ = = *str2++);

return *str1-*str2;

}

第三个code题是实现子串定位

int FindSubStr(const char *MainStr, const char *SubStr)

做是做对了，没有抄搞，比较乱

int MyStrstr(const char* MainStr, const char* SubStr)

{

const char *p;

const char *q;

const char * u = MainStr;

//assert((MainStr!=NULL)&&( SubStr!=NULL));//用断言对输入进行判断

while(*MainStr) //内部进行递增

{

p = MainStr;

q = SubStr;

while(*q && *p && *p++ == *q++);

if(!*q )

{

return MainStr - u +1 ;//MainStr指向当前起始位，u指向

}

MainStr ++;

}

return -1;

}

分析：

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

int *ptr = arr;

*(ptr++)+=123;

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

输出：8 8

过程：对于*(ptr++)+=123;先做加法6+123，然后++，指针指向7;对于printf(“ %d %d ”, *ptr, *(++ptr));从后往前执行，指针先++，指向8，然后输出8，紧接着再输出8

篇3：C语言面试题大13

1. 有双向循环链表结点定义为：

struct node

{ int data;

struct node *front,*next;

};

有两个双向循环链表A，B，知道其头指针为：pHeadA,pHeadB，请写一函数将两链表中data值相同的结点删除

BOOL DeteleNode(Node *pHeader, DataType Value)

{

if (pHeader == NULL) return;

BOOL bRet = FALSE;

Node *pNode = pHead;

while (pNode != NULL)

{

if (pNode->data == Value)

{

if (pNode->front == NULL)

{

pHeader = pNode->next;

pHeader->front = NULL;

}

else

{

if (pNode->next != NULL)

{

pNode->next->front = pNode->front;

}

pNode->front->next = pNode->next;

}

Node *pNextNode = pNode->next;

delete pNode;

pNode = pNextNode;

bRet = TRUE;

//不要break或return, 删除所有

}

else

{

pNode = pNode->next;

}

return bRet;

}

void DE(Node *pHeadA, Node *pHeadB)

{

if (pHeadA == NULL || pHeadB == NULL)

{

return;

}

Node *pNode = pHeadA;

while (pNode != NULL)

{

if (DeteleNode(pHeadB, pNode->data))

{

if (pNode->front == NULL)

{

pHeadA = pNode->next;

pHeadA->front = NULL;

}

else

{

pNode->front->next = pNode->next;

if (pNode->next != NULL)

{

pNode->next->front = pNode->front;

}

Node *pNextNode = pNode->next;

delete pNode;

pNode = pNextNode;

}

else

{

pNode = pNode->next;

}

2. 编程实现：找出两个字符串中最大公共子字符串,如“abccade”,“dgcadde”的最大子串为“cad”

int GetCommon(char *s1, char *s2, char **r1, char **r2)

{

int len1 = strlen(s1);

int len2 = strlen(s2);

int maxlen = 0;

for(int i = 0; i < len1; i++)

{

for(int j = 0; j < len2; j++)

{

if(s1[i] == s2[j])

{

int as = i, bs = j, count = 1;

while(as + 1 < len1 && bs + 1 < len2 && s1[++as] == s2[++bs])

count++;

if(count >maxlen)

{

maxlen = count;

*r1 = s1 + i;

*r2 = s2 + j;

}

3. 编程实现：把十进制数(long型)分别以二进制和十六进制形式输出，不能使用printf系列库函数

char* test3(long num) {

char* buffer = (char*)malloc(11);

buffer[0] = “0”;

buffer[1] = “x”;

buffer[10] = “\0”;

char* temp = buffer + 2;

for (int i=0; i < 8; i++) {

temp[i] = (char)(num<<4*i>>28);

temp[i] = temp[i] >= 0 ? temp[i] : temp[i] + 16;

temp[i] = temp[i] < 10 ? temp[i] + 48 : temp[i] + 55;

}

return buffer;

}

输入N, 打印 N*N 矩阵

比如 N = 3，打印：

1 2 3

8 9 4

7 6 5

N = 4，打印：

1 2 3 4

12 13 14 5

11 16 15 6

10 9 8 7

解答：

1 #define N 15

int s[N][N];

void main

{

int k = 0, i = 0, j = 0;

int a = 1;

for( ; k < (N+1)/2; k++ )

{

while( j < N-k ) s[i][j++] = a++; i++; j--;

while( i < N-k ) s[i++][j] = a++; i--; j--;

while( j >k-1 ) s[i][j--] = a++; i--; j++;

while( i >k ) s[i--][j] = a++; i++; j++;

}

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

{

for( j = 0; j < N; j++ )

cout << s[i][j] << “ ”;

cout << endl;

}

2 define MAX_N 100

int matrix[MAX_N][MAX_N];

*(x,y)：第一个元素的坐标

* start：第一个元素的值

* n：矩阵的大小

void SetMatrix(int x, int y, int start, int n) {

int i, j;

if (n <= 0) //递归结束条件

return;

if (n == 1) { //矩阵大小为1时

matrix[x][y] = start;

return;

}

for (i = x; i < x + n-1; i++) //矩阵上部

matrix[y][i] = start++;

for (j = y; j < y + n-1; j++) //右部

matrix[j][x+n-1] = start++;

for (i = x+n-1; i >x; i--) //底部

matrix[y+n-1][i] = start++;

for (j = y+n-1; j >y; j--) //左部

matrix[j][x] = start++;

SetMatrix(x+1, y+1, start, n-2); //递归

}

void main() {

int i, j;

int n;

scanf(“%d”, &n);

SetMatrix(0, 0, 1, n);

//打印螺旋矩阵

for(i = 0; i < n; i++) {

for (j = 0; j < n; j++)

printf(“%4d”, matrix[i][j]);

printf(“”);

}

斐波拉契数列递归实现的方法如下：

int Funct( int n )

{

if(n==0) return 1;

if(n==1) return 1;

retrurn Funct(n-1) + Funct(n-2);

}

请问，如何不使用递归，来实现上述函数?

请教各位高手!

解答：int Funct( int n ) // n 为非负整数

{

int a=0;

int b=1;

int c;

if(n==0) c=1;

else if(n==1) c=1;

else for(int i=2;i<=n;i++) //应该n从2开始算起

{

c=a+b;

a=b;

b=c;

}

return c;

}

解答：

现在大多数系统都是将低字位放在前面，而结构体中位域的申明一般是先声明高位，

C语言面试题大汇总13

，

100 的二进制是 001 100 100

低位在前高位在后

001----s3

100----s2

100----s1

所以结果应该是 1

如果先申明的在低位则：

001----s1

100----s2

100----s3

结果是 4

1、原题跟little-endian，big-endian没有关系

2、原题跟位域的存储空间分配有关，到底是从低字节分配还是从高字节分配，从Dev C++和VC7.1上看，都是从低字节开始分配，并且连续分配，中间不空，不像谭的书那样会留空位

3、原题跟编译器有关，编译器在未用堆栈空间的默认值分配上有所不同，Dev C++未用空间分配为

01110111b，VC7.1下为11001100b,所以在Dev C++下的结果为5，在VC7.1下为1。

注：PC一般采用little-endian，即高高低低，但在网络传输上，一般采用big-endian，即高低低高，华为是做网络的，所以可能考虑big-endian模式，这样输出结果可能为4

判断一个字符串是不是回文

int IsReverseStr(char *aStr)

{

int i,j;

int found=1;

if(aStr==NULL)

return -1;

j=strlen(aStr);

for(i=0;i

if(*(aStr+i)!=*(aStr+j-i-1))

{

found=0;

break;

}

return found;

}

Josephu 问题为：设编号为1，2，… n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

数组实现：

#include

int Josephu(int n, int m)

{

int flag, i, j = 0;

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

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

arr[i] = 1;

for (i = 1; i < n; ++i)

{

flag = 0;

while (flag < m)

{

if (j == n)

j = 0;

if (arr[j])

++flag;

++j;

}

arr[j - 1] = 0;

printf(“第%4d个出局的人是：%4d号”, i, j);

}

free(arr);

return j;

}

int main()

{

int n, m;

scanf(“%d%d”, &n, &m);

printf(“最后胜利的是%d号!”, Josephu(n, m));

system(“pause”);

return 0;

}

链表实现：

#include

typedef struct Node

{

int index;

struct Node *next;

}JosephuNode;

int Josephu(int n, int m)

{

int i, j;

JosephuNode *head, *tail;

head = tail = (JosephuNode *)malloc(sizeof(JosephuNode));

for (i = 1; i < n; ++i)

{

tail->index = i;

tail->next = (JosephuNode *)malloc(sizeof(JosephuNode));

tail = tail->next;

}

tail->index = i;

tail->next = head;

for (i = 1; tail != head; ++i)

{

for (j = 1; j < m; ++j)

{

tail = head;

head = head->next;

}

tail->next = head->next;

printf(“第%4d个出局的人是：%4d号”, i, head->index);

free(head);

head = tail->next;

}

i = head->index;

free(head);

return i;

}

int main()

{

int n, m;

scanf(“%d%d”, &n, &m);

printf(“最后胜利的是%d号!”, Josephu(n, m));

system(“pause”);

return 0;

}

已知strcpy函数的原型是：

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

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

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

解说：

1.strcpy的实现代码

char * strcpy(char * strDest,const char * strSrc)

{

if ((strDest==NULL)||(strSrc==NULL)) file://[/1]

throw “Invalid argument(s)”; //[2]

char * strDestCopy=strDest; file://[/3]

while ((*strDest++=*strSrc++)!=“\0”); file://[/4]

return strDestCopy;

}

错误的做法：

[1]

(A)不检查指针的有效性，说明答题者不注重代码的健壮性。

(B) 检查指针的有效性时使用((!strDest)||(!strSrc))或(!(strDest&&strSrc))，说明答题者对C语言中类型的隐式转换没有深刻认识。在本例中char *转换为bool即是类型隐式转换，这种功能虽然灵活，但更多的是导致出错概率增大和维护成本升高。所以C++专门增加了bool、true、false 三个关键字以提供更安全的条件表达式。

(C)检查指针的有效性时使用((strDest==0)||(strSrc==0))，说明答题者不知道使用常量的好处。直接使用字面常量(如本例中的0)会减少程序的可维护性。0虽然简单，但程序中可能出现很多处对指针的检查，万一出现笔误，编译器不能发现，生成的程序内含逻辑错误，很难排除。而使用NULL代替0，如果出现拼写错误，编译器就会检查出来。

[2]

(A)return new string(“Invalid argument(s)”);，说明答题者根本不知道返回值的用途，并且他对内存泄漏也没有警惕心。从函数中返回函数体内分配的内存是十分危险的做法，他把释放内存的义务抛给不知情的调用者，绝大多数情况下，调用者不会释放内存，这导致内存泄漏。

(B)return 0;，说明答题者没有掌握异常机制。调用者有可能忘记检查返回值，调用者还可能无法检查返回值(见后面的链式表达式)。妄想让返回值肩负返回正确值和异常值的双重功能，其结果往往是两种功能都失效。应该以抛出异常来代替返回值，这样可以减轻调用者的负担、使错误不会被忽略、增强程序的可维护性。

[3]

(A)忘记保存原始的strDest值，说明答题者逻辑思维不严密。

[4]

(A)循环写成while (*strDest++=*strSrc++);，[1](B)。

(B)循环写成while (*strSrc!=“\0”) *strDest++=*strSrc++;，说明答题者对边界条件的检查不力。循环体结束后，strDest字符串的末尾没有正确地加上“\0”。

篇4：C语言面试题大11

1. 简述一个Linux驱动程序的主要流程与功能，

2. 请列举一个软件中时间换空间或者空间换时间的例子。

void swap(int a,int b)

{

int c; c=a;a=b;b=a;

}

--->空优

void swap(int a,int b)

{

a=a+b;b=a-b;a=a-b;

}

6. 请问一下程序将输出什么结果?

char *RetMenory(void)

{

char p[] = “hellow world”;

return p;

}

void Test(void)

{

char *str = NULL;

str = RetMemory();

printf(str);

}

RetMenory执行完毕，p资源被回收，指向未知地址。返回地址，str的内容应是不可预测的, 打印的应该是str的地址

写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)

功能：

在字符串中找出连续最长的数字串，并把这个串的长度返回，并把这个最长数字串付给其中一个函数参数outputstr所指内存。例如：“abcd12345ed125ss123456789”的首地址传给intputstr后，函数将返回

9，outputstr所指的值为123456789

int continumax(char *outputstr, char *inputstr)

{

char *in = inputstr, *out = outputstr, *temp, *final;

int count = 0, maxlen = 0;

while( *in != “\0” )

{

if( *in >47 && *in < 58 )

{

for(temp = in; *in >47 && *in < 58 ; in++ )

count++;

}

else

in++;

if( maxlen < count )

{

maxlen = count;

count = 0;

final = temp;

}

for(int i = 0; i < maxlen; i++)

{

*out = *final;

out++;

final++;

}

*out = “\0”;

return maxlen;

}

不用库函数,用C语言实现将一整型数字转化为字符串

方法1：

int getlen(char *s){

int n;

for(n = 0; *s != “\0”; s++)

n++;

return n;

}

void reverse(char s[])

{

int c,i,j;

for(i = 0,j = getlen(s) - 1; i < j; i++,j--){

c = s[i];

s[i] = s[j];

s[j] = c;

}

void itoa(int n,char s[])

{

int i,sign;

if((sign = n) < 0)

n = -n;

i = 0;

do{/*以反序生成数字*/

s[i++] = n%10 + “0”;/*get next number*/

}while((n /= 10) >0);/*delete the number*/

if(sign < 0)

s[i++] = “-”;

s[i] = “\0”;

reverse(s);

}

方法2:

#include

using namespace std;

void itochar(int num);

void itochar(int num)

{

int i = 0;

int j ;

char stra[10];

char strb[10];

while ( num )

{

stra[i++]=num%10+48;

num=num/10;

}

stra[i] = “\0”;

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

{

strb[j] = stra[i-j-1];

}

strb[j] = “\0”;

cout<<< p>

}

int main()

{

int num;

cin>>num;

itochar(num);

return 0;

}

前几天面试，有一题想不明白,请教大家!

typedef struct

{

int a:2;

int b:2;

int c:1;

}test;

test t;

t.a = 1;

t.b = 3;

t.c = 1;

printf(“%d”,t.a);

printf(“%d”,t.b);

printf(“%d”,t.c);

谢谢!

t.a为01,输出就是1

t.b为11，输出就是-1

t.c为1，输出也是-1

3个都是有符号数int嘛，

这是位扩展问题

编译器进行符号扩展

求组合数：求n个数(1....n)中k个数的组合....

如：combination(5,3)

要求输出：543，542，541，532，531，521，432，431，421，321，

#include

int pop(int *);

int push(int );

void combination(int ,int );

int stack[3]={0};

top=-1;

int main()

{

int n,m;

printf(“Input two numbers:”);

while( (2!=scanf(“%d%*c%d”,&n,&m)) )

{

fflush(stdin);

printf(“Input error! Again:”);

}

combination(n,m);

printf(“”);

}

void combination(int m,int n)

{

int temp=m;

push(temp);

while(1)

{

if(1==temp)

{

if(pop(&temp)&&stack[0]==n) //当栈底元素弹出&&为可能取的最小值，循环退出

break;

}

else if( push(--temp))

{

printf(“%d%d%d ”,stack[0],stack[1],stack[2]);

pop(&temp);

}

int push(int i)

{

stack[++top]=i;

if(top<2)

return 0;

else

return 1;

}

int pop(int *i)

{

*i=stack[top--];

if(top>=0)

return 0;

else

return 1;

}

篇5：C语言面试题大10

同学的4道面试题，应聘的职位是搜索引擎工程师，后两道超级难，(希望大家多给一些算发)

1.给两个数组和他们的大小，还有一动态开辟的内存，求交集，把交集放到动态内存dongtai，并且返回交集个数

long jiaoji(long* a[],long b[],long* alength,long blength,long* dongtai[])

2.单连表的建立，把“a”--“z”26个字母插入到连表中，并且倒叙，还要打印!

方法1：

typedef struct val

{ int date_1;

struct val *next;

}*p;

void main(void)

{ char c;

for(c=122;c>=97;c--)

{ p.date=c;

p=p->next;

}

p.next=NULL;

}

方法2：

node *p = NULL;

node *q = NULL;

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

head->data = “ ”;head->next=NULL;

node *first = (node*)malloc(sizeof(node));

first->data = “a”;first->next=NULL;head->next = first;

p = first;

int longth = “z” - “b”;

int i=0;

while ( i<=longth )

{

node *temp = (node*)malloc(sizeof(node));

temp->data = “b”+i;temp->next=NULL;q=temp;

head->next = temp; temp->next=p;p=q;

i++;

}

print(head);

3.可怕的题目终于来了

象搜索的输入信息是一个字符串，统计300万输入信息中的最热门的前十条，我们每次输入的一个字符串为不超过255byte,内存使用只有1G,

请描述思想，写出算发(c语言)，空间和时间复杂度，

4.国内的一些帖吧，如baidu,有几十万个主题，假设每一个主题都有上亿的跟帖子，怎么样设计这个系统速度最好，请描述思想，写出算发(c语言)，空间和时间复杂度，

#include string.h

main(void)

{ char *src=“hello,world”;

char *dest=NULL;

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

int len=strlen(str);

char *d=dest;

char *s=src[len];

while(len--!=0)

d++=s--;

printf(“%s”,dest);

}

找出错误!!

#include “string.h”

#include “stdio.h”

#include “malloc.h”

main(void)

{

char *src=“hello,world”;

char *dest=NULL;

dest=(char *)malloc(sizeof(char)*(strlen(src)+1));

int len=strlen(src);

char *d=dest;

char *s=src+len-1;

while(len--!=0)

*d++=*s--;

*d=“\0”;

printf(“%s”,dest);

}

篇6：C语言面试题大9

今天早上的面试题9道，比较难，向牛人请教，国内的一牛公司，坐落在北京北四环某大厦：

1、线形表a、b为两个有序升序的线形表，编写一程序，使两个有序线形表合并成一个有序升序线形表h;

答案在请化大学严锐敏《数据结构第二版》第二章例题，数据结构当中，这个叫做：两路归并排序

Linklist *unio(Linklist *p,Linklist *q){

linklist *R,*pa,*qa,*ra;

pa=p;

qa=q;

R=ra=p;

while(pa->next!=NULL&&qa->next!=NULL){

if(pa->data>qa->data){

ra->next=qa;

qa=qa->next;

}

else{

ra->next=pa;

pa=pa->next;

}

if(pa->next!=NULL)

ra->next=pa;

if(qa->next!=NULL)

ra->next==qa;

return R;

}

2、运用四色定理，为N个局域举行配色，颜色为1、2、3、4四种，另有数组adj[][N]，如adj[i][j]=1则表示i区域与j区域相邻，数组color[N]，如color[i]=1,表示i区域的颜色为1号颜色，

C语言面试题大汇总9

，

四色填充

3、用递归算法判断数组a[N]是否为一个递增数组。

递归的方法，记录当前最大的，并且判断当前的是否比这个还大，大则继续，否则返回false结束：

bool fun( int a[], int n )

{

if( n= =1 )

return true;

if( n= =2 )

return a[n-1] >= a[n-2];

return fun( a,n-1) && ( a[n-1] >= a[n-2] );

}

4、编写算法，从10亿个浮点数当中，选出其中最大的10000个。

用外部排序，在《数据结构》书上有

《计算方法导论》在找到第n大的数的算法上加工

5、编写一unix程序，防止僵尸进程的出现。

篇7：C语言面试题大8

写一段程序，找出数组中第k大小的数，输出数所在的位置，例如{2，4，3，4，7}中，第一大的数是7，位置在4。第二大、第三大的数都是4，位置在1、3随便输出哪一个均可。函数接口为：int find_orderk(const int* narry,const int n,const int k)

要求算法复杂度不能是O(n^2)

谢谢!

可以先用快速排序进行排序，其中用另外一个进行地址查找

代码如下，在VC++6.0运行通过。给分吧^-^

//快速排序

#include

usingnamespacestd;

intPartition (int*L,intlow,int high)

{

inttemp = L[low];

intpt = L[low];

while (low < high)

{

while (low < high && L[high] >= pt)

--high;

L[low] = L[high];

while (low < high && L[low] <= pt)

++low;

L[low] = temp;

}

L[low] = temp;

returnlow;

}

voidQSort (int*L,intlow,int high)

{

if (low < high)

{

intpl = Partition (L,low,high);

QSort (L,low,pl - 1);

QSort (L,pl + 1,high);

}

intmain

{

intnarry[100],addr[100];

intsum = 1,t;

cout << “Input number:” << endl;

cin >>t;

while (t != -1)

{

narry[sum] = t;

addr[sum - 1] = t;

sum++;

cin >>t;

}

sum -= 1;

QSort (narry,1,sum);

for (int i = 1; i <= sum;i++)

cout << narry[i] << “ ”;

cout << endl;

intk;

cout << “Please input place you want:” << endl;

cin >>k;

intaa = 1;

intkk = 0;

for (;;)

{

if (aa == k)

break;

if (narry[kk] != narry[kk + 1])

{

aa += 1;

kk++;

}

cout << “The NO.” << k << “number is:” << narry[sum - kk] << endl;

cout << “And it”s place is:“ ;

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

{

if (addr[i] == narry[sum - kk])

cout << i << ” “;

}

return0;

}

1、找错

Void test1()

{

char string[10];

char* str1=”0123456789“;

strcpy(string, str1);// 溢出，应该包括一个存放”\0“的字符string[11]

}

Void test2()

{

char string[10], str1[10];

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

{

str1[i] =”a“;

}

strcpy(string, str1);// I，i没有声明，

}

Void test3(char* str1)

{

char string[10];

if(strlen(str1)<=10)// 改成<10,字符溢出，将strlen改为sizeof也可以

{

strcpy(string, str1);

}

void g(int**);

int main()

{

int line[10],i;

int *p=line; //p是地址的地址

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

{

*p=i;

g(&p);//数组对应的值加1

}

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

printf(”%d“,line[i]);

return 0;

}

void g(int**p)

{

(**p)++;

(*p)++;// 无效

}

输出：

3. 写出程序运行结果

int sum(int a)

{

auto int c=0;

static int b=3;

c+=1;

b+=2;

return(a+b+c);

}

void main()

{

int I;

int a=2;

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

{

printf(”%d,“, sum(a));

}

// static会保存上次结果，记住这一点，剩下的自己写

输出：8,10,12,14,16,

int func(int a)

{

int b;

switch(a)

{

case 1: 30;

case 2: 20;

case 3: 16;

default: 0

}

return b;

}

则func(1)=?

// b定义后就没有赋值。

int a[3];

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

int *p, *q;

p=a;

q=&a[2];

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

解释：指针一次移动一个int但计数为1

篇8：C语言面试题大3

1、static全局变量与普通的全局变量有什么区别 static局部变量和普通局部变量有什么区别 static函数与普通函数有什么区别

全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量，全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。

static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件

static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;

static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值;

static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

程序的局部变量存在于(堆栈)中，全局变量存在于(静态区 )中，动态申请数据存在于( 堆)中。

2、设有以下说明和定义：

typedef union {long i; int k[5]; char c;} DATE;

struct data { int cat; DATE cow; double dog;} too;

DATE max;

则语句 printf(”%d“,sizeof(struct date)+sizeof(max));的执行结果是：___52____

答：DATE是一个union, 变量公用空间. 里面最大的变量类型是int[5], 占用20个字节. 所以它的大小是20

data是一个struct, 每个变量分开占用空间. 依次为int4 + DATE20 + double8 = 32.

所以结果是 20 + 32 = 52.

当然...在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20

3、队列和栈有什么区别

队列先进先出，栈后进先出

4、写出下列代码的输出内容

以下是引用片段：

#include

int inc(int a)

{

return(++a);

}

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

{

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

}

typedef int(FUNC1)(int in);

typedef int(FUNC2) (int*,int*,int*);

void show(FUNC2 fun,int arg1, int*arg2)

{

INCp=&inc;

int temp =p(arg1);

fun(&temp,&arg1, arg2);

printf(”%d“,*arg2);

}

main()

{

int a;

show(multi,10,&a);

return 0;

}

答：110

5、请找出下面代码中的所以错误

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

以下是引用片段：

1、#include”string.h“

2、main()

3、{

4、char*src=”hello,world“;

5、char* dest=NULL;

6、int len=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、return 0;

14、}

答：

方法1：

以下是引用片段：

int main(){

char* src = ”hello,world“;

int len = strlen(src);

char* dest = (char*)malloc(len+1);//要为\0分配一个空间

char* d = dest;

char* s = &src[len-1];//指向最后一个字符

while( len-- != 0 )

*d++=*s--;

*d = 0;//尾部要加\0

printf(”%s“,dest);

free(dest);// 使用完，应当释放空间，以免造成内存汇泄露

return 0;

}

方法2：

以下是引用片段：

#include

main()

{

char str[]=”hello,world“;

int len=strlen(str);

char t;

for(int i=0; i

{

t=str[i];

str[i]=str[len-i-1]; str[len-i-1]=t;

}

printf(”%s“,str);

return 0;

}

篇9：C语言面试题大7

说明data为bs变量，共占两个字节，其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：

1. 一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：

struct bs

{

unsigned a:4

unsigned :0 /*空域*/

unsigned b:4 /*从下一单元开始存放*/

unsigned c:4

}

在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。

2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。

3. 位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：

struct k

{

int a:1

int :2 /*该2位不能使用*/

int b:3

int c:2

};

从以上分析可以看出，位域在本质上就是一种结构类型，不过其成员是按二进位分配的。

二、位域的使用位域的使用和结构成员的使用相同，其一般形式为：位域变量名?位域名位域允许用各种格式输出。

main{

struct bs

{

unsigned a:1;

unsigned b:3;

unsigned c:4;

} bit,*pbit;

bit.a=1;

bit.b=7;

bit.c=15;

pri

改错：

#include

int main(void) {

int **p;

int arr[100];

p = &arr;

return 0;

}

解答：

搞错了,是指针类型不同,

int **p; //二级指针

&arr; //得到的是指向第一维为100的数组的指针

#include

int main(void) {

int **p, *q;

int arr[100];

q = arr;

p = &q;

return 0;

}

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

#define MAX 255

int main()

{

unsigned char A[MAX],i;//i被定义为unsigned char

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

A[i]=i;

}

解答：死循环加数组越界访问(C/C++不进行数组越界检查)

MAX=255

数组A的下标范围为:0..MAX-1,这是其一..

其二.当i循环到255时,循环内执行:

A[255]=255;

这句本身没有问题..但是返回for (i=0;i<=MAX;i++)语句时,

由于unsigned char的取值范围在(0..255),i++以后i又为0了..无限循环下去.

struct name1{

char str;

short x;

int num;

}

struct name2{

char str;

int num;

short x;

}

sizeof(struct name1)=8,sizeof(struct name2)=12

在第二个结构中，为保证num按四个字节对齐，char后必须留出3字节的空间;同时为保证整个结构的自然对齐(这里是4字节对齐)，在x后还要补齐2个字节，这样就是12字节。

intel：

A.c 和B.c两个c文件中使用了两个相同名字的static变量,编译的时候会不会有问题?这两个static变量会保存到哪里(栈还是堆或者其他的)?

static的全局变量，表明这个变量仅在本模块中有意义，不会影响其他模块。

他们都放在数据区，但是编译器对他们的命名是不同的。

如果要使变量在其他模块也有意义的话，需要使用extern关键字。

struct s1

{

int i: 8;

int j: 4;

int a: 3;

double b;

};

struct s2

{

int i: 8;

int j: 4;

double b;

int a:3;

};

printf(”sizeof(s1)= %d“, sizeof(s1));

printf(”sizeof(s2)= %d“, sizeof(s2));

result: 16, 24

第一个struct s1

{

int i: 8;

int j: 4;

int a: 3;

double b;

};

理论上是这样的，首先是i在相对0的位置，占8位一个字节，然后，j就在相对一个字节的位置，由于一个位置的字节数是4位的倍数，因此不用对齐，就放在那里了，然后是a，要在3位的倍数关系的位置上，因此要移一位，在15位的位置上放下，目前总共是18位，折算过来是2字节2位的样子，由于double是8 字节的，因此要在相对0要是8个字节的位置上放下，因此从18位开始到8个字节之间的位置被忽略，直接放在8字节的位置了，因此，总共是16字节。

第二个最后会对照是不是结构体内最大数据的倍数，不是的话，会补成是最大数据的倍数

1)读文件file1.txt的内容(例如)：

输出到file2.txt：

(逆序)

2)输出和为一个给定整数的所有组合

例如n=5

5=1+4;5=2+3(相加的数不能重复)

则输出

1，4;2，3。

望高手赐教!!

第一题,注意可增长数组的应用.

#include

int main(void)

{

int MAX = 10;

int *a = (int *)malloc(MAX * sizeof(int));

int *b;

FILE *fp1;

FILE *fp2;

fp1 = fopen(”a.txt“,”r“);

if(fp1 == NULL)

{printf(”error1“);

exit(-1);

}

fp2 = fopen(”b.txt“,”w“);

if(fp2 == NULL)

{printf(”error2“);

exit(-1);

}

int i = 0;

int j = 0;

while(fscanf(fp1,”%d“,&a[i]) != EOF)

{

i++;

j++;

if(i >= MAX)

{

MAX = 2 * MAX;

b = (int*)realloc(a,MAX * sizeof(int));

if(b == NULL)

{

printf(”error3“);

exit(-1);

}

a = b;

}

for(;--j >= 0;)

fprintf(fp2,”%d“,a[j]);

fclose(fp1);

fclose(fp2);

return 0;

}

第二题.

#include

int main(void)

{

unsigned long int i,j,k;

printf(”please input the number“);

scanf(”%d“,&i);

if( i % 2 == 0)

j = i / 2;

else

j = i / 2 + 1;

printf(”The result is “);

for(k = 0; k < j; k++)

printf(”%d = %d + %d“,i,k,i - k);

return 0;

}

#include

void main()

{

unsigned long int a,i=1;

scanf(”%d“,&a);

if(a%2==0)

{

for(i=1;i

printf(”%d“,a,a-i);

}

else

for(i=1;i<=a/2;i++)

printf(” %d, %d“,i,a-i);

}

兄弟,这样的题目若是做不出来实在是有些不应该, 给你一个递规反向输出字符串的例子,可谓是反序的经典例程.

void inverse(char *p)

{

if( *p = = ”\0“ )

return;

inverse( p+1 );

printf( ”%c“, *p );

}

int main(int argc, char *argv[])

{

inverse(”abc\0“);

return 0;

}

借签了楼上的“递规反向输出”

#include

void test(FILE *fread, FILE *fwrite)

{

char buf[1024] = {0};

if (!fgets(buf, sizeof(buf), fread))

return;

test( fread, fwrite );

fputs(buf, fwrite);

}

int main(int argc, char *argv[])

{

FILE *fr = NULL;

FILE *fw = NULL;

fr = fopen(”data“, ”rb“);

fw = fopen(”dataout“, ”wb“);

test(fr, fw);

fclose(fr);

fclose(fw);

return 0;

}

在对齐为4的情况下

struct BBB

{

long num;

char *name;

short int data;

char ha;

short ba[5];

}*p;

p=0x1000000;

p+0x200=____;

(Ulong)p+0x200=____;

(char*)p+0x200=____;

希望各位达人给出答案和原因，谢谢拉

解答：假设在32位CPU上，

sizeof(long) = 4 bytes

sizeof(char *) = 4 bytes

sizeof(short int) = sizeof(short) = 2 bytes

sizeof(char) = 1 bytes

由于是4字节对齐，

sizeof(struct BBB) = sizeof(*p)

= 4 + 4 + 2 + 1 + 1/*补齐*/ + 2*5 + 2/*补齐*/ = 24 bytes (经Dev-C++验证)

p=0x1000000;

p+0x200=____;

= 0x1000000 + 0x200*24

(Ulong)p+0x200=____;

= 0x1000000 + 0x200

(char*)p+0x200=____;

= 0x1000000 + 0x200*4

你可以参考一下指针运算的细节

篇10：c语言基础面试题

c语言基础面试题

1、statac 全局变量、局部变量、函数与普通全局变量、局部变量、函数static 全局变量与普通的全局变量有什么区别?static 局部变量和普通局部变量有什么区别?static 函数与普通函数有什么区别?

答、全局变量(外部变量)的说明之前再冠以 static 就构成了静态的全局变量，全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。

这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

static 函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件static 全局变量与普通的全局变量有什么区别：static 全局变量只初使化一次，防止在其他文件单元中被引用;

static 局部变量和普通局部变量有什么区别：static 局部变量只被初始化一次，下一次依据上一次结果值;

static 函数与普通函数有什么区别：static 函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

2、程序的内存分配

答：一个由 c/C++编译的程序占用的内存分为以下几个部分

1、栈区(stack)—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区(heap)—一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区(静态区)(static)—全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。

4、文字常量区—常量字符串就是放在这里的。程序结束后由系统释放。

5、程序代码区—存放函数体的二进制代码

3、解释堆和栈的区别

答：堆(heap)和栈(stack)的区别

(1)申请方式

stack:由系统自动分配。例如，声明在函数中一个局部变量 int b;系统自动在栈中为 b 开辟空间

heap:需要程序员自己申请，并指明大小，在 c 中 malloc 函数

如 p1=(char*)malloc(10);

在 C++中用 new 运算符

如 p2=(char*)malloc(10);

但是注意 p1、p2 本身是在栈中的。

(2)申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的 delete 语句才能正确的释放本内存空间，

另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

(3)申请大小的限制

栈：在 Windows 下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS 下，栈的大小是 2M(也有的说是 1M，总之是一个编译时就确定的常数)，如果申请的空间超过栈的.剩余空间时，将提示 overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

(4)申请效率的比较：

栈:由系统自动分配，速度较快。但程序员是无法控制的。

堆:是由 new 分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.另外，在 WINDOWS 下，最好的方式是用 Virtual Alloc 分配内存，他不是在堆，也不是在栈,而是直接在进程的地址空间中保留一块内存，虽然用起来最不方便。但是速度快，也最灵活。

(5)堆和栈中的存储内容

栈：在函数调用时，第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址，然后是函数的各个参数，在大多数的 C 编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。

当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

(6)存取效率的比较

char s1[]=”aaaaaaaaaaaaaaa“;

char *s2=”bbbbbbbbbbbbbbbbb“;

aaaaaaaaaaa 是在运行时刻赋值的;