二叉树的基本操作及面试题

最新推荐文章于 2024-04-14 09:19:57 发布
最新推荐文章于 2024-04-14 09:19:57 发布
阅读量444 收藏 1
点赞数 1
分类专栏： C语言 数据结构 文章标签： 二叉树的基本操作 二叉树面试题 二叉树的5性质 完全二叉树 满二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhang21722668/article/details/82190004
版权

1.二叉树概念
二叉树(Binary Tree)是n(n >= 0)个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成。

2.二叉树的特点

  • 每个结点最多有两个子树，所以二叉树中不存在度大于2的结点；注意不是只有两棵子树，而是最多有，没有子树或者由一棵子树都是可以的。
  • 左右子树是有顺序的次序不能任意颠倒。
  • 即使树中摸个结点只有一棵子树，也要区分它是左子树还是右子树。

3.二叉树的基本形态
这里写图片描述

  • （1）空二叉树
  • （2）只有一个根结点
  • （3）根结点只有左子树
  • （4）根结点只有右子树
  • （5）根结点既有左子树又有右子树
    注：因此二叉树由以上5种情况组成。

4.特殊二叉树
【1.斜树】
在这里插入图片描述

顾名思义，斜树一定是要斜的，但往哪斜还是有讲究的；所有结点只有左子树的二叉树叫左斜树，所有结点只有右子树的二叉树叫右斜树，这两者统称为斜树。斜树有很明显的特点，就是每一层都只有一个结点，结点的个数与二叉树的深度相同。

【2.满二叉树】
在这里插入图片描述
在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有的叶子结点都在同一层上，这样的二叉树称为满二叉树。

特点：

  • （1）叶子只能出现在最下一层，出现在其他层就不可能达到平衡。
  • （2）非叶子结点的度一定是2，否则就是“缺胳膊少腿”了。
  • （3）在同样深度的二叉树中，满二叉树的结点个数最多，叶子数最多。

【3.完全二叉树】
在这里插入图片描述
对一棵具有n个结点的二叉树按层序编号，如果编号为i（1 <= i <= n）的结点与同样深度的满二叉树中编号为i的结点在二叉树中的位置完全相同，则这棵二叉树称为完全二叉树。

特点：

  • （1）叶子结点只能出现在最下两层。
  • （2）最下层的叶子一定集中在左部连续位置。
  • （3）倒数第二层，若有叶子结点，一定在右连续位置。
  • （4）如果结点度为1，则该结点只有左孩子，即不存在只有右子树的情况。
  • （5）同样结点的二叉树，完全二叉树的深度最小。

5.二叉树性质

  • 性质1 ：在二叉树的第i层上至多有2^(i-1)个结点（i >= 1）。

  • 性质2 ：深度为k的二叉树至多有2^k -1个结点（i >= 1）。

  • 性质3 ：对任何一棵二叉树T，如果其终端结点为n0,度为2的结点树为n2,则n0 = n2 +1。

  • 性质4 ：具有n个结点的完全二叉树的深度为㏒n +1（此处的㏒n表示不大于它的最大整数）。

  • 性质5 ：如果对一棵有n个结点的完全二叉树的结点按层序编号，对任一结点i（1 <= i <= n）有：

    • 如果 i =1，则结点i是二叉树的根，无双亲；如果 i > 1，则双亲是结点不大于i/2的整数。
    • 如果 2i > n，则结点 i 无左孩子（结点 i 为叶子结点）；否则左孩子是 2i。
    • 如果 2i + 1 > n，则结点 i 无右孩子；否则右孩子为 2i + 1。

6.完整代码块

/************************************/
//BinTree.h


typedef int BDataType;

typedef struct BTNode
{
	struct BTNode *_pLeft;
	struct BTNode *_pRight;
	BDataType data;
}BTNode;


//创建二叉树
void CrateBinTree(BTNode **pRoot, char *str, int size, int *index, BDataType inValid);

//前序遍历二叉树
void PreOrderBinTree(BTNode *pRoot);

//前序遍历二叉树(非递归)
void PreOrderBinTreeNor(BTNode *pRoot);

//中序遍历二叉树
void InOrderBinTree(BTNode *pRoot);

//中序遍历二叉树(非递归)
void InOrderBinTreeNor(BTNode *pRoot);

//后序遍历二叉树
void PostOrderBinTree(BTNode *pRoot);

