二叉树面试题：单度结点删除 、中序线索化二叉树

最新推荐文章于 2022-10-06 11:28:58 发布
最新推荐文章于 2022-10-06 11:28:58 发布
阅读量463 收藏 1
点赞数
分类专栏： 数据结构实战开发【笔记】
课程笔记内容整理于狄泰软件
本文链接：https://blog.csdn.net/qq_39654127/article/details/80538598
版权

目录

1、面试题一：单度结点删除 

2、面试题二：中序线索化二叉树 

1、面试题一：单度结点删除 

编写一个函数用于删除二叉树中的所有单度结点 

要求：结点删除后，其唯一的子结点替代它的位置 

            

                                                            递归的思想

这里应该考虑结点中是否包含指向父结点的指针（这里是否包含可以问面试官）

情况一： 结点中包含指向父结点的指针

     － 定义功能： delOdd1(node) 

                 功能： 删除 node 为根结点的二叉树中的单度结点 

         

             度为0或2的结点不需要删除只需递归的删除左子树单度结点和右子树单度结点

 

情况二：结点中只包含左右孩子指针 

     － 定义功能： delOdd2(node)    

                 功能： 删除 node 为根结点的二叉树中的单度结点 

            

  编程实验 

单度结点删除一     delOdd1 

#include <iostream>  
#include "BTreeNode.h"  
  
using namespace std;  
using namespace DTLib;  
  
template < typename T >  
BTreeNode<T>* createTree() // 创建的树，就是前面画的树  
{  
    static BTreeNode<int> ns[9];  
  
    for(int i=0; i<9; i++)  
    {  
        ns[i].value = i;  
        ns[i].parent = NULL;  
        ns[i].left = NULL;  
        ns[i].right = NULL;  
    }  
  
    ns[0].left = &ns[1];  
    ns[0].right = &ns[2];  
    ns[1].parent = &ns[0];  
    ns[2].parent = &ns[0];  
  
    ns[1].left = &ns[3];  
    ns[1].right = NULL;  
    ns[3].parent = &ns[1];  
  
    ns[2].left = &ns[4];  
    ns[2].right = &ns[5];  
    ns[4].parent = &ns[2];  
    ns[5].parent = &ns[2];  
  
    ns[3].left = NULL;  
    ns[3].right = &ns[6];  
    ns[6].parent = &ns[3];  
  
    ns[4].left = &ns[7];  
    ns[4].right = NULL;  
    ns[7].parent = &ns[4];  
  
    ns[5].left = &ns[8];  
    ns[5].right = NULL;  
    ns[8].parent = &ns[5];  
  
    return ns;  
}  
  
template < typename T >  
void printInOrder(BTreeNode<T>* node)   // 中序遍历  
{  
    if( node != NULL )  
    {  
        printInOrder(node->left);  
  
        cout << node->value << " ";  
  
        printInOrder(node->right);  
    }  
}  
  
template < typename T >  
BTreeNode<T>* delOdd1(BTreeNode<T>* node)  
{  
    BTreeNode<T>* ret = NULL;  
  
    if(node != NULL)  
    {  
        // 度为1
        if((  node->left && !node->right ) ||  
           ( !node->left &&  node->right ))  
        {  
            BTreeNode<T>* parent = dynamic_cast<BTreeNode<T>*>(node->parent);
  
            BTreeNode<T>* node_child = (node->left != NULL) ? node->left : node->right; // 指向单度结点的唯一孩子  
  
            if( parent != NULL )  
            {  
                BTreeNode<T>*& parent_chlid =  (parent->left == node) ? parent->left : parent->right; // 父结点中指向node的指针  
  
                parent_chlid = node_child;  
                node_child->parent = parent;  
  
            }  
            else    // 根结点为单度  
            {  
                node_child->parent = NULL;  
            }  
  
            if( node->flag() )  
            {  
                delete node;  
            }  
  
            ret = delOdd1(node_child);  // 持续删除单度结点  
        }  
        else    // 度为0，2  
        {  
            delOdd1(node->left);  
            delOdd1(node->right);  
  
            ret = node;  
        }  
  
    }  
  
    return ret;  
}  
  
int main()  
{  
    BTreeNode<int>* ns = createTree<int>();  
  
    printInOrder(ns);  
  
    cout << endl;  
  
    ns = delOdd1(ns);  
  
    printInOrder(ns);  
  
    cout << endl;  
  
    int a[] = {6, 7, 8};  
  
    for(int i=0; i<3; i++)    // 打印叶结点到根结点路径  
    {  
        TreeNode<int>* n = ns + a[i];   // n代表叶节点，这里序号就是顺序  
  
        while(n != NULL)  
        {  
            cout << n->value << " ";  
            n = n->parent;  
        }  
  
        cout << endl;  
    }  
    return 0;  
}

                        

