二叉树的一些笔试面试常见题目

最新推荐文章于 2024-09-17 20:47:29 发布
最新推荐文章于 2024-09-17 20:47:29 发布
阅读量518 收藏 2
点赞数 1
分类专栏： c++ 笔试 文章标签： cc++ 笔试 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HJ_show/article/details/52033162
版权
本文详细介绍了二叉树的各种遍历方法，包括递归和非递归的前序、中序、后序遍历，以及层次遍历。此外，还涉及到了二叉树的创建、深度计算、节点计数以及判断是否为平衡二叉树等操作。通过这些内容，可以帮助读者深入理解二叉树的基本操作。
摘要由CSDN通过智能技术生成 
//树的一些常见编程题目
#include<iostream>    
#include<queue>    
#include<stack>    
using namespace std;    
    
//二叉树结点的描述    
typedef struct BiTNode  
{    
    char data;    
    struct BiTNode *lchild, *rchild;      //左右孩子    
}BiTNode,*BiTree;    
    
//按先序遍历创建二叉树    
//BiTree *CreateBiTree()     //返回结点指针类型    
//void CreateBiTree(BiTree &root)      //引用类型的参数    
void CreateBiTree(BiTNode **root)    //二级指针作为函数参数    
{    
    char ch; //要插入的数据    
    scanf("\n%c", &ch);  
    //cin>>ch;    
    if(ch=='#')  
        *root = NULL;  
    else  
    {  
        *root = (BiTNode *)malloc(sizeof(BiTNode));  
        (*root)->data = ch;  
        printf("请输入%c的左孩子：",ch);  
        CreateBiTree(&((*root)->lchild));  
        printf("请输入%c的右孩子：",ch);  
        CreateBiTree(&((*root)->rchild));  
    }  
}  
    
//前序遍历的算法程序    
void PreOrder(BiTNode *root)  
{    
    if(root==NULL)    
        return ;    
    printf("%c ", root->data); //输出数据    
    PreOrder(root->lchild); //递归调用，前序遍历左子树    
    PreOrder(root->rchild); //递归调用，前序遍历右子树    
}    
    
//中序遍历的算法程序    
void InOrder(BiTNode *root)    
{    
    if(root==NULL)  
        return ;  
    InOrder(root->lchild); //递归调用，前序遍历左子树    
    printf("%c ", root->data); //输出数据    
    InOrder(root->rchild); //递归调用，前序遍历右子树    
}    
    
//后序遍历的算法程序    
void PostOrder(BiTNode *root)  
{  
    if(root==NULL)  
        return ;  
    PostOrder(root->lchild);      //递归调用，前序遍历左子树    
    PostOrder(root->rchild);      //递归调用，前序遍历右子树    
    printf("%c ", root->data);    //输出数据      
}    
    
/*  
二叉树的非递归前序遍历，前序遍历思想：先让根进栈，只要栈不为空，就可以做弹出操作，  
每次弹出一个结点，记得把它的左右结点都进栈，记得右子树先进栈，这样可以保证右子树在栈中总处于左子树的下面。  
*/ 
#if 1
void PreOrder_Nonrecursive(BiTree T)     //先序遍历的非递归      
{    
    if(!T)      
        return ;      
      
    stack<BiTree> s;    
    s.push(T);    
    
    while(!s.empty())    
    {    
        BiTree temp = s.top();    
        cout<<temp->data<<" ";    
        s.pop();    
        if(temp->rchild)    
            s.push(temp->rchild);    
        if(temp->lchild)    
            s.push(temp->lchild);    
    }    
}      
#endif

/*  
二叉树的非递归中序遍历*/
void InOrder_Nonrecursive1(BiTree T)
{
	if(T == NULL)
		return;

	stack<BiTree> s;
	BiTree curr = T;
	
	while(curr != NULL)
	{
		s.push(curr);
		curr = curr->lchild;
	}

	while(!s.empty())
	{
		curr = s.top();
		s.pop();
		cout<<curr->data<<" ";
		if(curr->rchild)
		{
			curr = curr->rchild;
			while(curr != NULL)
			{
				s.push(curr);
				curr = curr->lchild;
			}
		}
	}
}