//后序遍历二叉树(非递归)
void PostOrderBinTreeNor(BTNode *pRoot);

//层序遍历二叉树
void LevelOrderBintree(BTNode *pRoot);

//拷贝二叉树
BTNode *CopyBinTree(BTNode *pRoot);

//销毁二叉树
void DestoryBinTree(BTNode **pRoot);

//求二叉树结点数
int GetBTNodeCount(BTNode *pRoot);

//求叶子结点数
int GetLeafNodeCount(BTNode *pRoot);

//求低K层结点数
int GetKLevelNodeCount(BTNode *pRoot, int k);

//求二叉树的高度
int HeightBinTree(BTNode *pRoot);

//判断一个结点是否在二叉树中
int IsBTNodeBinTree(BTNode*pRoot, BTNode *pNode);

//查找一个结点的双亲结点
BTNode * GetBTNodeParent(BTNode *pRoot, BTNode *pNode);

//判断是否是完全二叉树
int IsCompleteBinTree(BTNode *pRoot);

//二叉树的镜像
void MirrorBinTree(BTNode *pRoot);

//二叉树的镜像（非递归）
void MirrorBinTreeNor(BTNode *pRoot);

//获取一个结点的左孩子结点
BTNode *LeftChild(BTNode *pRoot);

//获取一个结点的右孩子结点
BTNode *RightChild(BTNode *pRoot);



/************************************/
//BinTree.c
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include "LQueue.h"
#include "Stack.h"



void Swap(BTNode **left, BTNode **right)
{
	BTNode *tmp;
	tmp = *left;
	*left = *right;
	*right = tmp;
}


//创建新结点
static BTNode *BuyBTNode(BDataType data)
{
	BTNode *pNewNode;
	pNewNode = (BTNode *)malloc(sizeof(BTNode));
	if (NULL == pNewNode)
	{
		printf("创建新结点失败!\n");
		assert(0);
	}
	pNewNode->data = data;
	pNewNode->_pLeft = NULL;
	pNewNode->_pRight = NULL;
}

//创建二叉树
void CrateBinTree(BTNode **pRoot, char *str, int size, int *index, BDataType invalid)
{
	if (*index < size && invalid != str[*index])
	{
		//创建根结点
		*pRoot = BuyBTNode(str[*index]);
		
		++(*index);
		//创建左子树
		CrateBinTree(&((*pRoot)->_pLeft), str, size, index, invalid);

		++(*index);
		//创建右子树
		CrateBinTree(&((*pRoot)->_pRight), str, size, index, invalid);
	}
}

//前序遍历二叉树
void PreOrderBinTree(BTNode *pRoot)
{
	if (pRoot)
	{
		printf("%c", pRoot->data);
		PreOrderBinTree(pRoot->_pLeft);
		PreOrderBinTree(pRoot->_pRight);
	}
}

//前序遍历二叉树（非递归）
void PreOrderBinTreeNor(BTNode *pRoot)
{
	Stack s;
	BTNode *pCur = NULL;
	if (NULL == pRoot)
		return NULL;

	StackInit(&s);
	StackPush(&s, pRoot);
	while (!StackEmpty(&s))
	{
		pCur = StackTop(&s);
		printf("%c", pCur->data);
		StackPop(&s);
		if (pCur->_pRight)
			StackPush(&s, pCur->_pRight);
		if (pCur->_pLeft)
			StackPush(&s, pCur->_pLeft);
	}
}

//中序遍历二叉树
void InOrderBinTree(BTNode *pRoot)
{
	if (pRoot)
	{
		InOrderBinTree(pRoot->_pLeft);
		printf("%c", pRoot->data);
		InOrderBinTree(pRoot->_pRight);
	}
}

//中序遍历二叉树(非递归)
void InOrderBinTreeNor(BTNode *pRoot)
{
	Stack s;
	BTNode *pCur = pRoot;
	if (NULL == pRoot)
		return;
	StackInit(&s);
	while (!StackEmpty(&s) || pCur)
	{
		while (pCur)
		{
			StackPush(&s, pCur);
			pCur = pCur->_pLeft;
		}

		pCur = StackTop(&s);
		printf("%c", pCur->data);
		StackPop(&s);
		pCur = pCur->_pRight;
	}
}