单度结点删除二     delOdd2   

#include <iostream>  
#include "BTreeNode.h"  
  
using namespace std;  
using namespace DTLib;  
  
template < typename T >  
BTreeNode<T>* createTree() //创建的树就是前，前面画的树  
{  
    static BTreeNode<int> ns[9];  
  
    for(int i=0; i<9; i++)  
    {  
        ns[i].value = i;  
        ns[i].parent = NULL;  
        ns[i].left = NULL;  
        ns[i].right = NULL;  
    }  
  
    ns[0].left = &ns[1];  
    ns[0].right = &ns[2];  
    ns[1].parent = &ns[0];  
    ns[2].parent = &ns[0];  
  
    ns[1].left = &ns[3];  
    ns[1].right = NULL;  
    ns[3].parent = &ns[1];  
  
    ns[2].left = &ns[4];  
    ns[2].right = &ns[5];  
    ns[4].parent = &ns[2];  
    ns[5].parent = &ns[2];  
  
    ns[3].left = NULL;  
    ns[3].right = &ns[6];  
    ns[6].parent = &ns[3];  
  
    ns[4].left = &ns[7];  
    ns[4].right = NULL;  
    ns[7].parent = &ns[4];  
  
    ns[5].left = &ns[8];  
    ns[5].right = NULL;  
    ns[8].parent = &ns[5];  
  
    return ns;  
}  
  
template < typename T >  
void printInOrder(BTreeNode<T>* node)   // 中序遍历  
{  
    if( node != NULL )  
    {  
        printInOrder(node->left);  
  
        cout << node->value <<" ";  
  
        printInOrder(node->right);  
    }  
}  
  
template < typename T >  
void delOdd2(BTreeNode<T>*& node)  
{  
  
    if(node != NULL)  
    {  
        if((  node->left && !node->right ) ||  
           ( !node->left &&  node->right ))  
        {  
  
            BTreeNode<T>* node_child = (node->left != NULL) ? node->left : node->right; // 指向单度结点的唯一孩子  
  
            if(node->flag())  
            {  
                delete node;  
            }  
  
            node = node_child;  // node是父结点左孩子指针或右孩子指针的引用  
  
            delOdd2(node);  
        }  
        else  
        {  
            delOdd2(node->left);  
            delOdd2(node->right);  
        }  
     }  
}  
  
int main()  
{  
    BTreeNode<int>* ns = createTree<int>();  
  
    printInOrder(ns);  
  
    cout << endl;  
  
    delOdd2(ns);  
  
    printInOrder(ns);  
  
    cout << endl;  
  
  
    return 0;  
}

                            

 

2、面试题二：中序线索化二叉树 

编写一个函数用于中序线索化二叉树 

要求：不允许使用其它数据结构 （我们前面实现基于队列）  

        

解法一：在中序遍历的同时进行线索化 

     － 思路： 

                 ● 使用辅助指针，在中序遍历时指向当前结点的前驱结点 

                 ● 访问当前结点时，连接与前驱结点的先后次序 

                                    

     － 定义功能： inOrderThread(node, pre) 

                 ● node: 根结点，也是中序访问的结点 

                 ● pre: 为中序遍历时的前驱结点指针 

            

解法二：中序遍历的结点次序正好是结点的水平次序 

     － 思路： 

                 ● 使用辅助指针，指向转换后双向链表的头结点和尾结点 

                 ● 根结点与左右子树转换的双向链表连接，成为完整双向链表 

 

            

     － 定义功能： inOrderThread(node, head, tail) 

                 ● node: 根结点，也是中序访问的结点

                 ● head: 转换成功后指向双向链表的首结点 

                 ● tail : 转换成功后指向双链表的尾结点 

 

            

编程实验 

中序线索化一     inOrderThread1

#include <iostream>  
#include "BTreeNode.h"  
  
using namespace std;  
using namespace DTLib;  
  
