中兴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. 链表反序

#include <iostream>
using namespace std;
//链表反序
struct node
{
    struct node *next;
    int data;
};


struct node* Reverse(struct node *p)
{
    node *p1, *p2;
    if(!p) return 0;
    p1 = p->next;
    if(!p1) return p;
    p2 = p1->next;
    p->next = 0;
    while(true)
    {
        p1->next = p;
        p = p1;
        p1 = p2;
        if(!p2) break;
        p2 = p2->next;
    }
    return p;
}

void output(struct node *p)
{
    while(p)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}


int main()
{
    //添加链表
    node *head, *p;
    head = new node();
    head->data = 0;
    p = head;
    for(int i = 1; i < 5; ++i)
    {
        p->next = new node();
        p = p->next;
        p->data = i;
    }
    p->next = 0;
    output(head);
    head = Reverse(head);
    output(head);
}

2. 双向链表

#include <iostream>
using namespace std;
//删除两个链表中的重复数据
typedef struct node
{
    int data;
    struct node *front, *next;
}Node;


void output(Node *head)
{
    Node *p = head;
    while(p->next != head)
    {
        p = p->next;
        cout << p->data << " ";
    }
    cout << endl;
}

//构造一个双链表
Node* createLink(int* a, int len)
{
    Node *pHeadA = new Node;
    Node *p;
    pHeadA->data = 0xffffffff;
    pHeadA->next = pHeadA;
    pHeadA->front = pHeadA;
    p = pHeadA;
    for(int i = 0; i < len; ++i)
    {
        Node *p1 = new Node;
        p1->data = a[i];
        p->next = p1;
        p1->front = p;
        pHeadA->front = p1;
        p1->next = pHeadA;
        p = p1;
    }
    return pHeadA;
}

//删除指定的结点
Node* removeNode(Node* p)
{
    Node *pPrevious = p->front;
    Node *pNext = p->next;
    pPrevious->next = pNext;
    pNext->front = pPrevious;
    delete p;
    return pPrevious;
}

//找到要删除的结点
bool findRemoveNode(Node* head, int data)
{
    Node *p = head;
    bool flag = false;
    while(p->next != head)
    {
        p = p->next;
        if(p->data == data)
        {
            p = removeNode(p);
            flag = true;
        }
    }
    return flag;
}

//删除重复结点
void DeleteSameNodes(Node* pHeadA, node* pHeadB)
{
    Node *pA = pHeadA;
    Node *pAPre;
    while(pA->next != pHeadA)
    {
        pAPre = pA;
        pA = pA->next;
        int Adata = pA->data;
        int flag = findRemoveNode(pHeadB, Adata);
        if(flag)
        {
            //在B中重复的结点，那么A中的结点也要都删去
            findRemoveNode(pHeadA, Adata);//注意会引起A中pA失效
            pA =  pAPre;//重定位指针
        }
    }
}

int main()
{
    cout << "删除前："<<endl;
    //创建A链表
    int a[6] = {1,2,3,2,4,3};
    Node* pHeadA = createLink(a, 6);
    cout << "A链表中的元素为：";
    output(pHeadA);

    //创建B链表
    int b[4] = {0,2,4,2};
    Node* pHeadB = createLink(b, 4);
    cout << "B链表中的元素为：";
    output(pHeadB);

    //删除两个链表中重复的值，题意不是很清楚，这里理解为若B中与A有相同的元素data，
    //则A与B中所有含data的结点都要删去，而若B中没有相同的data，那么即使A内部有多
    //个data，也不删除。
    cout <<endl<< "删除后："<< endl;
    DeleteSameNodes(pHeadA, pHeadB);
    cout << "A链表中的元素为：";
    output(pHeadA);
    cout << "B链表中的元素为：";
    output(pHeadB);
    return 0;
}