PTA习题解析:是否完全二叉搜索树、二叉搜索树的最近公共祖先

二叉搜索树

这 2 道题目都是使用二叉搜索树实现,并且都要用到插入结点和查找结点的基操。更多基础内容可以查看博客——树表查找

结构体定义

typedef struct TNode
{
    int data;
    struct TNode* left, * right;
} TNode, * BinTree;

插入操作

二叉搜索树的插入本质上是查找操作,时间复杂度在 O(㏒2n) ~ O(n) 之间,这要根据树的形态而定。

void Insert(BinTree& BST, int num)
{
    if (BST == NULL)      //找到插入位置,插入结点
    {
        BST = new TNode;
        BST->data = num;
        BST->left = NULL;
        BST->right = NULL;
    }
    else
    {
        if (num < BST->data)
        {
            Insert(BST->left, num);
        }
        else if (num > BST->data)      //注意不要漏条件
        {
            Insert(BST->right, num);
        }
    }
}

查找操作

bool Find(BinTree BST, int num)
{
    bool flag = true;

    while (BST != NULL && BST->data != num)      //查找直到成功或失败
    {
        if (num < BST->data)
        {
            BST = BST->left;
        }
        else
        {
            BST = BST->right;
        }
    }
    if (BST == NULL)
    {
        flag = false;
    }
    return flag;
}

是否完全二叉搜索树

题目说明

测试样例 1

输入样例

9
38 45 42 24 58 30 67 12 51

输出样例

38 45 24 58 42 30 12 67 51
YES

测试样例 2

输入样例

8
38 24 12 45 58 67 42 51

输出样例

38 45 24 58 42 12 67 51
NO

题目分析

这道题目可以被分为 2 部分,分别是建立二叉搜索树和判断是否是完全二叉树。首先是建立二叉搜索树,这个操作并不难,只需要使用上文给出的建树函数,循环调用插入函数就行。值得注意的是这道题左子树是较大的关键字,右子树是较小的关键字。
接下来就是判断是否是完全二叉树,首先我们先回忆一下什么是完全二叉树。我使用通俗的话来说,所谓完全二叉树就是生成结点的顺序是严格按照从上到下,从左往右的顺序来构建的二叉树。例如对于题设测试样例 1 所建立的二叉搜索树,我把它展开为拓展二叉树的形式:

若按照“从上到下,从左到右”的顺序去读这个二叉树,会发现空结点只会集中出现在末尾部分。下面再看测试样例 2:

从定义上讲,这不是个完全二叉树,若展开成拓展二叉树的形式,按照“从上到下,从左到右”的顺序去读这个二叉树,会发现有个空结点穿插在了结点之间。
也就是说要判断一个二叉树是否是完全二叉树,可以先展开为拓展二叉树,然后按照“从上到下,从左到右”的顺序遍历这个二叉树,若在所有实际存在的结点遍历完毕之前遇到了空结点,就说明这不是完全二叉树。如何实现“从上到下,从左到右”的顺序遍历?这就是所谓的层序遍历法,需要通过一个队列结构来辅助实现。对于二叉树的相关概念和操作,可以前往博客——二叉树结构详解进行回顾。

总体的思路已经很明确了,接下来就是如何体现中间遇到了空结点?在层序遍历中我们可以直接忽略空结点,不让空结点入队列,但是这里必须用拓展二叉树的思想让空结点入队列,这样我们才能确定是否有空结点的出现。但是如果是这样的话,可以在空结点入队列时判断不是完全二叉树吗?也不行,因为这么操作在最后会有一系列空结点入队列。
再观察一下完全二叉树的特点,我们就会明白了,若二叉树是完全二叉树,那么遇到空结点之前入队列的结点数就会和二叉搜索树中的结点数相等。此时我们可以另外定义一个变量来统计结点数,当遇到空结点入队列时就停止统计,在层序遍历结束后返回这个变量。若返回的结点数和实际结点数相同,说明是完全二叉树,否则就不是,这样就能同时实现层序遍历和完全二叉树的判定了。

主函数 main()

int main()
{
    BinTree T = NULL;
    int fre;      //查找次数
    int num;
    int count;      //遇到 NULL 前遍历的结点数

    cin >> fre;
    for (int i = 0; i < fre; i++)      //建树
    {
        cin >> num;
        Insert(T, num);
    }
    //PreOrderTraverse(T);      //前序遍历检查建树是否正确
    count = levelOrder(T);
    if (count == fre)      //若返回的结点数和实际结点数相同,说明是完全二叉树
    {
        cout << "\nYES";
    }
    else      //否则不是
    {
        cout << "\nNO";
    }
    return 0;
}

层序遍历函数 levelOrder(BinTree t)

伪代码

由于需要把所有结点都过一遍,因此时间复杂度 O(n)。

代码实现

