过关检测-Lv3_ 数据结构

1. 下列结构，属于线性结构的是（C ）
   A 二叉树
   B 有向无环图
   C 循环队列
   D 霍夫曼树

2. 对于层次结构，下列描述正确的是（ C）
   A 具有唯一前驱和唯一后继
   B 具有多个前驱
   C 后继可以有多个，前驱只有一个
   D 前驱可以有多个，后继只有一个

3. 下列不属于描述数据逻辑结构的是（ D ）
   A 线性表
   B 树
   C 图
   D 链表

4. 数据结构包含的内容不包括（A ）
   A 线性结构
   B 存储结构
   C 逻辑结构
   D 数据运算

5. 下列关于存储结构和逻辑结构描述正确的是（ D ）
   A 存储结构和程序具体实现的语言没有关系
   B 算法的实现需要考虑逻辑结构
   C 逻辑结构就是实际存储的结构
   D 算法的实现依赖于存储结构

6. 下列不是一个好的算法应该具有的特点的是（ C ）
   A 算法消耗时间少
   B 算法消耗空间少
   C 算法的时间复杂度高
   D 算法的结构简单

7. 一个算法的时间复杂度为T(n) = 2n3+3n2+4n+5n4+2,则该T(n)应记为（ D ）
   A O(n)
   B O(n^2)
   C O(n^3)
   D O(n^4)

8. 对于冒泡排序来说，其算法时间复杂度为（B ）
   A O(n)
   B O(n^2)
   C O(1)
   D O(nlogn)

9. 向一个单链表linklist中的节点t后面插入一个节点p，下列操作正确的是（A ）
   A p->next = t->next;t->next = p
   B t->next = p->next;t->next = p
   C t->next = p;p->next = t->next
   D t->next = p;t->next = p->next

10. 在一个完全二叉树中，编号为i的节点存在左孩子，则左孩子的编号是（CCCCCCCCCCCCCCCCCCC ）设根节点编号为0
    A 2i
    B 2i - 1
    C 2i +１
    D 2i + 2

11. 二叉树的第k层最多有几个节点（ D ）
    A 2^k-1
    B 2^k+1
    C 2k+1
    D 2^(k-1)

12. 设指针变量p指向单链表中节点A，若删除单链表中的节点A，则需要修改指针的操作顺序为（A ）
    A q= p->next;p->data = q->data;p->next = q ->next;free(q)
    B q = p->next;q->data = p->data;p->next = q->next;free(q)
    C q = p->next;p->next = q->next;free(q)
    D q = p->next;p->data = q->data;free(q)

13. 约瑟夫环问题中，有n个人，从第k个人数，数到第m个人出列，若n = 8,k= 3 m = 4,则正确的出队序列为：（A ）
    A 62743518
    B 62751843
    C 62734518
    D 62734518

14. 顺序栈和链式栈的主要区别是（ B ）
    A 逻辑结构不同
    B 存储结构不同
    C 数据类型不同
    D 数据存取方式不同

15. 深度为k的完全二叉树中，最少有（B ）个节点
    A 2^(k-1)-1
    B 2^(k-1)
    C 2^(k-1)+1
    D 2^(k-)

16. 从一个具有N个结点的单链表中查找其值等于x的结点时，在查找成功的情况下，需平均比较( C )个结点
    A N
    B N / 2
    C (N + 1)/2
    D (N - 1)/ 2

17. 对于二叉树的遍历算法，下面描述正确的是（ D ）
    A void pre_order(bitree* root){ printf("%d “,root->data); pre_order(root->lchild); pre_order(root->rchild);
    B void in_order(bitree* root){ in_order(root->lchild); in_order(root->rchild); printf(”%d “,root->data);
    C void post_order(bitree* root){ post_order(root->lchild); printf(”%d “,root->data); post_order(root->rchild);
    D void in_order(bitree* root){ printf(”%d ",root->data); in_order(root->lchild); in_order(root->rchild);

18. 若已知一颗二叉树先序序列为ABCDEFG，中序序列为CBDAEGF，则其后序序列为(A )
    A CDBGFEA
    B CDBFGEA
    C CDBAGFE
    D BCDAGFE

19. 用链表表示线性表的优点是( C )
    A 便于随机存取
    B 花费的存储空间比顺序表少
    C 便于插入和删除
    D 数据元素存储的物理顺序与逻辑顺序相同

20. 一个栈的入栈序列是a,b,c,d,e,则栈的不可能的输出序列是( )
    A edcba
    B decba
    C dceab
    D abcde

21. 通过例子分析结构体对齐

struct student{
char *name; //姓名
int num; //学号
int age; //年龄
char sex; //性别
float score; //成绩

}stu1;

理论上讲结构体的各个成员在内存中是连续存储的，结构体变量 stu1共占用 4+4+4+1+4 = 17 个字节。
但在编译器的具体实现中，各个成员之间可能会存在缝隙，对于 stu1，成员变量 sex 和 score 之间就存在 3 个字节的空白填充。
这样算来，stu1 其实占用了 17 + 3 = 20 个字节。

22. 一个单向链表，不知道头节点,一个指针指向其中的一个节点，问如何删除这个指针指向的节点？

    将这个指针指向的next节点值copy到本节点，将next指向next->next,并随后删除原next指向的节点
    

23. 若已知一颗二叉树先序序列为ABCDEFG，中序序列为CBDAEGF，画出二叉树

    后序（CDBGFEA）

24. 用两个栈实现一个队列的功能？简述算法和思路

        答案参考：
    两个栈s1,s2始终维护s1作为存储空间，以s2作为临时缓冲区。
    入队时，将元素压入s1。
    出队时，将s1的元素逐个“倒入”（弹出并压入）s2，将s2的顶元素弹出作为出队元素，之后再将s2剩下的元素逐个“倒回”s1
    

25. 建立单向链表，把’a’–'z’26个字母插入到链表中，倒序输出。

       答案参考：
    typedef struct node
    {
        char data;
        struct node *next;
    }linknode;
     
    void func(){
        //建立空链表
        linknode* list = (linknode*)malloc(sizeof(linknode));
        list->next = NULL;
        //将字母a~z倒叙插入链表中，采用头插法
        char ch = 'a';
        while(ch <= 'z'){
            创建一个新节点
            linknode* new = (linknode*)malloc(sizeof(linknode));
            new->data = ch;
            //将新节点插入表头
            new->next = list->next;
            list->next = new;
            //将ch增加一，指向下一个字符
            ch++;
        }
        //输出字符
        linknode* p = list;
        for(;p->next != NULL;p = p->next){
            printf("%c", p->data);
        }
    }
    

26. 写程序，创建一个具有十个节点的完全二叉树

要求：先定义二叉树的节点，该程序返回创建的二叉树的根节点地址

   答案参考：
typedef int datatype;
 
typedef struct _tree{
    datatype data;
    struct _tree *lchild,*rchild;
}bitree;
 
bitree *create_bitree(int i,int n){
     bitree *root;
     root = (bitree*)malloc(sizeof(bitree));
     root->data = i;
 
     if(2 * i <= n){
         root->lchild = create_bitree(2 * i,n);
     }else{
         root->lchild = NULL;
     }
     if(2 * i + 1 <= n){
         root->rchild = create_bitree(2 * i + 1,n);
     }else{
         root->rchild = NULL;
     }
     return root;
}