C语言与数据结构相关习题整理

选择题

1、一个栈的入栈序列是 a,b,c,d,e,则栈的不可能的输出序列是(  ) 
[A] edcba   [B] decba   [C] dceab   [D] abcde
答案：C

2、以下为 linux 下的 32 位 C 程序，请计算 sizeof 的值
char str[10] = “Hello” ; char *p = str ;
请计算：sizeof ( str ) =  10
void Func ( char str[100]){……}
请计算：sizeof( str ) =  4
void *p = malloc( 100 );
请计算：sizeof ( p ) =  100

3、int main()
{ int a[3] = {1, 2};
int *p, *q;
p = a; q = &a[2];
printf("%d", a[q-p]);
return 0;
}
上述程序段输出结果为：0

4、有如下 C 语言程序：
#include<stdio.h>
int main()
{
    int a,b;
    for(a=1,b=1;a<=100;a++)
    {
    	if(b>=10)
           break;
        if(b%3==1)
        {
            b+=3;
            continue;
        }
    }
    printf("%d\n",a);
}
则程序运行后的输出结果是___4___

5、设有 int 型变量占用 4 个字节，定义数组 int a[12] = {12, 14, 21}，则数组 a 在内存中占用的
字节数为（ D ）
A. 3 B. 12 C. 18 D. 48

6、以下程序的输出结果为（ B ）
#include <stdio.h>
int main (int argc, char **argv)
{
 int a[5] = {1, 2, 3, 4, 5};
 int *ptr=(int *)(&a+1);
 printf("%d, %d\n",*(a + 1),*(ptr - 2));
 return 0;
}
A. 1, 5 	B. 2, 4 	C. 2, 1 	D. 4, 5

7、为判断字符变量 c 的值不是数字也不是字母时，应采用下述表达式 D
A) c<=48 || c>=57 && c<=65 || c>=90 && c<=97 || c>=122 
B) !(c<=48 || c>=57 && c<=65 || c>=90 && c<=97 || c>=122)
C) c>=48 && c<=57 || c>=65 && c<=90 || c>=97 && c<=122
D) !(c>=48 && c<=57 || c>=65 && c<=90 || c>=97 && c<=122)

8、在无符号 16 位的环境中计算表达式 0xF8 << 3 得到的结果通过不同的进制表示
  
0000 0000 1111 1000 << 3 → 0000 0111 1100 0000 
16:0x7C0
8 进制: 03700 // 000 000 011 111 00 0 000 
10 进制:1984
2 进制: 0000 0111 1100 0000 //0B 0111 1100 0000

9、假设所有变量均为整型,则表达式(a=2,b=5,b++,a+b)的值是: B
A.	7	B.	8	C.	6	D.	2 
逗号表达式，

10、若指针p已正确定义，要使p指向两个连续的整型动态存储单元，不正确的语句是（ A ）。
[A] p=2*(int *)malloc(sizeof(int)); 
[B] p=(int *)malloc(2*sizeof(int));
[C] p=(int *)malloc(2*2); 
[D] p=(int*)calloc(2, sizeof(int));

11、以下说明和定义
int fun(int *c){   };
main()
{
	int (*a)(int*)=fun,*b(),w[10],c;┆
}
在必要的赋值之后，对fun函数的正确调用语句是 （B）
[A] a=a(w);         [B] (*a)(&c);       [C] b=*b(w);       [D] fun (b);

12、有如下程序
#include <stdio.h>
void convert(char ch)
{
	if(ch < 'X') convert(ch+ 1);
	printf("%c", ch);
}
main()
{
	convert('W');
	printf("\n");
}
程序运行后的输出结果是: （D）   //递归
A、YZ
B、VW
C、XY
D、XW

13、以下选项中正确的语句组是 (B)
A、char *s; s={"BOOK!"};    //{}只能用在数组初始化时
В、char *s; s="BOOK!"; 
С、char s[10]; s="BOOK!";   //char s[10] = {"BOOK!"};  char s[10] = "BOOK!";
D、char s[ ]; s="BOOK!"   //char s[ ] = "BOOK!";

14、#include <stdio.h>
main()
{
int a=1,b=2,c=3,x;
x=(a^b)&c;
printf("%d\n",x);
}
程序的运行结果是 （A）
A、 3 
В、 1 
С、 2 
D、 0
/*
<<左移,相当于*2
>>右移,相当于除以2
| 按位或:相同位上的两个数有一者为1就为1
& 按位与:相同位上的两个数必须都为1才为1
^ 按位异或: 相同位置上的两个数,相同为0,不同为1
~ 按位取反:  1变0, 0变1
    
(01 ^ 10 --> 11) & 11 --> 11 
*/

15 若有定义: double x; , 则表达式:x=0,x+ 10,x++的值是 (C)
А、11.0 
B、10.0 
C、0.0
D、1.0
//x++是先进行运算再进行加1