//后序遍历二叉树
void PostOrderBinTree(BTNode *pRoot)
{
	if (pRoot)
	{
		PostOrderBinTree(pRoot->_pLeft);
		PostOrderBinTree(pRoot->_pRight);
		printf("%c", pRoot->data);
	}
}

//后序遍历二叉树(非递归)
void PostOrderBinTreeNor(BTNode *pRoot)
{
	Stack s;
	BTNode *pTop = NULL;
	BTNode *pPre = NULL;
	BTNode *pCur = pRoot;
	if (NULL == pRoot)
		return;
	StackInit(&s);
	while (!StackEmpty(&s) || pCur)
	{
		while (pCur)
		{
			StackPush(&s, pCur);
			pCur = pCur->_pLeft;
		}

		pTop = StackTop(&s);
		if (NULL == pTop->_pRight || pPre == pTop->_pRight)
		{
			printf("%c", pTop->data);
			pPre = pTop;
			StackPop(&s);
		}
		else
			pCur = pTop->_pRight;
	}
}

//层序遍历
void LevelOrderBintree(BTNode *pRoot)
{
	LQueue q;
	BTNode *pCur = NULL;
	if (NULL == pRoot)
		return;
	LQueueInit(&q);
	LQueuePush(&q, pRoot);
	while (!LQueueEmpty(&q))
	{
		pCur = LQueueTop(&q);
		printf("%c", pCur->data); 
		if (pCur->_pLeft)
			LQueuePush(&q, pCur->_pLeft);
		if (pCur->_pRight)
			LQueuePush(&q, pCur->_pRight);
		LQueuePop(&q);
	}
}

//拷贝二叉树
BTNode *CopyBinTree(BTNode *pRoot)
{
	if (NULL == pRoot)
		return;
	if (pRoot)
		pRoot = BuyBTNode(pRoot->data);
	if (pRoot->_pLeft)
		CopyBinTree(pRoot->_pLeft);
	if (pRoot->_pRight)
		CopyBinTree(pRoot->_pRight);
	return pRoot;
}

//销毁二叉树
void DestoryBinTree(BTNode **pRoot)
{
	if (NULL == *pRoot)
		return;

	DestoryBinTree(&((*pRoot)->_pLeft));
	DestoryBinTree(&((*pRoot)->_pRight));

	free(*pRoot);
	*pRoot = NULL;
}

//求二叉树结点数
int GetBTNodeCount(BTNode *pRoot)
{
	if (NULL == pRoot)
		return 0;
	return GetBTNodeCount(pRoot->_pLeft) + GetBTNodeCount(pRoot->_pRight) + 1;
}

//求叶子结点数
int GetLeafNodeCount(BTNode *pRoot)
{
	if (NULL == pRoot)
		return 0;
	if (NULL == pRoot->_pLeft && NULL == pRoot->_pRight)
		return 1;
	return GetLeafNodeCount(pRoot->_pLeft) + GetLeafNodeCount(pRoot->_pRight);
}

//求低K层结点数
int GetKLevelNodeCount(BTNode *pRoot, int k)
{
	if (NULL == pRoot || 0 == k)
		return 0;
	if (1 == k)
		return 1;
	return GetKLevelNodeCount(pRoot->_pLeft, k - 1) + GetKLevelNodeCount(pRoot->_pRight, k - 1);
}

//求二叉树的高度
int HeightBinTree(BTNode *pRoot)
{
	if (NULL == pRoot)
		return 0;
	return (HeightBinTree(pRoot->_pLeft) > HeightBinTree(pRoot->_pRight)) ? HeightBinTree(pRoot->_pLeft)+1 : HeightBinTree(pRoot->_pRight)+1;
}

//判断一个结点是否在二叉树中
int IsBTNodeBinTree(BTNode*pRoot, BTNode *pNode)
{
	if (NULL == pRoot || NULL == pNode)
		return 0;
	if (pRoot == pNode)
		return 1;
	if (IsBTNodeBinTree(pRoot->_pLeft, pNode))
		return 1;
	return IsBTNodeBinTree(pRoot->_pRight, pNode);
}

