数据结构错题集期末复习自存（PTA）

数据结构错题集

练习一

1. 错（数据的逻辑结构从逻辑关系上描述数据，与数据的储存无关，是独立于计算机的）

2. 错（顺序存储结构的地址是连续的，可以通过计算地址实现随机存取，而链式存储的地址不一定连续，只能通过结点的指针顺序存取）

3. 顺序表和链表的优缺点：

   顺序表的优点是可以随机存取元素,存储密度高,结构简单;

   缺点是需要一片地址连续的存储空间,不便于插入和删除元素(需要移动大量的元素),表的容量难以确定。

   链表的优点是便于结点的插入和删除(只需要修改指针域,不需要移动结点),表的容量扩充十分方便;

   缺点是不能进行随机访问,只能顺序访问,另外每个结点上增加指针域,导致存储密度较低

4. 顺序表的概念：顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

5. 线性结构概念：特点：数据元素之间存在一对一的线性关系。包括顺序存储结构和链式存储结构。

6. 线性表，堆栈，队列的主要区别是：堆栈和队列都是插入，删除受到约束的线性表。

7. 堆和栈的区别：数据结构中堆是一种特殊的完全二叉树。【算法与数据结构】堆与栈的联系区别（多角度详解）_南城果宝的博客-CSDN博客_堆和栈的区别和联系)

8. 单链表是一种非顺序存储线性表。

9. 线性表在顺序存储时，查找第i各元素的时间同i的值无关，且所有的元素储存单元是连续的，链式存储相反。

10. 出栈排序统计：C(2n,n)/(n+1)；出栈序列统计_韩小妹的博客-CSDN博客_出栈序列统计

练习二

AVL树：平衡因子的绝对值不超过1的二叉搜索树。（中序遍历满足从小到大排序）

    1.对一棵平衡二叉树，所有非叶结点的平衡因子都是0，当且仅当该树是完全二叉树。

错：完全二叉树定义可以有最后一层不满的情况。

附：完美二叉树：所有的分支节点存在左子树和右子树，并且所有的叶节点在同一层。

        完全二叉树：叶节点只能出现在最下层和次下层。

        完满二叉树：所有非叶子结点的度都是2。

        二叉搜索树：二叉搜索树的左子树的一定比根小,右子树一定比根大。

当记录数少，关键字分布基本有序，要求排序稳定时，选择插入排序；

当记录数少，对排序稳定不做要求时，采用选择排序；

将两个有序表合成一个有序表，采用归并排序。

稳定性说明：堆排序、快速排序、希尔排序、直接选择排序是不稳定的排序算法,而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。

 

插入排序：每次将待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的合适位置，直到全部记录插入完成。

选择排序：首先从序列中选出关键字最小或最大的记录送到最前面，再从余下的序列中选取关键字最小或最大的记录送到第二个的位置，直到所有的记录选择完毕。

交换排序：若大小顺序和要求顺序相反，则处理这两个数据。

各种排序方法的选择：

当记录数多，关键字分布随机，对排序稳定不要求时，选择快速排序；

当记录数多，内存空间允许，要求排序稳定时，选择归并排序；

当记录数多，关键字可能出现有序，对排序稳定不要求时，选择堆排序或者归并排序；

1. 若一搜索树（查找树）是一个有n个结点的完全二叉树，则该树的最小值一定在叶结点上. 对

2. 若一搜索树是一个有n个节点的完全二叉树则该树的最大值一定在叶子节点。 错

3. 哈夫曼编码是一种最优的前缀码。对一个给定的字符集及其字符频率，其哈夫曼编码不一定是唯一的，但是每个字符的哈夫曼码的长度一定是唯一的。 错：长度不是唯一的

4. 二叉树中除叶子结点外，任一结点X，其左子树根结点的值小于该结点（X）的值；其右子树根结点的值≥该结点（X）的值，则此二叉树一定是二叉排序树。 错：左子树和右子树。