void PostOrder_Nonrecursive1(BiTree T)  // 后序遍历的非递归      
{      
	if(T == NULL)
		return;
    stack<BiTree> s;      
    BiTree curr = T ;           // 指向当前要检查的节点    
    BiTree previsited = NULL;    // 指向前一个被访问的节点    
	while(curr != NULL)
	{
		s.push(curr);
		curr = curr->lchild;
	}

	while(!s.empty())
	{
		curr = s.top();
		//如果右子树为空或者已经被访问过，则输出当前结点
		if(curr->rchild == NULL || curr->rchild == previsited)
		{
			cout<<curr->data<<" ";
			previsited = curr;
			s.pop();
		} 
		else if(curr->lchild == previsited) //如果左子树已经被访问，则访问右子树
		{
			curr = curr->rchild;
			while(curr != NULL)
			{
				s.push(curr);
				curr = curr->lchild;
			}
		}
	}
}     
    
void PostOrder_Nonrecursive(BiTree T)  // 后序遍历的非递归     双栈法    
{      
    stack<BiTree> s1 , s2;      
    BiTree curr ;           // 指向当前要检查的节点    
    s1.push(T);    
  
	while(!s1.empty())  // 栈空时结束      
    {    
        curr = s1.top();    
        s1.pop();    
        s2.push(curr);    
        if(curr->lchild)    
            s1.push(curr->lchild);    
        if(curr->rchild)    
            s1.push(curr->rchild);    
    }    
    
	while(!s2.empty())    
    {    
        printf("%c ", s2.top()->data);    
        s2.pop();    
    }    
}  
    
int visit(BiTree T)    
{    
    if(T)    
    {    
        printf("%c ",T->data);    
        return 1;    
    }    
    else    
        return 0;    
}    
    
// 使用递归求二叉树的深度
int getDepth(BiTree T)
{
	if(T == NULL)
		return 0;
	int d1 = getDepth(T->lchild);
	int d2 = getDepth(T->rchild);
	return (d1 > d2 ? d1 : d2) + 1;
}

// 使用非递归算法求二叉树的深度,根据层次遍历来求解
#define MARK ((BiTree) -1)
int visit2(BiTree T,int &depth)
{ 
	if(T == NULL)
		return -1;
	
	if(T == MARK)
		++depth;
	
	return 1;

}

int getDepth_Nonrecursive(BiTree T)
{
	if(T == NULL)
		return 0;
	queue<BiTree> Q;
	Q.push(T);
	Q.push(MARK);
	int depth = 0;
	
	while(!Q.empty())
	{
		int flag = 0;
		BiTree curr = Q.front();
		Q.pop();
		visit2(curr,depth);
		if(curr != MARK && curr->lchild)
		{
			Q.push(curr->lchild);
			flag = 1;
		}

		if(curr != MARK && curr->rchild)
		{
			Q.push(curr->rchild);
			flag = 1;
		}
		if(flag)
			Q.push(MARK);
	}
	return depth;
}

//使用递归求出二叉树的结点个数
int getNodeCount(BiTree T)
{
	if(T == NULL)
		return 0;
	return 1 + getNodeCount(T->lchild) + getNodeCount(T->rchild);
}

//递归判断二叉树是否相等
bool cmpTree(BiTree T1,BiTree T2)
{
	if(T1 == NULL && T2 == NULL)
		return true;
	if(T1 == NULL || T2 == NULL)
		return false;

	if(T1 && T2)
	{
		if(T1->data == T2->data)
		{
			if(cmpTree(T1->lchild,T2->lchild))
				return cmpTree(T1->rchild,T2->rchild);
			else if(cmpTree(T1->lchild,T2->rchild))
				return cmpTree(T1->rchild,T2->lchild);
		}
	}
}

//使用队列层次遍历二叉树
void LeverTraverse(BiTree T) 
{
	queue<BiTree> Q;
	BiTree p = T;
	if(p != NULL)
		Q.push(p);
	
	while(!Q.empty())
	{	
		BiTree curr = Q.front();
		Q.pop();
		visit(curr);
		if(curr->lchild)
		{
			Q.push(curr->lchild);
		}

		if(curr->rchild)
		{
			Q.push(curr->rchild);
		}
	}
}

//如何判断二叉树是否是平衡二叉树
void IsBalance()
{

}

