数据结构面试易错点

下列结构，属于线性结构的是（ C ） 

• A  二叉树
• B  有向无环图
• C  循环队列
• D  霍夫曼树

下列关于存储结构和逻辑结构描述正确的是（D ）

• A 存储结构和程序具体实现的语言没有关系

• B 算法的实现需要考虑逻辑结构

• C 逻辑结构就是实际存储的结构

• D 算法的实现依赖于存储结构

对于层次结构，下列描述正确的是（C ）

• A 具有唯一前驱和唯一后继

• B 具有多个前驱

• C 后继可以有多个，前驱只有一个

• D 前驱可以有多个，后继只有一个

下列不属于描述数据逻辑结构的是（  D ）

• A  线性表
• B  树
• C  图
• D  链表

数据结构包含的内容不包括（A ）

• A  线性结构
• B  存储结构
• C  逻辑结构
• D  数据运算

下列关于存储结构和逻辑结构描述正确的是（D   ）

• A  存储结构和程序具体实现的语言没有关系
• B  算法的实现需要考虑逻辑结构
• C  逻辑结构就是实际存储的结构
• D  算法的实现依赖于存储结构

下列不是一个好的算法应该具有的特点的是（ C  ）

• A  算法消耗时间少
• B  算法消耗空间少
• C  算法的时间复杂度高
• D  算法的结构简单

一个算法的时间复杂度为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)

对于冒泡排序来说，其算法时间复杂度为（  B ）

• A  O(n)
• B  O(n^2)
• C  O(1)
• D  O(nlogn)

向一个单链表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

在一个完全二叉树中，编号为i的节点存在左孩子，则左孩子的编号是（A ）设根节点编号为0

• A 2i

• B 2i - 1

• C 2i +１

• D 2i + 2

二叉树的第k层最多有几个节点（D ）

• A 2^k-1

• B 2^k+1

• C 2k+1

• D 2^(k-1)

设指针变量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)

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

• A  62743518
• B  62751843
• C  62734518
• D  62734518

顺序栈和链式栈的主要区别是（B  ）

• A  逻辑结构不同
• B  存储结构不同
• C  数据类型不同
• D  数据存取方式不同

深度为k的完全二叉树中，最少有（ B ）个节点

• A  2^(k-1)-1
• B  2^(k-1)
• C  2^(k-1)+1
• D  2^(k-)

从一个具有N个结点的单链表中查找其值等于x的结点时，在查找成功的情况下，需平均比较( C   )个结点

• A  N
• B  N / 2
• C  (N + 1)/2
• D  (N - 1)/ 2

对于二叉树的遍历算法，下面描述正确的是（A  ）

• 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);

若已知一颗二叉树先序序列为ABCDEFG，中序序列为CBDAEGF，则其后序序列为( A  )

• A  CDBGFEA
• B  CDBFGEA
• C  CDBAGFE
• D  BCDAGFE

用链表表示线性表的优点是( C   )

• A  便于随机存取
• B  花费的存储空间比顺序表少
• C  便于插入和删除
• D  数据元素存储的物理顺序与逻辑顺序相同

一个栈的入栈序列是a,b,c,d,e,则栈的不可能的输出序列是( C   )

• A  edcba
• B  decba
• C  dceab
• D  abcde

通过例子分析结构体对齐

struct student{

    char *name;  //姓名

    int num;  //学号

    int age;  //年龄

char sex;  //性别

    float score;  //成绩

}stu1;

参考：结构体中的成员在内存中是连续存储的，因为要结构对齐，所以这个结构体实际所占空间为20个字节 

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

参考：假设这个指针为p，指向了链表中的A节点，要删除A节点，我们要定义一个指针q，q = p->next;    p->data = q->data;    

p->next = q->next;    free(q);

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

 ABC##D##E#FG#

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

参考：一个栈负责存储数据，另一个栈作为临时缓冲区负责将数据“倒过来”，从而实现队列先进先出的功能 

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

要求：

 1. 写清楚定义的链表节点结构体

 2. 篇幅有限，可以把所有操作写在一个函数中，但必须注释

#include 
#include 
#include 
 
typedef char data_c;
typedef struct node{
    data_c data;
    struct node *next;
}listnode, *linklist;
 
linklist list_create();
int list_tail_insert(linklist H, data_c value);
linklist list_free(linklist H);
int list_show(linklist H);
 
int main(int argc, const char *argv[])
{
    linklist H;
    data_c value = 'z';
    H = list_create();
    if(H == NULL){
        printf("node is create failed\n");
        return -1;
    }
    while((value != ('a' - 1))){
        list_tail_insert(H, value);
        value = value - 1;
    }
 
    list_show(H);
    H = list_free(H);
 
    return 0;
}
 
linklist list_create()
{
    linklist H;
    H = (linklist)malloc(sizeof(listnode));
    if(H == NULL){
        printf("H malloc failed\n");
        return H;
    }
    H->data = 0;
    H->next = NULL;
    return H;
}
int list_tail_insert(linklist H, data_c value)
{  
    linklist p, q = H;
    if(H == NULL){
        printf("H is NULL\n");
        return -1;
    }  
    p = (linklist)malloc(sizeof(listnode));
    p->data = value;
    p->next = NULL;
     
    while(q->next){
        q = q->next;
    }
    q->next = p;
 
    return 0;
}  
linklist list_free(linklist H)
{
    linklist p = H;
    if(H == NULL){
        printf("H is NULL\n");
        return NULL;
    }
 
    while(H){
        p = H;
        H = H->next;
        free(p);
    }
    return NULL;
}
int list_show(linklist H)
{
    linklist p;
    if(H == NULL){
        printf("H is NULL\n");
        return -1;
    }
 
    p = H;
    while(p->next){
        printf("%c ", p->next->data);
        p = p->next;
    }
    putchar(10);
    return 0;
}

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

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

#include 
#include 
 
typedef int data_t;
typedef struct tree{
    data_t data;
    struct tree *lchild, *rchild;
}bitree;
 
bitree *create_bitree(int i, int n)
{
    bitree *r;
    r = (bitree *)malloc(sizeof(bitree));
    r->data = i;
 
    if(2 * i <= i){
        r->lchild = create_bitree(2 * i, n);
    }else{
        r->lchild = NULL;
    }
    if(2 * i + 1 <= n){
        r->rchild = create_bitree(2 * i + 1, n);
    }else{
        r->rchild = NULL;
    }
 
    return r;
}