5. 若把堆看成是一棵完全二叉树，则该树一定是一棵二叉排序树。 错：堆对于左右子树的大小关系没有要求,而二叉排序树有要求。

6. 在二叉排序树中，新结点总是作为树叶来插入的。 对

7. 给定一棵树，可以找到唯一的一棵二叉树与之对应。 对

8. 用链表(llink-rlink)存储包含n个结点的二叉树，结点的2n个指针区域中有n-1个空指针。 错

   解析：n 个节点有 2n 个指针域（因为是树），只有根节点没有被指向，所以，有(n-1)个节点被指向了， 所以，空指针数：2n - （n -1） = n+1 非空指针数：n - 1。

9. 高度为8的完全二叉树至少有( )个叶子结点。 64

10. 

11. 元素移动次数与关键字的初始排列次序无关的是： 基数排序

    元素的比较次数与初始序列无关的是：选择排序，折半插入排序

    算法时间复杂度与初始序列无关的是：选择排序，堆排序，归并排序，基数排序

    算法排序趟数与初始序列无关的是：插入排序，选择排序，基数排序

12. 算法思想：

//快速排序 nlog2 n ~ n^2 不稳定
int partition(int start, int end,int a[])
{
    int temp = a[start];
    while (start < end)
    {
        while (start < end && temp <=a[end])end--;
        a[start] = a[end];
        while (start < end && temp >=a[start])start++;
        a[end] = a[start];
    }
    a[start] = temp;
    return start;
}
void sort(int start, int end, int a[])
{
    if (start < end)
    {
        int temp = partition(start, end, a);
        sort(start, temp - 1, a);
        sort(temp + 1, end,a);
    }
}
//归并排序 nlog2 n 稳定
void merge(int a[], int b[], int start, int temp, int end)//将a[]中的start到temp和temp+1到end合并到b的start到end
{
    int la, lb, lc;
    la = start;
    lb = temp + 1;
    lc = start;
    while (la <= temp && lb <= end)
    {
        if (a[la] <= a[lb])
            b[lc++] = a[la++];
        else b[lc++] = a[lb++];
    }
    while (la <= temp) b[lc++] = a[la++];
    while (lb <= end) b[lc++] = a[lb++];
}
void mergesort(int a[], int b[], int start, int end)//将a有序排列到b中
{
    int temp;
    int c[1000];
    if (start == end) b[start] = a[start];
    else {
        temp = (start + end) / 2;
        mergesort(a, c, start, temp);
        mergesort(a, c, temp + 1, end);
        merge(c, b, start, temp, end);
    }
}
//堆排序 nlog2 n 不稳定
void creatheap(int a[], int start, int end)
{
    int i, j;
    int flag = 0;
    i = start;
    j = i * 2;
    int temp = a[start];
    while (j <= end && !flag)
    {
        if (ja[j + 1]) j++;
        if (temp > a[j])
        {
            a[i] = a[j];
            i = j;
            a[i] = temp;
            j = i * 2;
        }
        else flag = 1;
    }
}
void heapsort(int a[], int n)
{
    int i;
    for (i = n / 2; i >= 1; i--)
    {
        creatheap(a, i, n);
    }
    for (int i = n; i >= 1; i--)
    {
        printf("%d ", a[1]);
        a[1] = a[i];
        creatheap(a, 1, i);
    }
} 
//折半插入法 n^2 稳定
void Binarysort(int a[], int start, int end)
{
    int i, j;
    int low, high,temp;
    int sign;
    for (i = start+1; i <= end; i++)
    {
        low = 0;
        sign = a[i];
        high = i - 1;
        while (low <= high)
        {
            temp = (low + high) / 2;
            if (a[temp] > a[i]) high = temp - 1;
            else low = temp + 1;
        }
        for (j = i - 1; j >= high + 1; j--) a[j + 1] = a[j];
        a[high+1] = sign;
    }
}
//直接选择排序 n^2 不稳定
void selectsort(int a[], int start, int end)
{
    int i, j, min;
    int temp;
    for (i = 0; i <= end; i++)
    {
        min = i;
        for (j = i + 1; j <= end; j++)
        {
            if (a[j] < a[min]) min = j;
        }
        if (min != i) {
            temp = a[i];
            a[i] = a[min];
            a[min] = temp;
        }
    }
}

