中興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;
}