//查找一个结点的双亲结点
BTNode * GetBTNodeParent(BTNode *pRoot, BTNode *pNode)
{
	BTNode *Parent = NULL;
	if (NULL == pRoot || NULL == pNode || (NULL == pRoot->_pLeft && NULL == pRoot->_pRight))
		return NULL;
	if (pRoot->_pLeft == pNode || pRoot->_pRight == pNode)
		return pRoot;
	if (Parent = GetBTNodeParent(pRoot->_pLeft, pNode))
		return Parent;
	return GetBTNodeParent(pRoot->_pRight, pNode);
}

//判断是否是完全二叉树
int IsCompleteBinTree(BTNode *pRoot)
{
	LQueue q;
	int flag = 0;
	BTNode *pCur = NULL;
	if (NULL == pRoot)
		return 1;

	LQueueInit(&q);
	LQueuePush(&q, pRoot);
	while (!LQueueEmpty(&q))
	{
		pCur = LQueueTop(&q);
		LQueuePop(&q);
		if (1 == flag)
		{
			if (pCur->_pLeft || pCur->_pRight)
				return 0;
		}

		else
		{
			if (pCur->_pLeft && pCur->_pRight)
			{
				LQueuePush(&q, pCur->_pRight);
				LQueuePush(&q, pCur->_pLeft);
				flag = 0;
			}
			else if (pCur->_pLeft)
			{
				LQueuePush(&q, pCur->_pLeft);
				flag = 1;
			}
			else if (pCur->_pRight)
				return 0;
			else
				flag = 1;
		}
		/*LQueuePop(&q);*/
	}
	return 1;
}

//二叉树的镜像
void MirrorBinTree(BTNode *pRoot)
{
	if (NULL == pRoot)
		return;
	Swap(&pRoot->_pLeft, &pRoot->_pRight);

	if (pRoot->_pLeft)
		MirrorBinTree(pRoot->_pLeft);
	if(pRoot->_pRight)
		MirrorBinTree(pRoot->_pRight);
	
}

//二叉树的镜像（非递归）
void MirrorBinTreeNor(BTNode *pRoot)
{
	LQueue q;
	BTNode *pCur = NULL;
	if (NULL == pRoot)
		return;
	LQueueInit(&q);
	LQueuePush(&q, pRoot);
	while (!LQueueEmpty(&q))
	{
		pCur = LQueueTop(&q);
		printf("%c", pCur->data);
		
		if (pCur->_pLeft)
			LQueuePush(&q, pCur->_pLeft);
		if (pCur->_pRight)
			LQueuePush(&q, pCur->_pRight);
	
		Swap(&pCur->_pLeft, &pCur->_pRight);
		LQueuePop(&q);
	}
}

//获取一个结点的左孩子结点
BTNode *LeftChild(BTNode *pNode)
{
	return (pNode != NULL) ? pNode->_pLeft : NULL;
}

//获取一个结点的右孩子结点
BTNode *RightChild(BTNode *pNode)
{
	return (pNode != NULL) ? pNode->_pRight : NULL;
}