template < typename T >  
BTreeNode<T>* createTree() // 创建的树就是前，前面画的树  
{  
    static BTreeNode<int> ns[9];  
  
    for(int i=0; i<9; i++)  
    {  
        ns[i].value = i;  
        ns[i].parent = NULL;  
        ns[i].left = NULL;  
        ns[i].right = NULL;  
    }  
  
    ns[0].left = &ns[1];  
    ns[0].right = &ns[2];  
    ns[1].parent = &ns[0];  
    ns[2].parent = &ns[0];  
  
    ns[1].left = &ns[3];  
    ns[1].right = NULL;  
    ns[3].parent = &ns[1];  
  
    ns[2].left = &ns[4];  
    ns[2].right = &ns[5];  
    ns[4].parent = &ns[2];  
    ns[5].parent = &ns[2];  
  
    ns[3].left = NULL;  
    ns[3].right = &ns[6];  
    ns[6].parent = &ns[3];  
  
    ns[4].left = &ns[7];  
    ns[4].right = NULL;  
    ns[7].parent = &ns[4];  
  
    ns[5].left = &ns[8];  
    ns[5].right = NULL;  
    ns[8].parent = &ns[5];  
  
    return ns;  
}  
  
template < typename T >  
void printInOrder(BTreeNode<T>* node)   // 中序遍历  
{  
    if( node != NULL )  
    {  
        printInOrder(node->left);  
  
        cout << node->value <<" ";  
  
        printInOrder(node->right);  
    }  
}  
  
template < typename T >  
void printDualList(BTreeNode<T>* node)  
{  
    BTreeNode<T>* g = node;  
  
    cout << "head -> tail: " << endl;  
  
    while( node != NULL )  
    {  
        cout << node->value << " ";  
  
        g = node;  
  
        node = node->right;  
    }  
  
    cout << endl;  
  
    cout << "tail -> head: " << endl;  
  
    while( g != NULL )  
    {  
        cout << g->value << " ";  
  
        g = g->left;  
    }  
  
    cout << endl;  
}  
  
template < typename T >  
void inOrderThread(BTreeNode<T>* node, BTreeNode<T>*& pre)  
{  
    if(node != NULL)  
    {  
        inOrderThread(node->left, pre);  // 左子树为双向链表，pre指向最后一个结点  
  
        node->left = pre;  
  
        if(pre != NULL)  
        {  
            pre->right = node;  
        }  
  
        pre = node;  
  
        inOrderThread(node->right, pre);  
    }  
  
}  
template < typename T >  
BTreeNode<T>* inOrderThread1(BTreeNode<T>* node)  
{  
    BTreeNode<T>* pre = NULL;  
  
    inOrderThread(node, pre);  
  
    while( (node != NULL) && (node->left != NULL) )  
    {  
        node = node->left;  
    }  
  
    return node;  
}  
  
int main()  
{  
    BTreeNode<int>* ns = createTree<int>();  
  
    printInOrder(ns);  
  
    cout << endl;  
  
    delOdd2(ns);  
  
    printInOrder(ns);  
  
    cout<<endl;  
  
    ns = inOrderThread1(ns);  
  
    printDualList(ns);  
  
    return 0;  
}

  

 

 

 

中序线索化二     inOrderThread2

#include <iostream>  
#include "BTreeNode.h"  
  
using namespace std;  
using namespace DTLib;  
  
template < typename T >  
BTreeNode<T>* createTree() // 创建的树就是前，前面画的树  
{  
    static BTreeNode<int> ns[9];  
  
    for(int i=0; i<9; i++)  
    {  
        ns[i].value = i;  
        ns[i].parent = NULL;  
        ns[i].left = NULL;  
        ns[i].right = NULL;  
    }  
  
    ns[0].left = &ns[1];  
    ns[0].right = &ns[2];  
    ns[1].parent = &ns[0];  
    ns[2].parent = &ns[0];  
  
    ns[1].left = &ns[3];  
    ns[1].right = NULL;  
    ns[3].parent = &ns[1];  
  
    ns[2].left = &ns[4];  
    ns[2].right = &ns[5];  
    ns[4].parent = &ns[2];  
    ns[5].parent = &ns[2];  
  
    ns[3].left = NULL;  
    ns[3].right = &ns[6];  
    ns[6].parent = &ns[3];  
  
    ns[4].left = &ns[7];  
    ns[4].right = NULL;  
    ns[7].parent = &ns[4];  
  
    ns[5].left = &ns[8];  
    ns[5].right = NULL;  
    ns[8].parent = &ns[5];  
  
    return ns;  
}  
  
template < typename T >  
void printInOrder(BTreeNode<T>* node)   // 中序遍历  
{  
    if( node != NULL )  
    {  
        printInOrder(node->left);  
  
        cout << node->value <<" ";  
  
        printInOrder(node->right);  
    }  
}  
  