int levelOrder(BinTree t)   //层序遍历并判断完全二叉树
{
    BinTree ptr;
    queue<BinTree> que_level;    //层序结点队列
    int flag = 0;      //是否有 NULL 入队列的 flag
    int count = 0;      //统计遇到 NULL 之前的结点数

    if (t == NULL)    //空树处理
    {
        cout << "NULL";
    }
    que_level.push(t);    //根结点入队列
    while (!que_level.empty())    //直至空队列,结束循环
    {
        if (que_level.front() == NULL)      //队列读取到空结点
        {
            flag = 1;      //修改 flag 表示接下来不再统计结点数
        }
        else       //队列头结点非空
        {
            if (count == 0)
            {
                cout << que_level.front()->data;
            }
            else
            {
                cout << " " << que_level.front()->data;
            }
            if (flag == 0)
            {
                count++;      //统计结点数
            }
            que_level.push(que_level.front()->left);    //左结点入队列
            que_level.push(que_level.front()->right);    //右结点入队列
        }
        que_level.pop();    //队列头出队列
    }
    return count;
}

调试遇到的问题

这道题虽然是一次过了,但是调试时遇到的问题很多。
Q1:层序遍历操作得出的结点序列,与测试样例差别很大,顺序混乱。
A1:按照层次分开,发现每一层的结点都是逆序的,重新读题发现题目要求左子树是较大的关键字,右子树是较小的关键字。因此通过修改结点插入函数的判断条件,就能得到正确的序列。
Q2:判定完全二叉树时,发现无论什么情况判断为是。
A2:因为没有按照拓展二叉树去写,空结点并不会入队列,而我的判断语句是在出队列时发挥作用的,这就导致了我无法进行任何判断。修改方式为,遍历到了空结点也入队列。
Q3:修改好 Q3 后,发现无论什么情况判断为否。
A3:我的判断语句是根据是否是空结点来判断的,但是用拓展二叉树的思想让空结点入队列,操作在最后会有一系列空结点入队列,这就导致了无论如何都有空结点的出现。这就说明我的判断条件写错了,或者判断机制得重新设计。最后的解法是另外定义一个变量来统计结点数,当遇到空结点入队列时就停止统计,在层序遍历结束后返回这个变量。若返回的结点数和实际结点数相同,说明是完全二叉树,否则就不是。

知识总结

  1. 二叉搜索树的基操,这道题的前提条件就是建出二叉搜索树,没有这一步后面的所有都免谈。这就需要熟悉二叉搜索树的建立方式,二叉搜索树的建立基础是插入数据,而插入数据的本质是查找,虽然是基础操作,但是也可以加深对二叉搜索树的理解。
  2. 层序遍历法,这个操作是属于二叉树遍历法之一。层序遍历就好像从根结点开始,一层一层向下扩散搜索,这就跟我们队列实现迷宫算法非常类似,因为迷宫算法的不同路径也是无关联的,但是我们是用广度优先搜索的思想可以找到最短路径。层序遍历需要结合队列结构协同操作,在这里有熟悉了这个遍历手法。
  3. 完全二叉树的性质,完全二叉树的概念不好理解,但是用“从上到下,从左到右”这个顺序就会变得形象。在这里对完全二叉树的判断提出要求,这就需要理解其特点和性质,同时这也是堆结构的基础,在这里加深理解是很必要的。
  4. 辅助变量的使用,在这里我使用了 count 变量顺手判断了是否是完全二叉树。这个变量的设计,不仅是从需求和问题出发,更是结合了细化的知识点,可见细致的分析对问题的解决而言极为重要。

二叉搜索树的最近公共祖先

题目说明

测试样例

输入

6 8
6 3 1 2 5 4 8 7
2 5
8 7
1 9
12 -3
0 8
99 99

输出

LCA of 2 and 5 is 3.
8 is an ancestor of 7.
ERROR: 9 is not found.
ERROR: 12 and -3 are not found.
ERROR: 0 is not found.
ERROR: 99 and 99 are not found.

题目解析

这道题目是分成 3 部分来解决,分别是建立二叉搜索树、判断结点是否存在于树和获取 2 个结点的公共祖先。首先是建立二叉搜索树,这个操作虽然不难,循环调用插入函数就行。但是在这个地方一定要保证建立的正确性,否则下面的操作都无法实现。
接下来是判断结点是否存在于树,这个部分是二叉搜索树的基操,使用上面的函数就行。这里的想法是,若结点不存在于树中就可以忽略第 3 部分的操作。
第 3 部分就是获取 2 个结点的公共祖先,概括一下就是找到第一个公共祖先结点,该结点满足从这个结点出发进行搜索,可以找到两个要求的结点。关于这个操作可以用很多方式实现,这里讲解一个较为简单的手法,就是落脚到性质上去分析。对于二叉搜索树来说,满足条件的结点的数据域,值是 2 个给定数据的中间值,我们来观察一个例子。

