数据结构面试易错点

下列结构,属于线性结构的是( 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 +1

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

你可能感兴趣的:(数据结构)