template < typename T >  
void printDualList(BTreeNode<T>* node)  
{  
    BTreeNode<T>* g = node;  
  
    cout << "head -> tail: " << endl;  
  
    while( node != NULL )  
    {  
        cout << node->value << " ";  
  
        g = node;  
  
        node = node->right;  
    }  
  
    cout << endl;  
  
    cout << "tail -> head: " << endl;  
  
    while( g != NULL )  
    {  
        cout << g->value << " ";  
  
        g = g->left;  
    }  
  
    cout << endl;  
}  
  
template < typename T >  
void inOrderThread(BTreeNode<T>* node,BTreeNode<T>*& head,BTreeNode<T>*& tail)  
{  
    if(node != NULL)  
    {  
        BTreeNode<T>* h = NULL;  
        BTreeNode<T>* t = NULL;  
  
        inOrderThread(node->left, h, t);  
  
        node->left = t;  
  
        if(t != NULL)  
        {  
            t->right = node;  
        }  
  
        head = (h != NULL) ? h : node;  
  
        h = NULL;  
        t = NULL;  
  
        inOrderThread(node->right, h, t);  
  
        node->right = h;  
  
        if(h != NULL)  
        {  
            h->left = node;  
        }  
  
        tail = (t != NULL) ? t : node;  
    }  
  
}  
template < typename T >  
BTreeNode<T>* inOrderThread2(BTreeNode<T>* node)  
{  
    BTreeNode<T>* head = NULL;  
    BTreeNode<T>* tail = NULL;  
  
    inOrderThread(node, head, tail);  
  
    return head;  
}  
  
int main()  
{  
    BTreeNode<int>* ns = createTree<int>();  
  
    printInOrder(ns);  
  
    cout << endl;  
  
    ns = inOrderThread2(ns);  
  
    printDualList(ns);  
  
    return 0;  
}

                                

 