void BinTree()
{
	BTNode *pRoot;
	BTNode *pCP;
	char str[] = "ABD###CE##F";
	int size = strlen(str);
	int index = 0;
	int count = 0;

	CrateBinTree(&pRoot, &str, size, &index, '#');
	
	printf("前序遍历：");
	PreOrderBinTree(pRoot);
	printf("\n");
	printf("前序遍历(非递归)：");
	PreOrderBinTreeNor(pRoot);
	printf("\n");

	printf("中序遍历：");
	InOrderBinTree(pRoot);
	printf("\n");
	printf("中序遍历(非递归):");
	InOrderBinTreeNor(pRoot);
	printf("\n");

	printf("后序遍历：");
	PostOrderBinTree(pRoot);
	printf("\n");
	printf("后序遍历(非递归):");
	PostOrderBinTreeNor(pRoot);
	printf("\n");

	printf("层序遍历：");
	LevelOrderBintree(pRoot);
	printf("\n");


	printf("MirrorBinTree:");
	MirrorBinTree(pRoot);
	PreOrderBinTree(pRoot);
	printf("\n");
	printf("MirrorBinTreeNor:");
	MirrorBinTreeNor(pRoot);
	//PreOrderBinTree(pRoot);
	printf("\n");
	

	pCP = CopyBinTree(pRoot);
	printf("CopyBinTree:");
	PreOrderBinTree(pRoot);
	printf("\n");


	printf("二叉树结点数 = %d\n", GetBTNodeCount(pRoot));
	printf("二叉树叶子结点数 = %d\n", GetLeafNodeCount(pRoot));
	printf("第K层结点数 = %d\n", GetKLevelNodeCount(pRoot, 3));
	printf("二叉树高度 = %d\n", HeightBinTree(pRoot));

	printf("%c\n", GetBTNodeParent(pRoot, 'B'));

	if (IsCompleteBinTree(pRoot))
		printf("是一个完全二叉树\n");
	else 
		printf("不是一个完全二叉树\n");

	if (IsBTNodeBinTree(pRoot, 'B'))
		printf("该结点在二叉树中\n");
	else
		printf("该结点不在二叉树中\n");


	DestoryBinTree(&pRoot);
}
C__zhang
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树面试题 树和二叉树总结.doc
02-24
"二叉树面试题 树和二叉树总结" 本资源摘要信息涵盖了树和二叉树的面试题总结，包括选择题和解释。涵盖的知识点包括树和二叉树的定义、性质、操作和应用等。 一、树和二叉树的定义 树是一种数据结构，由一个根...
面经 常见数据结构的算法 - 二叉树
lyu00002的博客
03-09 784
1.算法 二叉树二叉树分满二叉树、完全二叉树、平衡二叉树、红黑树。满二叉树：除最后一层外，每一层都有两个节点。完全二叉树：除最后一层外，每一层节点数都达到最大值，且缺少最右边的节点平衡二叉树：本质上是二叉树查找树，只不过是为了防止退化成链表加入了平衡，也就是平衡因子保证是一个平衡的二叉树。红黑树：本质上也是二叉查找树，加入了红黑节点保证其实平衡的。二叉树：(1)遍历方式前序遍历、中序遍历、后序遍历...
【数据结构】二叉树面试题总结(持续更新中...)
weixin_44258092的博客
08-10 1109
总结了二叉树的相关习题。
二叉树的实现、遍历及面试题(1)，2024年最新携程前端面试难吗
最新发布
m0_61369275的博客
04-14 675
其实前端开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。这里再分享一个复习的路线：（以下体系的复习资料是我从各路大佬收集整理好的）《前端开发四大模块核心知识笔记》最后，说个题外话，我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。
【数据结构】这些二叉树经典面试题帮你快速入门二叉树
Living_Amethyst的博客
06-27 1390
二叉树入门到精通
十道二叉树面试题，对二叉树理解更进一步
weixin_46016019的博客
05-06 2860
学习二叉树有一个很重要的思想就是分治（将一个大问题划分为最小规模的子问题），常用方法之一就是递归，而递归是很抽象的，当对递归过程不理解时，建议多画图将递归过程实例化，拒绝人脑压栈...
二叉树面试题
08-28
以下是一些关于二叉树的常见面试题及解题思路： 1. **定义与基本术语**： - 二叉树是每个节点最多有两个子节点的树结构，通常分为左子节点和右子节点。 - 节点包含一个值，可能有零个、一个或两个子节点。 - ...
面试题68 – II. 二叉树的最近公共祖先
01-06
面试题68 – II. 二叉树的最近公共祖先 【简单题】【递归】 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个...
【面试题8】二叉树的下一个节点
01-06
Python解法 思路：脑中构造出一个树。 1.左子树为父节点； 2.如果一个节点有右子树，下一个节点为右子树的最左结点； 3.如果一个节点无右子树，且为父节点的左子结点，下一个节点为父节点； 4.如果为父节点的右子...
剑指offer面试题（7）——重建二叉树
06-14
【重建二叉树】是计算机科学中一个经典的数据结构问题，主要出现在算法和数据结构的面试中，尤其在像《剑指Offer》这样的面试指南中经常出现。这道题目要求根据给定的前序遍历和中序遍历序列来重建原始的二叉树结构...
二叉树中常见的面试题
飞翔的熊blabla
07-08 500
1用一个函数判断一棵树是否平衡 题目：实现一个函数检查一棵树是否平衡。对于这个问题而言， 平衡指的是这棵树任意两个叶子结点到根结点的距离之差不大于1。 注意，对于这道题，要审清题意。它并不是让你判断一棵树是否为平衡二叉树。平衡二叉树的定义为：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1， 并且左右两个子树都是一棵平衡二叉树。 而本题的平衡指的是这棵树任意两个叶子结点到根结点的距离之差不大于1。（程序员面试金典） 思路： 对于本题，只需要求出离根结点最近和最远的叶子结点， 然后看它们到根结.
二叉树面试题（高频）
m0_64130230的博客
03-22 2714
目录 1. 检查两颗树是否相同 1.1题目描述 1.2思考过程 1.3代码 2. 另一颗树的子树 2.1题目描述 2.2思考过程 2.3代码 3. 二叉树最大深度 3.1题目描述 3.2思考过程 3.3代码 4. 判断一颗二叉树是否是平衡二叉树 4.1题目描述 4.2思考过程 4.3代码 5. 对称二叉树 5.1题目描述 5.2思考过程 5.3代码 6.二叉树的分层遍历 6.1题目描述 6.2思考过程 6.3代码 7.二叉树的构建及遍历 7.1题目...
【数据结构】二叉树常见面试题
如风逝去
08-07 6049
1、创建二叉树 树的结构如下： 这里我们创建二叉树用的是静态创建即不是每次从标准输入读入数据然后插入树中，而是将定义好的一个序列，也就是一个数组构建一棵树，这里采用的是递归创建，首先来看一下参数，首先传进来的就是根结点，然后是要构建树的序列然后是数组下标索引，负责遍历整个数组，然后是数组的大小，然后是无效值，遇到无效值表示当前结点为空，就返回上一层函数调用，递归程序的出口是index...
二叉树的五道面试题
LLZK_的博客
11-30 6172
1、判断一棵树是否是完全二叉树； 2、求二叉树中最远两个结点的距离； 3、由前序和中序遍历序列重建二叉树 （前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6 5）； 4、求二叉树两个结点的最近公共祖先； 5、将二叉搜索树转化成有序的双向链表； 判断一棵树是否是完全二叉树 要想判断一颗树是否是完全二叉树，你得先知道什么是完全二叉树。 完全二
二叉树超全面试题，涵盖各类题型，刷题看这就够啦！（超详细版本 附解题思路+代码）
广西彭于晏的博客
04-21 156
二叉树面试题超详细版本1.根据二叉树创建字符串题目题解代码实现2.二叉树的层序遍历1题目题解代码实现3.二叉树的层序遍历2题目题解4.二叉树的最近公共祖先题目题解1.暴力法逻辑代码实现时间复杂度分析2.找路径法逻辑代码实现时间复杂度3.遍历法逻辑代码实现时间复杂度5.二叉树搜索树转换成排序双向链表题目题解代码实现：6.根据一棵树的前序遍历与中序遍历构造二叉树题目题解代码实现7.根据一棵树的中序遍历与后序遍历构造二叉树题目题解代码实现8.二叉树的前序遍历，非递归迭代实现题目题解9.二叉树中序遍历 ，非递归迭代
二叉树常见的面试题
weixin_41218106的博客
11-19 198
typedef struct tree { struct tree*left, *right; int val; }tree; //方法2: bool isBalanceBinaryTree(tree*root, int*depth) { if (root == NULL) { *depth = 0; return true; } int left; int right...
别再翻了，面试二叉树看这 11 个就够了~
热门推荐
小鹿动画学编程
09-13 12万+
写在前边 数据结构与算法： 不知道你有没有这种困惑，虽然刷了很多算法题，当我去面试的时候，面试官让你手写一个算法，可能你对此算法很熟悉，知道实现思路，但是总是不知道该在什么地方写，而且很多边界条件想不全面，一紧张，代码写的乱七八糟。如果遇到没有做过的算法题，思路也不知道从何寻找。面试吃了亏之后，我就慢慢的做出总结，开始分类的把数据结构所有的题型和解题思路每周刷题做出的系统性总结写在了 Github...
leetcode二叉树面试题目集锦
xiangxianghehe的博客
08-18 6880
struct BinaryTreeNode { int value; BinaryTreeNode* left; BinaryTreeNode* right; BinaryTreeNode(int x) : value(x), left(NULL), right(NULL) {} }; 初始化 BinaryTreeNode *root = new ...
Python面试题及答案共48道.docx
07-25
本段描述主要围绕Python面试题及答案共48道、找出两个列表中相同的元素和不同的元素、二叉树与线性结构的区别、对列表进行大小写无关排序以及字典中items()方法和iteritems()方法的区别展开。 首先，本文提到Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值