//判断B是否是A的子树
bool DoesTree1HaveTree2(BiTree T1,BiTree T2)
{
	if(T1 == NULL)
		return false;
	if(T2 == NULL)
		return true;
	if(T1->data != T2->data)
		return false;

	if(DoesTree1HaveTree2(T1->lchild,T2->lchild))
		return DoesTree1HaveTree2(T1->rchild,T2->rchild);
	else
		return false;
}
bool HasSubtree(BiTree T1,BiTree T2)
{
	bool result = false;
	
	if(T1 != NULL && T2 != NULL)
	{
		if(T1->data == T2->data)
			result = DoesTree1HaveTree2(T1,T2);
		if(!result)
			result = HasSubtree(T1->lchild,T2);
		if(!result)
			result = HasSubtree(T2->rchild,T2);
	}

	return result;
}


#if 0
int main(void)    
{    
    BiTNode *root = NULL; //定义一个根结点    
    int flag=1,k;    
    printf("                     本程序实现二叉树的基本操作。\n");    
    printf("可以进行建立二叉树，递归先序、中序、后序遍历，非递归先序、中序遍历及非递归层序遍历等操作。\n");    
    
    while(flag)    
    {    
        printf("\n");    
        printf("|--------------------------------------------------------------|\n");    
        printf("|                    二叉树的基本操作如下:                     |\n");    
        printf("|                        0.创建二叉树                          |\n");    
        printf("|                        1.递归先序遍历                        |\n");    
        printf("|                        2.递归中序遍历                        |\n");    
        printf("|                        3.递归后序遍历                        |\n");    
        printf("|                        4.非递归先序遍历                      |\n");    
        printf("|                        5.非递归中序遍历                      |\n");    
        printf("|                        6.非递归后序遍历                      |\n");    
        printf("|                        7.非递归层序遍历                      |\n");    
        printf("|                        8.二叉树的深度                        |\n");    
        printf("|                        9.二叉树的结点个数                    |\n");    
        printf("|                        10.退出程序                            |\n");    
        printf("|--------------------------------------------------------------|\n");    
        printf("                        请选择功能：");    
        scanf("%d",&k);    
        switch(k)    
        {    
        case 0:    
            printf("请建立二叉树并输入二叉树的根节点：");    
            CreateBiTree(&root);    
            break;    
        case 1:    
            if(root)    
            {    
                printf("递归先序遍历二叉树的结果为：");    
                PreOrder(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 2:    
            if(root)    
            {    
                printf("递归中序遍历二叉树的结果为：");    
                InOrder(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 3:    
            if(root)    
            {    
                printf("递归后序遍历二叉树的结果为：");    
                PostOrder(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 4:    
            if(root)    
            {    
                printf("非递归先序遍历二叉树：");    
                PreOrder_Nonrecursive(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 5:    
            if(root)    
            {    
                printf("非递归中序遍历二叉树：");    
                //InOrderTraverse1(root);    
				InOrder_Nonrecursive1(root);
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 6:    
            if(root)    
            {    
                printf("非递归后序遍历二叉树：");    
                PostOrder_Nonrecursive(root);   
				//PostOrder_Nonrecursive1(root);
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 7:    
            if(root)    
            {    
                printf("非递归层序遍历二叉树：");    
                //LeverTraverse(root);    
                LevelOrder(root);    
                printf("\n");    
            }    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 8:    
            if(root)    
                printf("这棵二叉树的深度为：%d\n",depth(root));    
            else    
                printf("          二叉树为空！\n");    
            break;    
        case 9:    
            if(root)    
                printf("这棵二叉树的结点个数为：%d\n",CountNode(root));    
            else    
                printf("          二叉树为空！\n");    
            break;    
        default:    
            flag=0;    
            printf("程序运行结束，按任意键退出！\n");    
        }    
    }    
    system("pause");    
    return 0;    
}
#endif

//根据前序和中序遍历来构建二叉树
int CreateBiTreeWithPreAndIn(char *pPre,char *pIn,int num,BiTNode *T)
{
	if(pPre == NULL || pIn == NULL || T == NULL)
		return -1;
	
	if(num == 0)
		return 0;
	T->data = pPre[0];
	int i = 0;
	for(i = 0;i < num;++i)
	{
		if(pIn[i] == T->data)
			break;
	}
	
	if(i == num)
	{
		printf("--\n");
		return -2;
	}

	if(i > 0) // 有左子树
	{
		T->lchild = new BiTNode();
		CreateBiTreeWithPreAndIn(pPre+1,pIn,i,T->lchild);
	}

	if(num - i - 1 > 0) // 有右子树
	{	
		T->rchild = new BiTNode();
		CreateBiTreeWithPreAndIn(pPre+i+1,pIn+i+1,num - i - 1,T->rchild);
	}
	
}

//输入一个数组，判断是否是一个二叉搜索树的后序遍历
bool IsBiTreePostOrder(int a[],int n)
{
	if(a == NULL)
		return false;
	if(n == 1)
		return true;
   
	if(n > 1)
	{
		int root = a[n-1];
		int leftLen = 0;
		for(int i = 0;i < n-1;++i)
		{
			if(a[i] < root)
				leftLen = i+1;
			else
				break;
		}

		for(int i = leftLen + 1;i<n-1;++i)
		{
			if(a[i] < root)
				return false;
		}

		if(IsBiTreePostOrder(a,leftLen))
			return IsBiTreePostOrder(a+leftLen,n-leftLen-1);
	}	
}

//计算出从根节点到叶节点路径和等于expectedSum的路径
void printPath(vector<char> &path)
{
	for(auto it = path.cbegin();it != path.cend();++it)
	{
		printf("%d ",*it);
	}
	printf("\n");
}

void FindPath(BiTree T,char expectedSum,char currSum,vector<char> &path)
{
	path.push_back(T->data);
	currSum += T->data;
	bool isLeaf = (T->lchild == NULL && T->rchild == NULL);
	if(isLeaf && currSum == expectedSum)
		printPath(path);
	if(T->lchild)
		FindPath(T->lchild,expectedSum,currSum,path);
	if(T->rchild)
		FindPath(T->rchild,expectedSum,currSum,path);
	path.pop_back();
}

void  FindPath(BiTree T,char expectedSum)
{
	if(T == NULL)
		return ;
	char currSum = 0 ;
	vector<char> path;
	FindPath(T,expectedSum,currSum,path);
}

HJ_show
关注
专栏目录
二叉树相关笔试题(一)
mi_rencontre的博客
05-11 611
1.根据二叉树的前序遍历和中序遍历的结果重建二叉树 分析：二叉树的前序遍历顺序是根->左->右，中序遍历顺序是左->根->右，由此可以看出在前序遍历中的第一个数字为二叉树的根节点，接着扫描中序遍历的结果就可以得到根结点的位置，在根节点左边的数为左子树结点的值，位于根节点右边的为右子树结点的值，接下来可以用递归的方法分别构建左右子树。
嵌入式软件笔试面试总结
10-25
总的来说，嵌入式软件笔试面试涵盖了广泛的知识点，要求求职者不仅要有扎实的理论基础，还需要具备实践经验和问题解决能力。通过深入学习和实践，你可以更好地应对这些挑战，成功踏入嵌入式软件开发的大门。
二叉树笔试题
weixin_34366546的博客
11-11 145
题目：输入两棵二叉树A和B，判断树B是不是A的子结构 bool IsChildTree(Node * father, Node * son) { if(father == NULL &amp;&amp; son == NULL) return true; if(father == NULL &amp;&amp; son != NULL) ...
数据结构（二叉树）练习题————考前必备合集
最新发布
2301_79083481的博客
09-17 1294
数据结构————二叉树练习题
轻松搞定面试中的二叉树题目
热门推荐
计算机的艺术
08-29 26万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7518888 树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树是递归定义的，因此，与二叉树有关
二叉树笔试题（一）
Nan_Feng726的博客
06-06 1117
1、二叉树的前序遍历、中序遍历、后序遍历 思路： 在二叉树那篇文章里已经介绍过，这里直接看代码： private ArrayList<Integer> list; //1、前序 private void preorder(TreeNode root) { if (root != null) { list.add(root.val...
二叉树笔试题（二）
Nan_Feng726的博客
06-10 1022
1、采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。空节点则用一对空括号 "()" 表示。省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。 示例： 思路： 如果根节点不为空的话，在字符串后边先打印一个左括号，然后再打印根节点的值。 如果左子树为空，而右子树不为空，像示例2的那样，就必须打印一对括号出来，不可以省略（如果左右子树都为空，可以省略括号）。 其余情...
C++笔试面试常见问题解析
C++笔试面试是技术招聘中常见的环节，考察的是应聘者对C++语言的深入理解和应用能力。以下是一些关键知识点的详细解释： 1. 关键字`static`的作用： - 函数内部的`static`变量：在每次函数调用时保持其值，即具有...
C++编程：笔试面试常见问题解析
"计算机专业必备笔试面试锦囊，包含了丰富的计算机知识，如C++、数据结构、内存管理、网络协议等，适用于准备IT行业笔试和面试的求职者。" 计算机专业求职者在准备笔试和面试时，需要掌握一系列关键知识点。以下是...
常见的笔试和面试题目，涵盖了数据结构、算法、操作系统、网络、数据库.pdf
07-28
### 常见的笔试和面试题目解析 #### 数据结构与算法 1. **数组与字符串** - **反转一个字符串**： - 字符串是不可变对象，在大多数编程语言中，通常需要借助额外的数据结构（如数组或列表）来实现字符串的反转。...
互联网公司笔试面试题目
08-03
在互联网公司的招聘过程中，笔试和面试是至关重要的环节，这些题目通常涵盖了计算机科学和技术的各个方面，旨在测试候选人的基础知识、编程能力、问题解决技巧以及逻辑思维能力。以下是一些从给定的压缩包文件中可以...
常见的二叉树面试题大汇总（涵盖二叉搜索树）
09-05
常见的二叉树面试题大汇总（涵盖二叉搜索树）
刷刷笔试题~！！[二叉树]
nanaMasuda的博客
08-30 1434
1.将一棵有100个结点的完全二叉树从根这一层开始，开始进行层次遍历编号 那么编号最小的叶节点的编号为（根节点为1）  51 解析： 度为0的节点个数为n0，度为1的个数为n1，度为2的个数为n2。 n0=n2+1，n0+n1+n2=100，得到2n2+n1=99。 由于是完全二叉树，所以度为1的有0个或者1个，公式不能有小数， 所有度为2的有49个，度为1的有一个，叶子节点从
与二叉树相关的算法笔试题集
qq_24034545的博客
11-23 295
1. 二叉搜索树（BST）的后序遍历序列 2. 序列化/反序列化二叉树 3. 找到BST中的第k小的数 4. 二叉搜索树转双链表 5. 找出所有节点和满足目标数的路径 6.根据二叉树的前序遍历和中序遍历数组来重建二叉树 7. 判断二叉树是否是平衡二叉树 8. 二叉树的深度 9. 二叉树的镜像 10. 二叉树的下一个结点 11. 对称的二叉树 12. 按之字形顺序打印二叉树 ...
二叉树数常见笔试题汇总（遍历，最大深度，反向构造，共同祖先，对称判断，路经总和，序列化及反序列化操作） c++实现
weixin_42034081的博客
04-18 823
二叉树1.二叉树结构体定义2.反序列化与序列化2.1 反序列化2.2 序列化2.3 层序遍历2.4 测试3. 遍历3.1 前序及测试3.2 中序及测试3.3 后序及测试4.反向构造4.1 由中序和前序反向构造4.2 由中序和后序反向构造 1.二叉树结构体定义 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNod
二叉树相关笔试面试题（一）
xiongluo0628的博客
08-02 458
本博客内容 一、二叉树的结构 二、求二叉树中节点个数 三、求二叉树的第k层的节点个数 四、求二叉树的叶子节点的个数 五、求二叉树的深度 六、二叉树的遍历（前序、中序、后序） 七、层序遍历二叉树（从上到下、从左到右） 八、将二叉搜索树变为有序的双向链表（要求：不创建新节点，只调整指针） 九、判断二叉树是否相同 十、判断二叉树是否是平衡二叉树 一、二叉树的结构 struct B...
网易笔试题：二叉树
Alex-zhai专栏
09-08 964
有一棵二叉树，树上每个点标有权值，权值各不相同，请设计一个算法算出权值最大的叶节点到权值最小的叶节点的距离。二叉树每条边的距离为1，一个节点经过多少条边到达另一个节点为这两个节点之间的距离。 给定二叉树的根节点root，请返回所求距离。思路：分两步 1.找到权值最大的位置和权值最小的位置；2.将它们到最近公共父节点的距离相加就能得到结果。public static int getDis(Tree
二叉树相关算法常见笔试题
weixin_39309402的博客
10-17 1026
创建二叉树上一篇中已经提到：https://blog.csdn.net/weixin_39309402/article/details/101349676 1、如何计算二叉树叶子节点（没有子结点[即度为0]的结点称为叶子结点，简称“叶子”）的个数 // 叶子节点的个数(递归算法) public static int getNodeNumLeafRec(TreeNode root) { i...
二叉搜索树经典笔试题【力扣、牛客】
A progressive ape!
09-16 329
二叉树经典笔试题【C++】
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值