关于二叉树遍历及二叉树面试题目，2024年最新阿里面试官必问

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注Android）

正文

题目列表：

1. 求二叉树中的节点个数

**2. 求二叉树的深度

3. 前序遍历，中序遍历，后序遍历

4.分层遍历二叉树（按层次从上往下，从左往右）

5. 将二叉查找树变为有序的双向链表

6. 求二叉树第K层的节点个数

7. 求二叉树中叶子节点的个数

8. 判断两棵二叉树是否结构相同

9. 判断二叉树是不是平衡二叉树

10. 求二叉树的镜像

11. 求二叉树中两个节点的最低公共祖先节点

12. 求二叉树中节点的最大距离

13. 由前序遍历序列和中序遍历序列重建二叉树

14.判断二叉树是不是完全二叉树**

详细解答

1. 求二叉树中的节点个数

递归解法：

（1）如果二叉树为空，节点个数为0

（2）如果二叉树不为空，二叉树节点个数 = 左子树节点个数 + 右子树节点个数 + 1

参考代码如下：

[cpp]  view plain  copy

1. int GetNodeNum(BinaryTreeNode * pRoot)

2. {

3. if(pRoot == NULL) // 递归出口

4. return 0;

5. return GetNodeNum(pRoot->m_pLeft) + GetNodeNum(pRoot->m_pRight) + 1;

6. }

2. 求二叉树的深度

递归解法：

（1）如果二叉树为空，二叉树的深度为0

（2）如果二叉树不为空，二叉树的深度 = max(左子树深度， 右子树深度) + 1

参考代码如下：

[cpp]  view plain  copy

1. int GetDepth(BinaryTreeNode * pRoot)

2. {

3. if(pRoot == NULL) // 递归出口

4. return 0;

5. int depthLeft = GetDepth(pRoot->m_pLeft);

6. int depthRight = GetDepth(pRoot->m_pRight);

7. return depthLeft > depthRight ? (depthLeft + 1) : (depthRight + 1);

8. }

3. 前序遍历，中序遍历，后序遍历

前序遍历递归解法：

（1）如果二叉树为空，空操作

（2）如果二叉树不为空，访问根节点，前序遍历左子树，前序遍历右子树

参考代码如下：

[cpp]  view plain  copy

1. void PreOrderTraverse(BinaryTreeNode * pRoot)

2. {

3. if(pRoot == NULL)

4. return;

5. Visit(pRoot); // 访问根节点

6. PreOrderTraverse(pRoot->m_pLeft); // 前序遍历左子树

7. PreOrderTraverse(pRoot->m_pRight); // 前序遍历右子树

8. }

中序遍历递归解法

（1）如果二叉树为空，空操作。

（2）如果二叉树不为空，中序遍历左子树，访问根节点，中序遍历右子树

参考代码如下：

[cpp]  view plain  copy

1. void InOrderTraverse(BinaryTreeNode * pRoot)

2. {

3. if(pRoot == NULL)

4. return;

5. InOrderTraverse(pRoot->m_pLeft); // 中序遍历左子树

6. Visit(pRoot); // 访问根节点

7. InOrderTraverse(pRoot->m_pRight); // 中序遍历右子树

8. }

后序遍历递归解法

（1）如果二叉树为空，空操作

（2）如果二叉树不为空，后序遍历左子树，后序遍历右子树，访问根节点

参考代码如下：

[cpp]  view plain  copy

1. void PostOrderTraverse(BinaryTreeNode * pRoot)

2. {

3. if(pRoot == NULL)

4. return;

5. PostOrderTraverse(pRoot->m_pLeft); // 后序遍历左子树

6. PostOrderTraverse(pRoot->m_pRight); // 后序遍历右子树

7. Visit(pRoot); // 访问根节点

8. }

4.分层遍历二叉树（按层次从上往下，从左往右）

相当于广度优先搜索，使用队列实现。队列初始化，将根节点压入队列。当队列不为空，进行如下操作：弹出一个节点，访问，若左子节点或右子节点不为空，将其压入队列。

[cpp]  view plain  copy

1. void LevelTraverse(BinaryTreeNode * pRoot)

2. {

3. if(pRoot == NULL)

4. return;

5. queue<BinaryTreeNode *> q;

6. q.push(pRoot);

7. while(!q.empty())

8. {

9. BinaryTreeNode * pNode = q.front();

10. q.pop();

11. Visit(pNode); // 访问节点

12. if(pNode->m_pLeft != NULL)

13. q.push(pNode->m_pLeft);

14. if(pNode->m_pRight != NULL)

15. q.push(pNode->m_pRight);

16. }

17. return;

18. }

5. 将二叉查找树变为有序的双向链表

要求不能创建新节点，只调整指针。

递归解法：

（1）如果二叉树查找树为空，不需要转换，对应双向链表的第一个节点是NULL，最后一个节点是NULL

