中兴2011笔试题+答案解析

参考答案（大部分答案和都和卷子上给的相同，欢迎讨论）转载请注明来源http://www.cnblogs.com/jerry19880126/

一、单选题

  1. B。p2是int型，只有p1是int*型。
  2. D。区分0和\0。
  3. C。
  4. B。除号与取余的优先级是一样的，所以顺序是从左向右。快速与（逻辑与）只要不是0的都认为是true(1)，是0则认为是false(0)。
  5. 重复。
  6. 重复。
  7. A。字符串常量不可更改。
  8. 重复。
  9. C。可以用排除法。
  10. D。
  11. C or D。没查到，C6000是指DSP吗？如果是32位PC机上，D是错的，因为long还是4字节。但本科做过单片机知道，int是2字节的，所以C是错的。这里貌似是硬件环境，所以选C还是保稳些。
  12. C。只要有一个被显式初始化了，数组中其他元素也会被初始为0。
  13. B。百度一下就知道了。
  14. B。注意while里面的==误写成=了。
  15. B。
  16. B。我觉得是D，百度上没有找到确切的。
  17. A。应该是A，我百度到了。
  18. C。
  19. A。
  20. B。语句覆盖是最弱的，其次是条件覆盖，再次是条件及判定覆盖，最强的是条件组合覆盖。

 

二、多选题

  1. ABD。
  2. ABCD。形参、实参不一致时，会有默认的转换，若不能转换，则编译器报错。
  3. ACD。
  4. ACD。A只有是字符串数组时，才可以整体输出。B编译器没那么聪明，不知道是下标越界，报的只是读冲突错。C可以的。D是对的，数组名为地址常量。
  5. ABD。D是左移运算符，也是位操作。
  6. BCD。C和D都可以访问。
  7. 后面题目是软件测试、linux的，请自行百度确认答案。第16题好像有问题，信号量是进程互斥用的，信号才是用来通信的。

 

三、判断题

  1. 错。
  2. 对。
  3. 对。
  4. 对。
  5. 重复。
  6. 重复。
  7. 对。
  8. 错。
  9. 错。不是没有结果，而是垃圾值。
  10. 对。

 

四、问答题

  1. static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用；static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝，且static函数只能使用static变量。
  2. (1)和(2)是一样的，为指向常量的指针，(3)是指针常量。
  3. ZTE 垃圾值 DB。字符串常量存储于字符串常量区，在整个程序运行完毕后才释放。
  4. 程序代码在代码段，常量分为字符串常量和其他常量，字符串常量存储于字符串常量区，其他常量存储于代码段，局部变量存储于栈上，全局变量（包括静态变量）存储于全局数据区。

 

五、如下。

1. 链表反序

View Code 
 1 #include <iostream>
 2 using namespace std;
 3 //链表反序
 4 struct node
 5 {
 6     struct node *next;
 7     int data;
 8 };
 9 
10 
11 struct node* Reverse(struct node *p)
12 {
13     node *p1, *p2;
14     if(!p) return 0;
15     p1 = p->next;
16     if(!p1) return p;
17     p2 = p1->next;
18     p->next = 0;
19     while(true)
20     {
21         p1->next = p;
22         p = p1;
23         p1 = p2;
24         if(!p2) break;
25         p2 = p2->next;
26     }
27     return p;
28 }
29 
30 void output(struct node *p)
31 {
32     while(p)
33     {
34         cout << p->data << " ";
35         p = p->next;
36     }
37     cout << endl;
38 }
39 
40 
41 int main()
42 {
43     //添加链表
44     node *head, *p;
45     head = new node();
46     head->data = 0;
47     p = head;
48     for(int i = 1; i < 5; ++i)
49     {
50         p->next = new node();
51         p = p->next;
52         p->data = i;
53     }
54     p->next = 0;
55     output(head);
56     head = Reverse(head);
57     output(head);
58 }

 

2. 双向链表

View Code 
  1 #include <iostream>
  2 using namespace std;
  3 //删除两个链表中的重复数据
  4 typedef struct node
  5 {
  6     int data;
  7     struct node *front, *next;
  8 }Node;
  9 
 10 
 11 void output(Node *head)
 12 {
 13     Node *p = head;
 14     while(p->next != head)
 15     {
 16         p = p->next;
 17         cout << p->data << " ";
 18     }
 19     cout << endl;
 20 }
 21 
 22 //构造一个双链表
 23 Node* createLink(int* a, int len)
 24 {
 25     Node *pHeadA = new Node;
 26     Node *p;
 27     pHeadA->data = 0xffffffff;
 28     pHeadA->next = pHeadA;
 29     pHeadA->front = pHeadA;
 30     p = pHeadA;
 31     for(int i = 0; i < len; ++i)
 32     {
 33         Node *p1 = new Node;
 34         p1->data = a[i];
 35         p->next = p1;
 36         p1->front = p;
 37         pHeadA->front = p1;
 38         p1->next = pHeadA;
 39         p = p1;
 40     }
 41     return pHeadA;
 42 }
 43 
 44 //删除指定的结点
 45 Node* removeNode(Node* p)
 46 {
 47     Node *pPrevious = p->front;
 48     Node *pNext = p->next;
 49     pPrevious->next = pNext;
 50     pNext->front = pPrevious;
 51     delete p;
 52     return pPrevious;
 53 }
 54 
 55 //找到要删除的结点
 56 bool findRemoveNode(Node* head, int data)
 57 {
 58     Node *p = head;
 59     bool flag = false;
 60     while(p->next != head)
 61     {
 62         p = p->next;
 63         if(p->data == data)
 64         {
 65             p = removeNode(p);
 66             flag = true;
 67         }
 68     }
 69     return flag;
 70 }
 71 
 72 //删除重复结点
 73 void DeleteSameNodes(Node* pHeadA, node* pHeadB)
 74 {
 75     Node *pA = pHeadA;
 76     Node *pAPre;
 77     while(pA->next != pHeadA)
 78     {
 79         pAPre = pA;
 80         pA = pA->next;
 81         int Adata = pA->data;
 82         int flag = findRemoveNode(pHeadB, Adata);
 83         if(flag)
 84         {
 85             //在B中重复的结点，那么A中的结点也要都删去
 86             findRemoveNode(pHeadA, Adata);//注意会引起A中pA失效
 87             pA =  pAPre;//重定位指针
 88         }
 89     }
 90 }
 91 
 92 int main()
 93 {
 94     cout << "删除前："<<endl;
 95     //创建A链表
 96     int a[6] = {1,2,3,2,4,3};
 97     Node* pHeadA = createLink(a, 6);
 98     cout << "A链表中的元素为：";
 99     output(pHeadA);
100 
101     //创建B链表
102     int b[4] = {0,2,4,2};
103     Node* pHeadB = createLink(b, 4);
104     cout << "B链表中的元素为：";
105     output(pHeadB);
106 
107     //删除两个链表中重复的值，题意不是很清楚，这里理解为若B中与A有相同的元素data，
108     //则A与B中所有含data的结点都要删去，而若B中没有相同的data，那么即使A内部有多
109     //个data，也不删除。
110     cout <<endl<< "删除后："<< endl;
111     DeleteSameNodes(pHeadA, pHeadB);
112     cout << "A链表中的元素为：";
113     output(pHeadA);
114     cout << "B链表中的元素为：";
115     output(pHeadB);
116     return 0;
117 }
posted @ 2012-08-05 17:02  Jerry19880126  阅读(5466)  评论(3)  编辑  收藏  举报