对于结点 2 和 5,他们的公共祖先是结点 3,如图所示是如此,从数值上看 3 是 2 和 5 的中间值。不过为什么不能是结点 4 呢?因为结点 4 虽然是中间值,但是却不是第一个遇到的中间值,也就是结点 3 所在的层次比其更上层。进行搜索操作时,结点 3 就会被先遍历到。下面再看一个例子,对于结点 8 和 7,其公共祖先就是结点 8,因为结点 8 本身就可以访问它本身。

查找公共祖先函数 findLCA(BinTree BST, int num1, int num2)

伪代码

本质上其实也是查找操作,时间复杂度 O(㏒2n)。

代码实现

int findLCA(BinTree BST, int num1, int num2)
{
    while (1)
    {
        if (BST->data > num1&& BST->data > num2)      //LCA 在根结点左树中
        {
            BST = BST->left;
        }
        else if (BST->data < num1 && BST->data < num2)      //LCA 在根结点左树中
        {
            BST = BST->right;
        }
        else      //当前根结点是 LCA
        {
            break;
        }
    }
    return BST->data;
}

主函数 main()

伪代码

代码实现

int main()
{
    BinTree BST = NULL;
    int fre, count;
    int num1, num2;      //待查找的 LCA 的 2 个结点
    bool flag1, flag2;      //结点是否存在于树结构中的 flag
    int lca;

    cin >> fre >> count;
    for (int i = 0; i < count; i++)     //建树
    {
        cin >> num1;
        Insert(BST, num1); 
    }
    for (int i = 0; i < fre; i++)
    {
        cin >> num1 >> num2;
        flag1 = Find(BST, num1);      //查找结点是否在树中
        flag2 = Find(BST, num2);
        if (flag1 == false && flag2 == false)      //2 个都不在
        {
            printf("ERROR: %d and %d are not found.\n", num1, num2);
        }
        else if (flag1 == false)      //只有 1 个在
        {
            printf("ERROR: %d is not found.\n", num1);
        }
        else if (flag2 == false)
        {
            printf("ERROR: %d is not found.\n", num2);
        }
        else      //2 个结点都在
        {
            lca = findLCA(BST, num1, num2);      //找公共祖先
            if (lca == num1)
            {
                printf("%d is an ancestor of %d.\n", num1, num2);
            }
            else if (lca == num2)
            {
                printf("%d is an ancestor of %d.\n", num2, num1);
            }
            else
            {
                printf("LCA of %d and %d is %d.\n", num1, num2, lca);
            }
        }
    }
}

调试遇到的问题



虽然提交列表很长,但是只解决了 2 个问题。
Q1:找到的中间值并不是公共祖先,例如 2 和 5 找到的是 4。
A1:在我使用上述找公共祖先的方法之前,我还写了另一种算法。思想概括一下,就是另外定义一个结构体,我称之为报文结构体,里面有 1 个 int 类型变量表示状态码,用于判断需要输出什么信息,用 2 个 bool 类型变量标记 2 个数据分别有没有被找到,1 个 int 类型变量存储公共祖先的值。想法就是只搜索 1 次,若找到需要的数据就修改对应的 flag,若 2 个数据都找到了就利用递归回溯来确定公共祖先。这种做法我觉得绝对是可行的,但是我还没有试出比较好的方法来优化状态码变量,因为我传递这个结构体是使用引用来传递,但是当我找到了 2 个数据,并修改了 flag 类型,递归并没有结束,当下一层递归时 2 个 flag 都被改变了,就会去修改状态码。对于公共祖先较为密集的部分,这个状态码就很容易被提前修改。因此在我找到更好的办法来控制这个状态码之前,使用了上文提及的方法。
上文方法的好处是效率很高,这充分利用了二叉搜索树的性质,而我一开始并没有很好地理解所以没想到。
Q2:运行超时。
A2:我都不知道我中间做了什么,反正就是搞搞搞终于最后一次碰巧就不超时了,直接看截图吧。

插入函数这么写超时。

这么写不超时,看来确实是细节决定成败。由于我一开始漏了一个判断条件,使得建树函数并不能建立正确,在一些数据较为刁钻的测试点中就会有查找操作停不下来的情况。看来基础操作一定要烂熟于心,不能够出问题。

知识总结

  1. 二叉搜索树的基操,这道题的前提条件就是建出二叉搜索树,没有这一步后面的所有都免谈。这就需要熟悉二叉搜索树的建立方式,二叉搜索树的建立基础是插入数据,而插入数据的本质是查找,虽然是基础操作,但是也可以加深对二叉搜索树的理解。尤其需要注意一定不能漏条件,这里的数据还是比较有规律的,实际应用时如果没有对每一种条件都进行判断,就会出大问题。
  2. 二叉搜索树的性质,对于一个结点,比这个结点数值大的结点都在右子树,反之都在左子树。如果灵活运用这个性质,操作就会变得简捷而高效。
posted @ 2020-05-29 17:57  乌漆WhiteMoon  阅读(110)  评论(0编辑  收藏