（2）如果二叉查找树不为空：

如果左子树为空，对应双向有序链表的第一个节点是根节点，左边不需要其他操作；

如果左子树不为空，转换左子树，二叉查找树对应双向有序链表的第一个节点就是左子树转换后双向有序链表的第一个节点，同时将根节点和左子树转换后的双向有序链  表的最后一个节点连接；

如果右子树为空，对应双向有序链表的最后一个节点是根节点，右边不需要其他操作；

如果右子树不为空，对应双向有序链表的最后一个节点就是右子树转换后双向有序链表的最后一个节点，同时将根节点和右子树转换后的双向有序链表的第一个节点连  接。

参考代码如下：

[cpp]  view plain  copy

1. /******************************************************************************

2. 参数：

3. pRoot: 二叉查找树根节点指针

4. pFirstNode: 转换后双向有序链表的第一个节点指针

5. pLastNode: 转换后双向有序链表的最后一个节点指针

6. ******************************************************************************/

7. void Convert(BinaryTreeNode * pRoot,

8. BinaryTreeNode * & pFirstNode, BinaryTreeNode * & pLastNode)

9. {

10. BinaryTreeNode *pFirstLeft, *pLastLeft, * pFirstRight, *pLastRight;

11. if(pRoot == NULL)

12. {

13. pFirstNode = NULL;

14. pLastNode = NULL;

15. return;

16. }

17. if(pRoot->m_pLeft == NULL)

18. {

19. // 如果左子树为空，对应双向有序链表的第一个节点是根节点

20. pFirstNode = pRoot;

21. }

22. else

23. {

24. Convert(pRoot->m_pLeft, pFirstLeft, pLastLeft);

25. // 二叉查找树对应双向有序链表的第一个节点就是左子树转换后双向有序链表的第一个节点

26. pFirstNode = pFirstLeft;

27. // 将根节点和左子树转换后的双向有序链表的最后一个节点连接

28. pRoot->m_pLeft = pLastLeft;

29. pLastLeft->m_pRight = pRoot;

30. }

31. if(pRoot->m_pRight == NULL)

32. {

33. // 对应双向有序链表的最后一个节点是根节点

34. pLastNode = pRoot;

35. }

36. else

37. {

38. Convert(pRoot->m_pRight, pFirstRight, pLastRight);

39. // 对应双向有序链表的最后一个节点就是右子树转换后双向有序链表的最后一个节点

40. pLastNode = pLastRight;

41. // 将根节点和右子树转换后的双向有序链表的第一个节点连接

42. pRoot->m_pRight = pFirstRight;

43. pFirstRight->m_pLeft = pRoot;

44. }

45. return;

46. }

6. 求二叉树第K层的节点个数

递归解法：

（1）如果二叉树为空或者k<1返回0

（2）如果二叉树不为空并且k==1，返回1

（3）如果二叉树不为空且k>1，返回左子树中k-1层的节点个数与右子树k-1层节点个数之和

参考代码如下：

[cpp]  view plain  copy

1. int GetNodeNumKthLevel(BinaryTreeNode * pRoot, int k)

2. {

3. if(pRoot == NULL || k < 1)

4. return 0;

5. if(k == 1)

6. return 1;

7. int numLeft = GetNodeNumKthLevel(pRoot->m_pLeft, k-1); // 左子树中k-1层的节点个数

8. int numRight = GetNodeNumKthLevel(pRoot->m_pRight, k-1); // 右子树中k-1层的节点个数

9. return (numLeft + numRight);

10. }

7. 求二叉树中叶子节点的个数

递归解法：

（1）如果二叉树为空，返回0

（2）如果二叉树不为空且左右子树为空，返回1

（3）如果二叉树不为空，且左右子树不同时为空，返回左子树中叶子节点个数加上右子树中叶子节点个数

参考代码如下：

[cpp]  view plain  copy

1. int GetLeafNodeNum(BinaryTreeNode * pRoot)

2. {

3. if(pRoot == NULL)

4. return 0;

5. if(pRoot->m_pLeft == NULL && pRoot->m_pRight == NULL)

6. return 1;

7. int numLeft = GetLeafNodeNum(pRoot->m_pLeft); // 左子树中叶节点的个数

8. int numRight = GetLeafNodeNum(pRoot->m_pRight); // 右子树中叶节点的个数

9. return (numLeft + numRight);

10. }

8. 判断两棵二叉树是否结构相同

不考虑数据内容。结构相同意味着对应的左子树和对应的右子树都结构相同。

递归解法：

（1）如果两棵二叉树都为空，返回真

（2）如果两棵二叉树一棵为空，另一棵不为空，返回假

（3）如果两棵二叉树都不为空，如果对应的左子树和右子树都同构返回真，其他返回假