洋葱汪
关注
专栏目录
[各种面试题] 将一棵普通二叉树转换为一棵线索二叉树
a83610312的专栏
09-19 2327
将一棵普通二叉树转换为一棵线索二叉树（查看定义）。 详细说明：树结点除了包含left, right指针外，还包含isLeftThread和isRightThread，初始时isLeftThread和isRightThread都为false。对于left为null的结点，请将left设置为中序遍历该结点的前驱结点，并将isLeftThread设置为true。对于right为null的结点，请将
Java~二叉树进阶练习题：根据先序遍历和中序遍历构建二叉树 与 根据后序遍历和中序遍历构建二叉树
最新发布
a1901149的博客
04-30 401
学习技术一定要制定一个明确的学习路线，这样才能高效的学习，不必要做无效功，既浪费时间又得不到什么效率，大家不妨按照我这份路线来学习。大家不妨直接在牛客和力扣上多刷题，同时，我也拿了一些面试题跟大家分享，也是从一些大佬那里获得的，大家不妨多刷刷题，为金九银十冲一波！《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！[外链图片转存中…(img-hzqGxESh-1714438396250)]
面试高频必问-线索化二叉树
qq_25913607的博客
05-13 305
线索化二叉树 1、先看一个问题 将数列{1,3,6,8,10,14}构建成一颗二叉树.n+1=7 问题分析: 当我们对上面的二叉树进行中序遍历时，数列为{8,3,10,1,6,14} 但是6,8,10,14这几个节点的左右指针，并没有完全的利用上. 如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点,怎么办? 解决方案-线索二叉树 2、线索二叉树基本介绍 n个结点的二叉链表中含有n+1【公式2n-(n-1)=n+1】个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍
二叉树-单度节点的删除
qq_37933895的博客
08-07 428
递归实现(不带父亲指针) #include <iostream> #include "BTree.h" using namespace std; using namespace DTlib; template < typename T > BTreeNode<T>* createTree() { static BTreeNode<int&g...
二叉树-单度节点删除
qq_37933895的博客
08-07 199
递归实现 #include <iostream> #include "BTree.h" using namespace std; using namespace DTlib; template < typename T > BTreeNode<T>* createTree() { static BTreeNode<int> ns[9]...
数据结构笔记：二叉树单度节点删除
mlove编程
03-02 487
编写一个函数用于删除二叉树中度为1的所有节点。 要求：节点删除后，其唯一的子节点替代它的位置。 如下： 代码如下，如有问题请指出，谢谢指导： typedef struct _tag_BTreeNode BTreeNode; struct _tag_BTreeNode { int data; BTreeNode* left; BTreeNode* right; }; vo...
二叉树面试题 树和二叉树总结.doc
02-24
"二叉树面试题 树和二叉树总结" 本资源摘要信息涵盖了树和二叉树的面试题总结，包括选择题和解释。涵盖的知识点包括树和二叉树的定义、性质、操作和应用等。 一、树和二叉树的定义 树是一种数据结构，由一个根...
六大类二叉树面试题汇总解答
m0_54828003的博客
10-06 387
这一篇文章汇总下常见的二叉树相关面试题，主要分为判断类、构建类、存储类、查找类、距离类、混合类这六类大问题。
【剑指offer刷题】JZ57：给定二叉树和某个结点，找到中序遍历顺序的下一个结点
Spikeloiter的博客
07-19 255
【剑指offer刷题】JZ57：给定二叉树和某个结点，找到其下一个结点
《剑指Offer》刷题笔记——面试题32-II. 从上到下打印二叉树II
12-22
本题“面试题32-II. 从上到下打印二叉树II”是一道关于二叉树层次遍历的问题，难度为简单。下面将详细解析这个问题及其解决方案。 ### 一、题目描述 题目要求我们从上到下（自顶向下）地打印二叉树的每一层节点，...
数据结构——线索二叉树
zhaoxianyong的专栏
01-01 4087
一、线索二叉树         遍历二叉树实际上是将树中的结点按照一定的规则构成一个线性序列，不同的遍历方式得到的是不同的序列。对于需要经常遍历的二叉树，可以充分利用二叉树的空指针域，保存遍历中的信息，即左右指针分别记录结点的前驱和后继，即二叉树的线索化。         重新定义二叉树结点如下，增加两个标志域： typedef enum PointerTag{Link, Thread};
做习题，学知识--线索二叉树
暗星涌动
09-04 836
二叉树在线索化后，仍不能有效求解的问题是（）A、先序线索二叉树中求先序后继 B、中序线索二叉树中求中序后继C、中序线索二叉树中求中序前驱D、后序线索二叉树中求后序后继因为有...
删除二叉树中的度数为1的所有结点
大冰的小屋
04-02 1794
要求：结点删除后其唯一的子节点代替它的位置。 这里用到了递归的方法，不断遍历每个节点的左右子树，将度数为一的结点删除。 #include using namespace std; struct Node { int v; Node* left; Node* right; }; void print_div(int p) { for(int i=0; i < p; i++) {
先序遍历建立二叉树，中序遍历线索化二叉树，删除线索二叉树的节点
weixin_40625079的博客
07-31 1004
#include"stdio.h" #include"stdlib.h" typedef struct TBTNode { int data; int ltag,rtag;//ltag == 0表示存在左孩子 ，ltag == 1表示存在前驱线索 struct TBTNode *lchild; struct TBTNode *rchild; } TBTNode; ...
线索二叉树实例
ay_一起沉默 的博客
09-06 906
线索二叉树：二叉树存储结构完全依靠链表，而二叉树的链表表示的关系是父结点和子结点（子树）的关系， 而无法直接获得前驱-后继的关系，即，当要求某个结点的前驱结点or后继结点比较麻烦； 为了在不增加指针的情况下直接快速找到前驱/后继结点，可以使用 线索二叉树 来实现； 由于遍历方法不同时，产生的元素顺序不同，则每个元素的前驱/后继结点也不一定
中序线索二叉树
Dread_naught的专栏
12-07 2587
线索二叉树主要是为了解决查找结点的线性前驱与后继不方便的难题。它只增加了两个标志性域，就可以充分利用没有左或右孩子的结点的左右孩子的存储空间来存放该结点的线性前驱结点与线性后继结点。两个标志性域所占用的空间是极少的，所有充分利用了二叉链表中空闲存的储空间。    要实现线索二叉树，就必须定义二叉链表结点数据结构如下（定义请看代码）： left leftTa
二叉树经典题之线索二叉树（中序）
快乐江湖的博客
05-25 1309
前言： 二叉树刷题是有固定思维的，请移步 README】二叉树刷题框架 线索二叉树 题目 点击跳转：牛客 思路 此题本质就是二叉树的线索化，所谓二叉树的线索化就是不借用栈通过指针的指向来完成二叉树的非递归遍历 所以此题中要求的双向链表本质就是指针的链接，而且它要求的是排好序的双向链表，而我们知道二叉搜索树的中序遍历就是顺序的，所以可以进行中序线索化 过程也非常简单，只需要创建一个前驱指针prev，再每次进行递归之前，把当前结点root的left指向prev，同时把prev（不空）的right指向
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值