16、有以下程序
main() { char a1='M', a2='m'; printf("%c\n", (a1, a2) ); } 
以下叙述中正确的是 （ B ）
[A] 程序输出大写字母 M 
[B] 程序输出小写字母 m 
[C] 格式说明符不足，编译出错 
[D] 程序运行时产生出错信息 
//带括号的逗号表达式，最后输出靠右面的

17、#include <stdio.h>
main()
{
int x=1, y=0, a=0, b=0;
switch(x)
{ 
    case 1:
        switch(y)
        {case 0: a+ +; break; 
        case 1: b+ +; break;
        }
	case 2: a++; b++; break; 
	case 3: a++;b++;
}
printf(" a=%d, b=%d\n", a, b);
程序的运行结果是 （B）
A、a=2, b=2 
В、a=2, b=1 
C、a=1, b=1 
D、a=1, b=0

18、有以下程序
#include <stdio.h>
main( )
{
    char с;
    for (; ( c=getchar())!= '#';  )
    {
        if(c>='a' &&c<='z')  c= c-'a'+ 'A'; 
        putchar(+ +c);
    }
}
执行时输入: aBcDefG## <回车> ,则输出结果是（C）
A、AbCdEFg 
В、ABCDEFG 
С、BCDEFGH 
D、bcdefgh
//

填空题

1.static全局变量与普通的全局变量有什么区别？
 static全局变量：(只能在定义它的文件内有效)
    在函数体外面定义，用static关键字修饰，当前文件内可以使用，整个程序结束后释放
    静态局部变量未初始化结果为0，只能初始化一次。
 普通的全局变量：(在整个工程文件内有效)
    在函数体外面定义，当前文件或其它文件中都可以使用，在整个程序结束后释放
    普通全局变量未初始化结果为0，可以访问

2.#define 和typedef的区别
    
    #define：宏定义，调用时宏体替换宏名。
	typedef：用于给已定义好的类型取别名。

作用的时间不同：
    typedef是编译期的行为，因此typedef有类型检查的功能。
    #define是预编译期的行为，发生在预处理阶段，也就是编译之前，它只进行简单文本替换，而不进行任何检查。
作用域不同：
    typedef有自己的作用域。
    没有作用域的限制，只要是之前预定义过的宏，在以后的程序中都可以使用。
作用于指针时的不同：
    typedef int * Point1;
    #define Point2 int *

    int x = 10;
    const Point1 p1 = &x;  //p1不可修改，但是可以修改p1指向的对象
    const Point2 p2 = &x;  //p2可以修改，但是不能修改p2指向的对象

3.const char *p 和char *const p作用都是什么
const char *p：常量指针，p指针的指向可以改变，但是值不可以改变，防止p所指向的值被更改。
char *const p：指针常量，防止p指针的指向被改变，但是值可以更改。

4.C 语言中 static 修饰的全局变量与普通的全局变量有什么区别？static 修饰的局部变量与普通局部变量有什么区别？  

5.全局变量可不可以定义在可被多个.C 文件包含的头文件中？为什么？

char *mystrcpy(chsr *dest, const char *src)
{
char *save = dest;
while(*dest++ = *src++);
return save;
}
//这段程序是正确的

编程题

1、从键盘输入一个字符串，然后按照下面要求输出一个新字符串。新串是在原串中，每三个字符之间插 入一个空格，如原串为 abcdefg，则新串为 abc def g，要求在函数 insert 中完成新串的产生，并在函数 中完成所有相应的输入和输出。

#include <stdio.h>
#include <stdlib.h>
#define MAX 1024
void insert(char *num)
{
    int i, j=0 , k,n;
    for(i=0 ; i < MAX ; i++)
    {
        int top = 0;
        while(num[top] != '\0')
        {
            top++;
        }
        if( (i +1)% 4 == 0 )
        {
            k = i;
            while( k <= top )
            {
                num[top+1] =num[top];
                top--;
            }
            num[i] = ' ';
        }
    }
    puts(num);
}

int main()
{
    char arr[MAX];
    printf("Input : ");
    scanf("%s",arr);
    insert(arr);
}

2、将一个新的字符串插入到一个新的字符串的新位置

int fun(char *str,char *src,int n)//形参str为要插入的字符串，src为原字符串，n为插入的位置
{
	int src_len=0,str_len=0;
	char p[100];       //临时存储
    int i;int max;int j=0;
    
	src_len=strlen(src);  //获取字符的长度 1234567
	str_len=strlen(str);  // abcd
    max = src_len>str_len? src_len:str_len;
    
	for(i=n-1;i<src_len;i++)
    {
        p[j++]=src[i];        //缓存剩余字符
    }
    
    p[j]='\0';
    i=n-1;
    
    while(*str!='\0')
    {
        src[i++]=*str++;      //要衔接的值
    }
 
   strcat(src,p);
    
if(strlen(src)!=(src_len+str_len))return 0;
    else return 1;
}