参考代码如下：

[cpp]  view plain  copy

1. bool StructureCmp(BinaryTreeNode * pRoot1, BinaryTreeNode * pRoot2)

2. {

3. if(pRoot1 == NULL && pRoot2 == NULL) // 都为空，返回真

4. return true;

5. else if(pRoot1 == NULL || pRoot2 == NULL) // 有一个为空，一个不为空，返回假

6. return false;

7. bool resultLeft = StructureCmp(pRoot1->m_pLeft, pRoot2->m_pLeft); // 比较对应左子树

8. bool resultRight = StructureCmp(pRoot1->m_pRight, pRoot2->m_pRight); // 比较对应右子树

9. return (resultLeft && resultRight);

10. }

9. 判断二叉树是不是平衡二叉树

递归解法：

（1）如果二叉树为空，返回真

（2）如果二叉树不为空，如果左子树和右子树都是AVL树并且左子树和右子树高度相差不大于1，返回真，其他返回假

参考代码：

[cpp]  view plain  copy

1. bool IsAVL(BinaryTreeNode * pRoot, int & height)

2. {

3. if(pRoot == NULL) // 空树，返回真

4. {

5. height = 0;

6. return true;

7. }

8. int heightLeft;

9. bool resultLeft = IsAVL(pRoot->m_pLeft, heightLeft);

10. int heightRight;

11. bool resultRight = IsAVL(pRoot->m_pRight, heightRight);

12. if(resultLeft && resultRight && abs(heightLeft - heightRight) <= 1) // 左子树和右子树都是AVL，并且高度相差不大于1，返回真

13. {

14. height = max(heightLeft, heightRight) + 1;

15. return true;

16. }

17. else

18. {

19. height = max(heightLeft, heightRight) + 1;

20. return false;

21. }

22. }

10. 求二叉树的镜像

递归解法：

（1）如果二叉树为空，返回空

（2）如果二叉树不为空，求左子树和右子树的镜像，然后交换左子树和右子树

参考代码如下：

[cpp]  view plain  copy

1. BinaryTreeNode * Mirror(BinaryTreeNode * pRoot)

2. {

3. if(pRoot == NULL) // 返回NULL

4. return NULL;

5. BinaryTreeNode * pLeft = Mirror(pRoot->m_pLeft); // 求左子树镜像

6. BinaryTreeNode * pRight = Mirror(pRoot->m_pRight); // 求右子树镜像

7. // 交换左子树和右子树

8. pRoot->m_pLeft = pRight;

9. pRoot->m_pRight = pLeft;

10. return pRoot;

11. }

11. 求二叉树中两个节点的最低公共祖先节点

递归解法：

（1）如果两个节点分别在根节点的左子树和右子树，则返回根节点

（2）如果两个节点都在左子树，则递归处理左子树；如果两个节点都在右子树，则递归处理右子树

参考代码如下：

[cpp]  view plain  copy

1. bool FindNode(BinaryTreeNode * pRoot, BinaryTreeNode * pNode)

2. {

3. if(pRoot == NULL || pNode == NULL)

4. return false;

5. if(pRoot == pNode)

6. return true;

7. bool found = FindNode(pRoot->m_pLeft, pNode);

8. if(!found)

9. found = FindNode(pRoot->m_pRight, pNode);

10. return found;

11. }

12. BinaryTreeNode * GetLastCommonParent(BinaryTreeNode * pRoot,

13. BinaryTreeNode * pNode1,

14. BinaryTreeNode * pNode2)

15. {

16. if(FindNode(pRoot->m_pLeft, pNode1))

17. {

18. if(FindNode(pRoot->m_pRight, pNode2))

19. return pRoot;

20. else

21. return GetLastCommonParent(pRoot->m_pLeft, pNode1, pNode2);

22. }

23. else

24. {

25. if(FindNode(pRoot->m_pLeft, pNode2))

26. return pRoot;

27. else

28. return GetLastCommonParent(pRoot->m_pRight, pNode1, pNode2);

29. }

30. }

递归解法效率很低，有很多重复的遍历，下面看一下非递归解法。

非递归解法：

先求从根节点到两个节点的路径，然后再比较对应路径的节点就行，最后一个相同的节点也就是他们在二叉树中的最低公共祖先节点

参考代码如下：

[cpp]  view plain  copy

1. bool GetNodePath(BinaryTreeNode * pRoot, BinaryTreeNode * pNode,

2. list<BinaryTreeNode *> & path)

3. {

4. if(pRoot == pNode)

5. {

6. path.push_back(pRoot);

7. return true;

8. }

9. if(pRoot == NULL)

10. return false;

11. path.push_back(pRoot);

12. bool found = false;

13. found = GetNodePath(pRoot->m_pLeft, pNode, path);

14. if(!found)

15. found = GetNodePath(pRoot->m_pRight, pNode, path);

16. if(!found)

17. path.pop_back();

18. return found;

19. }