练习三

1. 将M个元素存入用长度为S的数组表示的散列表，则该表的装填因子为M/S。 T

2. 在散列表中，所谓同义词就是具有相同散列地址的两个元素。 T

3. 若用平方探测法解决冲突，则插入新元素时，若散列表容量为质数，插入就一定可以成功。F

4. hash表的平均查找长度与处理冲突的方法无关。 F

5. 任何无向图都存在生成树。F (生成树是连通图的包含图中的所有顶点的极小连通子图。图的生成树不惟一)

6. 在一个有权无向图中，若b到a的最短路径距离是12，且c到b之间存在一条权为2的边，则c到a的最短路径距离一定不小于10。T

7. Kruskal 算法是维护一个森林，每一步把两棵树合并成一棵. T

8. Prim 算法是通过每步添加一条边及其相连的顶点到一棵树，从而逐步生成最小生成树。 T

9. 如果 e 是有权无向图 G 唯一的一条最短边，那么边 e 一定会在该图的最小生成树上。 T

10. 最小生成树的Kruskal算法是一个贪心法。 T

11. AOE图的关键路径就是最长的路径 . T

12. AOE图的权值最大的边（活动）一定是关键活动。 F

13. 在AOE-网工程中，减少任一关键活动上的权值后，整个工期也就会相应的减小。F（

    在AOE图中，关键路径上活动的时间延长多少，整个工程的时间也就随之延长多少。缩短所有关键路径上共有的任意一个关键活动的持续时间可以缩短关键路径的长度。若某活动并不是该图中所有关键路径共有的，则它持续时间的缩短并不能缩短整个关键活动的持续时间；若活动a与活动b不是所有关键路径共有的，但它们覆盖了所有关键路径（即每一个关键路径必含活动a或活动b），则它们持续时间同时缩短就可以缩短整个关键活动的持续时间。）

14. 在AOE网络中，从源点到汇点具有最大长度的路径称为关键路径。完成AOE所表示的整个工程所需要的时间取决于关键路径的路径长度. T（关键活动：关键路径上的活动
    【现实意义】若想要最短时间完成这项工程，这些活动的上游完成后，不能休息，要立刻开始！）

15.​​​在有n个顶点的有向图中,每个顶点度最大可达()。 解:2(n-1）

16. 平均查找时间计算：

• 找的是元素的地址

• 根据地址来找元素。常见的平均查找长度总结_real_metrix的博客-CSDN博客_平均查找长度

• 如果从有向图 G 的每一点均能通过深度优先搜索遍历到所有其它顶点，那么该图一定不存在拓扑序列。(如果从有向图 G 的每一点均能通过深度优先搜索遍历到所有其它顶点，则该图是一个有环图；而拓扑排序的前提是有向无环图)

练习四

1. 在初始数据表已经有序时，快速排序算法的时间复杂度为O(nlogn ) F（快速排序和初始数据排列顺序没有关系）

2. 要从50个键值中找出最大的3个值，选择排序比堆排序快。 T

3. 对N个记录进行堆排序，需要的额外空间为O(N)。 F(：堆排序只要额外O(1)的空间复杂度。)

1. 有一大根堆，堆中任意结点的关键字均大于它的左右孩子关键字，则其具有最小值的结点一定是一个叶子结点并可能在堆的最后两层中。 T

2. 排序算法中的比较次数与初始元素序列的排列无关。 F

3. 对N个不同的数据采用冒泡排序进行从大到小的排序，当元素基本有序时交换元素次数肯定最多。 F

4. 采用递归方式对顺序表进行快速排序，每次划分后，先处理较短的分区可以减少递归次数。 F

---