20. BinaryTreeNode * GetLastCommonParent(BinaryTreeNode * pRoot, BinaryTreeNode * pNode1, BinaryTreeNode * pNode2)

21. {

22. if(pRoot == NULL || pNode1 == NULL || pNode2 == NULL)

23. return NULL;

24. list<BinaryTreeNode*> path1;

25. bool bResult1 = GetNodePath(pRoot, pNode1, path1);

26. list<BinaryTreeNode*> path2;

27. bool bResult2 = GetNodePath(pRoot, pNode2, path2);

28. if(!bResult1 || !bResult2)

29. return NULL;

30. BinaryTreeNode * pLast = NULL;

31. list<BinaryTreeNode*>::const_iterator iter1 = path1.begin();

32. list<BinaryTreeNode*>::const_iterator iter2 = path2.begin();

33. while(iter1 != path1.end() && iter2 != path2.end())

34. {

35. if(*iter1 == *iter2)

36. pLast = *iter1;

37. else

38. break;

39. iter1++;

40. iter2++;

41. }

42. return pLast;

43. }

在上述算法的基础上稍加变化即可求二叉树中任意两个节点的距离了。

12. 求二叉树中节点的最大距离

即二叉树中相距最远的两个节点之间的距离。

递归解法：

（1）如果二叉树为空，返回0，同时记录左子树和右子树的深度，都为0

（2）如果二叉树不为空，最大距离要么是左子树中的最大距离，要么是右子树中的最大距离，要么是左子树节点中到根节点的最大距离+右子树节点中到根节点的最大距离，同时记录左子树和右子树节点中到根节点的最大距离。

参考代码如下：

[cpp]  view plain  copy

1. int GetMaxDistance(BinaryTreeNode * pRoot, int & maxLeft, int & maxRight)

2. {

3. // maxLeft, 左子树中的节点距离根节点的最远距离

4. // maxRight, 右子树中的节点距离根节点的最远距离

5. if(pRoot == NULL)

6. {

7. maxLeft = 0;

8. maxRight = 0;

9. return 0;

10. }

11. int maxLL, maxLR, maxRL, maxRR;

12. int maxDistLeft, maxDistRight;

13. if(pRoot->m_pLeft != NULL)

14. {

15. maxDistLeft = GetMaxDistance(pRoot->m_pLeft, maxLL, maxLR);

16. maxLeft = max(maxLL, maxLR) + 1;

17. }

18. else

19. {

20. maxDistLeft = 0;

21. maxLeft = 0;

22. }

23. if(pRoot->m_pRight != NULL)

24. {

25. maxDistRight = GetMaxDistance(pRoot->m_pRight, maxRL, maxRR);

26. maxRight = max(maxRL, maxRR) + 1;

27. }

28. else

29. {

30. maxDistRight = 0;

31. maxRight = 0;

32. }

33. return max(max(maxDistLeft, maxDistRight), maxLeft+maxRight);

34. }

13. 由前序遍历序列和中序遍历序列重建二叉树

二叉树前序遍历序列中，第一个元素总是树的根节点的值。中序遍历序列中，左子树的节点的值位于根节点的值的左边，右子树的节点的值位

重要知识点

下面是有几位Android行业大佬对应上方技术点整理的一些进阶资料。

高级进阶篇——高级UI，自定义View（部分展示）

UI这块知识是现今使用者最多的。当年火爆一时的Android入门培训，学会这小块知识就能随便找到不错的工作了。不过很显然现在远远不够了，拒绝无休止的CV,亲自去项目实战，读源码，研究原理吧！

• 面试题部分合集
  

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

R) + 1;

27. }

28. else

29. {

30. maxDistRight = 0;

31. maxRight = 0;

32. }

33. return max(max(maxDistLeft, maxDistRight), maxLeft+maxRight);

34. }

13. 由前序遍历序列和中序遍历序列重建二叉树

二叉树前序遍历序列中，第一个元素总是树的根节点的值。中序遍历序列中，左子树的节点的值位于根节点的值的左边，右子树的节点的值位

重要知识点

下面是有几位Android行业大佬对应上方技术点整理的一些进阶资料。

[外链图片转存中…(img-nd5vpObD-1713100525075)]

高级进阶篇——高级UI，自定义View（部分展示）

UI这块知识是现今使用者最多的。当年火爆一时的Android入门培训，学会这小块知识就能随便找到不错的工作了。不过很显然现在远远不够了，拒绝无休止的CV,亲自去项目实战，读源码，研究原理吧！

[外链图片转存中…(img-jx2gDtlX-1713100525075)]

• 面试题部分合集
  [外链图片转存中…(img-5GAyMzAC-1713100525075)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-jlC6NRFr-1713100525076)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！