二叉树相关面试题

最新推荐文章于 2024-09-23 21:07:30 发布
原创 最新推荐文章于 2024-09-23 21:07:30 发布 · 480 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 

<pre name="code" class="html">/******************************************************************************************
Copyright (c) Inc.(2013), All rights reserved.

Purpose: 实现二叉树的基本面试题    

Author: MaJing

Reviser: yyy

Created Time: 2016-9-5
******************************************************************************************/


// ps:1-6题在在二叉树基础部分已经实现
//1. 前序/中序/后序遍历
//2. 层序遍历
//3. 求二叉树的高度
//4. 求叶子节点的个数
//5. 求二叉树第k层的节点个数
//6. 判断一个节点是否在一棵二叉树中
//7. 求两个节点的最近公共祖先
//8. 判断一棵二叉树是否是平衡二叉树
//9. 求二叉树中最远的两个节点的距离
//10. 由前序遍历和中序遍历重建二叉树（前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 5 6）
//11. 判断一棵树是否是完全二叉树
//12. 求二叉树的镜像【y】
//13. 将二叉搜索树转换为双向链表


#pragma once

#include<iostream>
#include<vector>
#include<queue>
#include<stack>
using namespace std;

//
// 定义以下结构仅用于二叉树笔试面试题进行测试。
//
typedef int DataType;

struct BinaryTreeTopic
{
	struct BinaryTreeNode
	{
		DataType _data;				// 结点数据
		BinaryTreeNode* _left;		// 左子树
		BinaryTreeNode* _right;		// 右子树

		BinaryTreeNode(int data)
			:_data(data)
			,_left(0)
			,_right(0)
		{}
	};

	void CreateBinaryTree(BinaryTreeNode*& root, const vector<DataType>& vDatas, int& i)
	{
		// 前序遍历创建二叉树
		if(i < vDatas.size() && vDatas[i] !=  '#')
		{
			root = new BinaryTreeNode(vDatas[i]);
			CreateBinaryTree(root->_left, vDatas, ++i);
			CreateBinaryTree(root->_right, vDatas, ++i);
		}
	}

	BinaryTreeNode* Find(BinaryTreeNode* root, DataType x)
	{
		BinaryTreeNode* ret;
		if (root == NULL)
			return NULL;

		if (root->_data == x)
			return root;

		if (ret = Find(root->_left, x))
			return ret;

		if (ret = Find(root->_right, x))
			return ret;

		return NULL;
	}

	// 前序/中序/后序遍历
	void PrevOrder(BinaryTreeNode* root)
	{
		if (root)
		{
			cout<<root->_data<<" ";
			PrevOrder(root->_left);
			PrevOrder(root->_right);
		}
	}

	void InOrder(BinaryTreeNode* root)
	{
		if (root)
		{
			InOrder(root->_left);
			cout<<root->_data<<" ";
			InOrder(root->_right);
		}
	}

	void PostOrder(BinaryTreeNode* root)
	{
		if (root)
		{
			PostOrder(root->_left);
			PostOrder(root->_right);

			cout<<root->_data<<" ";
		}
	}

	// 判断一个节点是否在一棵树中
	bool IsInTree(BinaryTreeNode* root, BinaryTreeNode* node)
	{
		if (root == NULL)
			return false;

		if(node == root)
			return true;

		if (IsInTree(root->_left, node) || IsInTree(root->_right, node))
			return true;

		return false;
	}

	// 求两个节点的最近公共祖先 -- O(N^2)
	//
	// 1.如果一个节点为根结点，另一个节点在一个子树中，则根节点为祖先节点。
	// 2.如果一个节点在左子树，另一个节点在右子树，则当前根节点即为祖先节点。
	// 3.如果两个均在左子树或右子树，则转化为子问题，在子树使用递归求解。
	//
	BinaryTreeNode* GetCommontAncestor(BinaryTreeNode* root,
		BinaryTreeNode* x1, BinaryTreeNode* x2)
	{
		// 1.如果一个节点为根结点，另一个节点在一个子树中，则根节点为祖先节点。
		if(root == x1 && IsInTree(root, x2))
		{
			return root;
		}
		if (root == x2 && IsInTree(root, x1))
		{
			return root;
		}

		// 2.如果一个节点在左子树，另一个节点在右子树，则当前根节点即为祖先节点。
		bool x1InLeft = false, x2InLeft = false, x1InRight = false, x2InRight = false;
		x1InLeft = IsInTree(root->_left, x1);
		x2InRight = IsInTree(root->_right, x2);
		if (x1InLeft&&x2InRight)
		{
			return root;
		}

		x1InRight = IsInTree(root->_right, x1);
		x2InLeft = IsInTree(root->_left, x2);

		if (x1InLeft && x2InRight)
		{
			return root;
		}

		// 3.如果两个均在左子树或右子树，则转化为子问题，在子树使用递归求解。
		if (x1InLeft && x2InLeft)
		{
			return GetCommontAncestor(root->_left, x1, x2);
		}
		if (x1InRight && x2InRight)
		{
			return GetCommontAncestor(root->_right, x1, x2);
		}

		return NULL;
	}

	// 优化
	bool GetNodePath(BinaryTreeNode* root, 
					 vector<BinaryTreeNode*>& s,
					 BinaryTreeNode* x)
	{
		if (root)
		{
			// 节点入数据
			s.push_back(root);

			// 找到节点则返回true
			if (root == x)
				return true;

			// 分别查找左右子树
			if(GetNodePath(root->_left, s, x))
				return true;

			if (GetNodePath(root->_right, s, x))
				return true;

			// 左右子树均没有找到，则出数据。
			s.pop_back();
		}

		return false;
	}

	// 优化 -- 时间复杂度O(N)
	BinaryTreeNode* GetCommontAncestor_OP(BinaryTreeNode* root,
										  BinaryTreeNode* x1, BinaryTreeNode* x2)
	{
		// 获取两个节点的查找路径
		vector<BinaryTreeNode*> s1;
		vector<BinaryTreeNode*> s2;
		GetNodePath(root, s1, x1);
		GetNodePath(root, s2, x2);

		// stack这里不能遍历，所以使用list/vector.
		// 找顺序表中从开始最后一个相同的数据则是最近公共祖先
		size_t i = 0;
		while (i < s1.size() && i < s2.size())
		{
			if (s1[i] == s2[i])
				++i;
			else
				break;
		}

		--i;

		if (i != 0)
			return s1[i];
		else
			return NULL;
	}

	int GetHeight(BinaryTreeNode* root)
	{
		if (root == NULL)
			return 0;
		
		int left = GetHeight(root->_left);
		int right = GetHeight(root->_right);

		return left > right ? left+1 : right+1;
	}

	// O(N^2)
	// 判断一棵二叉树是否是平衡树（AVL树的规则）
	bool IsBalance(BinaryTreeNode* root)
	{
		if (root == NULL || (root->_left == NULL && root->_right == NULL))
		{
			return true;
		}

		// 1.判断当前树是否为平衡树
		int leftH = GetHeight(root->_left);
		int rightH = GetHeight(root->_right);

		int interval = leftH - rightH;
		if (interval > 1 || interval < -1)
		{
			return false;
		}

		// 2.判断左右子树是否为平衡树
		return IsBalance(root->_left) && IsBalance(root->_right);
	}

	// 优化 -- O(N)
	bool IsBalance_OP(BinaryTreeNode* root, int& height)
	{
		// 1.判断当前树是否是平衡树
		if (root == NULL)
		{
			height = 0;
			return true;
		}

		if (root->_left == NULL && root->_right == NULL)
		{
			height = 1;
			return true;
		}

		// 2.判断左右子树是否是平衡树，并算出左右子树的高度，通过高度判断当前树是否是平衡树
		int leftH = 0;
		int rightH = 0;
		if(IsBalance_OP(root->_right, rightH) && IsBalance_OP(root->_left, leftH))
		{
			int interval = leftH - rightH;
			if (interval <= 1 && interval >= -1)
			{
				height = leftH > rightH ? leftH : rightH;
				height += 1;
				return true;
			}
			else
			{
				return false;
			}
		}

		return false;
	}


	// 9.求一棵二叉树中最远节点的距离 O(N^2)
	void FindMaxLen(BinaryTreeNode* root, int& maxLen)
	{
		if (root == NULL)
		{
			maxLen = 0;
			return;
		}

		int l = GetHeight(root->_left); 
		int r = GetHeight(root->_right);

		if (maxLen < l + r)
		{
			maxLen = l + r;
		}

		FindMaxLen_OP(root->_left, maxLen);
		FindMaxLen_OP(root->_right, maxLen);
	}

	// 优化O(N)
	int FindMaxLen_OP(BinaryTreeNode* root, int& maxLen)
	{
		if (root == NULL)
		{
			maxLen = 0;
			return -1;
		}

		int l = FindMaxLen_OP(root->_left, maxLen) + 1; 
		int r = FindMaxLen_OP(root->_right, maxLen) + 1;

		if (maxLen < l + r)
		{
			maxLen = l + r;
		}

		return l > r ? l : r;
	}

	//10. 由前序遍历和中序遍历重建二叉树（前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6 5)
	BinaryTreeNode* _RebulidTree(int prevOrder[], int& index, int prevSize,
								 int inOrder[], int po1, int po2)
	{
		BinaryTreeNode* root = NULL;
		if (index < prevSize && po1 <= po2)
		{
			// 前序确定根
			root = new BinaryTreeNode(prevOrder[index]);

			// 确定左右子树的区间
			if (po1 < po2)
			{
				int div = po1;
				while (inOrder[div] != prevOrder[index])
				{
					++div;
				}
				root->_left = _RebulidTree(prevOrder, ++index, prevSize, inOrder, po1, div-1);
				root->_right = _RebulidTree(prevOrder, ++index, prevSize, inOrder,div+1, po2);
			}
		}

		return root;
	}

	// 由前序遍历和中序遍历重建二叉树（前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6 5）
	BinaryTreeNode* RebulidTree(int inOrder[], int inSize,
								 int prevOrder[], int prevSize)
	{
		assert(inOrder);
		assert(prevOrder);
		assert(inSize == prevSize);

		int index = 0;
		return _RebulidTree(prevOrder, index, prevSize, inOrder, 0, prevSize-1);
	}

	void TestRebulidTree()
	{
		int prevOrder[] = {1,2,3,4,5,6};
		int inOrder[] = {3,2,4,1,6,5};

		BinaryTreeNode* root = RebulidTree(inOrder, sizeof(inOrder)/sizeof(int),
			prevOrder, sizeof(prevOrder)/sizeof(int));

		PrevOrder(root);
		InOrder(root);
	}

	//11. 判断一棵树是否是完全二叉树
	bool IsCompleteTree(BinaryTreeNode* root)
	{
		queue<BinaryTreeNode*> q;
		if (root)
			q.push(root);

		bool isLast = false;

		while (!q.empty())
		{
			BinaryTreeNode* front = q.front();
			q.pop();
			if (front->_left)
			{
				if (isLast)
					return false;

				q.push(front->_left);
			}
			else
			{
				isLast = true;
			}

			if (front->_right)
			{
				if (isLast)
					return false;

				q.push(front->_right);
			}
			else
			{
				isLast = true;
			}
		}

		return true;
	}

	void TestIsCompleteTree()
	{
		BinaryTreeNode* root = 0;

		//	    1
		//    /   \
		//	 2	   5	
		//  / \	  /
		// 3   4  6
		//

		// 123##4##56
		vector<DataType> t;
		t.push_back(1);
		t.push_back(2);
		t.push_back(3);
		t.push_back('#');
		t.push_back('#');
		t.push_back(4);
		t.push_back('#');
		t.push_back('#');
		t.push_back(5);
		t.push_back(6);

		int index = 0;
		CreateBinaryTree(root, t, index);

		cout<<"IsCompleteTree?"<<IsCompleteTree(root)<<endl;

	}

	//12. 求二叉树的镜像【y】
	void ToTreeMirror(BinaryTreeNode* root)
	{
		if (root == NULL)
		{
			return;
		}

		swap(root->_left, root->_right);
		ToTreeMirror(root->_left);
		ToTreeMirror(root->_right);
	}

	void TestToTreeMirror()
	{
		BinaryTreeNode* root = 0;

		//	    1
		//    /   \
		//	 2	   5	
		//  / \	  /	\
		// 3   4  6  7
		//

		// 123##4##56##7
		vector<DataType> t;
		t.push_back(1);
		t.push_back(2);
		t.push_back(3);
		t.push_back('#');
		t.push_back('#');
		t.push_back(4);
		t.push_back('#');
		t.push_back('#');
		t.push_back(5);
		t.push_back(6);
		t.push_back('#');
		t.push_back('#');
		t.push_back(7);

		int index = 0;
		CreateBinaryTree(root, t, index);
		ToTreeMirror(root);

		PrevOrder(root);
		cout<<endl;
	}

	//13.将二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向
	// left表示双向链表的前驱指针，right代表双向链表的后继指针
	void _ToList(BinaryTreeNode* cur, BinaryTreeNode*& prev)
	{
		if (cur == NULL)
			return;
		
		_ToList(cur->_left, prev);

		cur->_left = prev;
		if (prev)
			prev->_right = cur;

		prev = cur;

		_ToList(cur->_right, prev);
	}

	BinaryTreeNode* ToList(BinaryTreeNode* root)
	{
		// 先找到最左节点作为链表的头
		BinaryTreeNode* head = root;
		while (head && head->_left)
		{
			head = head->_left;
		}

		BinaryTreeNode* prev = NULL;
		_ToList(root, prev);

		return head;
	}

	void TestToList()
	{
		// 531##4##76
		vector<DataType> t;
		t.push_back(5);
		t.push_back(3);
		t.push_back(1);
		t.push_back('#');
		t.push_back('#');
		t.push_back(4);
		t.push_back('#');
		t.push_back('#');
		t.push_back(7);
		t.push_back(6);

		int index = 0;
		BinaryTreeNode* root = 0;
		CreateBinaryTree(root, t, index);

		BinaryTreeNode* head = ToList(root);


		BinaryTreeNode* tail = NULL;
		while (head)
		{
			cout<<head->_data<<" ";
			tail = head;
			head = head->_right;
		}
		cout<<endl;

		while (tail)
		{
			cout<<tail->_data<<" ";
			tail = tail->_left;
		}
		cout<<endl;
	}

	// 测试二叉树编程题
	void TestBinaryTreeTopic()
	{
		cout<<endl;
		cout<<"TestBinaryTreeTopic:"<<endl;
		BinaryTreeNode* root = 0;

		//	    1
		//    /   \
		//	 2	   5	
		//  / \	  /	
		// 3   4  6
		//

		// 123##4##56
		vector<DataType> t;
		t.push_back(1);
		t.push_back(2);
		t.push_back(3);
		t.push_back('#');
		t.push_back('#');
		t.push_back(4);
		t.push_back('#');
		t.push_back('#');
		t.push_back(5);
		t.push_back(6);

		for (size_t i = 0; i < t.size(); ++i)
		{
			cout<<t[i]<<" ";
		}
		cout<<endl;

		int index = 0;
		CreateBinaryTree(root, t, index);

		cout<<"prev:";
		PrevOrder(root);
		cout<<endl;

		cout<<"In:";
		InOrder(root);
		cout<<endl;

		cout<<"Post:";
		PostOrder(root);
		cout<<endl;


		// 求两个节点的最近公共祖先
		BinaryTreeNode* x1 = Find(root, 4);
		BinaryTreeNode* x2 = Find(root, 5);
		BinaryTreeNode* ret = GetCommontAncestor_OP(root, x1, x2);
		if (ret)
			cout<<"3 & 6 Commont Ancestor Is:"<<ret->_data<<endl;
		else
			cout<<"Not Find Commont Ancestor"<<endl;

		int height = 0;
		cout<<"Tree Is Balance Tree ? : "<<IsBalance(root)<<endl;

		cout<<"OP Tree Is Balance Tree ? : "<<IsBalance_OP(root, height)<<endl;

		// 测试一棵树中的最远距离
		int maxLen = 0;
		FindMaxLen(root, maxLen);
		cout<<"Max Len:"<<maxLen<<endl;

		maxLen = 0;
		FindMaxLen_OP(root, maxLen);
		cout<<"OP2 Max Len:"<<maxLen<<endl;

		// 测试二叉树重建
		cout<<"TestRebulidTree:";
		TestRebulidTree();
		cout<<endl;

		// 测试搜索二叉树转换成双向链表
		cout<<"TestToList:";
		TestToList();

		// 测试求二叉树的镜像
		cout<<"TestToTreeMirror:";
		TestToTreeMirror();

		// 测试判断是否是完全二叉树
		cout<<"TestIsCompleteTree:";
		TestIsCompleteTree();
	};
};




                

        

    



  



    



                



	

		

			

				
					
六大类二叉树面试题汇总解答

				
			

			

				

					m0_54828003的博客
				

				

					10-06
					
					466
					
				

			

		

		

			
				
这一篇文章汇总下常见的二叉树相关面试题，主要分为判断类、构建类、存储类、查找类、距离类、混合类这六类大问题。

			
		

	



                

            
              



	

		

			

				
					
二叉树面试题（高频）

				
			

			

				

					m0_64130230的博客
				

				

					03-22
					
					2945
					
				

			

		

		

			
				
目录

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题目...

			
		

	



              


  
              

                


	

		

			

				
					
二叉树的各种算法面试题及答案解析

				
			

			

				

					RuiDer的博客
				

				

					09-24
					
					5237
					
				

			

		

		

			
				
前言
下面的所有面试题及解析答案都是经过验证的。
开始
树的定义
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;
    }
}

树的深度计算（非...

			
		

	





	

		

			

				
					
二叉树的相关面试题(一)

				
			

			

				

					Damn_Yang的博客
				

				

					12-03
					
					386
					
				

			

		

		

			
				
1.创建二叉树

在我写的另一派博客中：https://blog.youkuaiyun.com/Damn_Yang/article/details/84728761

2.前/中/后序遍历二叉树（递归与非递归）

前序(递归与非递归)：


//递归
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	pri...

			
		

	



		

			
		



	

		

			

				
					
java二叉树算法面试题大全含答案，月薪20k+的Java面试都问些什么

				
			

			

				

					2401_84413631的博客
				

				

					04-23
					
					1218
					
				

			

		

		

			
				
21二叉树算法刷题LeetCode中文版：二叉树。

			
		

	





	

		

			

				
					
二叉树面试题 树和二叉树总结.doc

				
			

			

				

					02-24
				

			

		

		

			
				
"二叉树面试题 树和二叉树总结"  本资源摘要信息涵盖了树和二叉树的面试题总结，包括选择题和解释。涵盖的知识点包括树和二叉树的定义、性质、操作和应用等。  一、树和二叉树的定义  树是一种数据结构，由一个根...

			
		

	





	

		

			

				
					
数据结构二叉树常见面试题

				
			

			

				

					Nameseven的博客
				

				

					10-03
					
					1160
					
				

			

		

		

			
				
题目：
1. 求二叉树中的节点个数
2. 求二叉树的深度
3. 求二叉树中叶子节点的个数
4. 求二叉树第K层的节点个数
5. 前序遍历，中序遍历，后序遍历(递归版本，非递归版本)
6. 分层遍历二叉树（按层次从上往下，从左往右）
7.  将二叉查找树变为有序的双向链表
8. 判断两棵二叉树是否结构相同
9. 判断二叉树是不是平衡二叉树(AVL树)
10. 求二叉树的镜像
11. 求二叉树中两个节...

			
		

	





	

		

			

				
					
二叉树相关的面试题

				
			

			

				

					jingchengsuoz的专栏
				

				

					06-20
					
					462
					
				

			

		

		

			
				
1、 层序遍历二叉树
// 二叉树相关.cpp : 定义控制台应用程序的入口点。
//程序猴，2013.6.20
#include "stdafx.h"
#include 
#include 
using namespace std;

//定义一个二叉树结点结构体
typedef struct  Node 
{
	int Element;
	struct Node* Left;
	struct

			
		

	





	

		

			

				
					
二叉树相关面试题（上）

				
			

			

				

					zjx624bjh的博客
				

				

					03-02
					
					1034
					
				

			

		

		

			
				
一，将二叉搜索树转换为一个排序的双向链表。 
提示：要求不能创建任何新的结点，只能调整树中节点的指向。 
eg： 
 
搜索二叉树：左节点的值小于父节点的值，右节点的值大于父节点的值。 
思路：二叉树中每个节点有两个指向子节点的指针，双向链表中每个节点也有两个指针，两个节点结构相似，同时二叉搜索树也是一种排序的数据结构。因此理论上可能实现二叉搜索树和排序双向链表的转换。 
步骤：在将二叉搜索树转换...

			
		

	





	

		

			

				
					
二叉树相关面试题汇总

				
			

			

				

					观赏的博客
				

				

					07-23
					
					635
					
				

			

		

		

			
				
说明：本博文在以前面试题的基础上汇总了二叉树的常见面试题。二叉树中封装的功能有：    void _CreateTree(Node*& pRoot, const T array[], size_t size, size_t& index, const T& invalid);//创建树    Node* _CopyBinaryTree(Node* pRoot);//拷贝树    void _Dest

			
		

	





	

		

			

				
					
二叉树精选面试题

				
			

			

				

					2202_76097976的博客
				

				

					07-22
					
					1963
					
				

			

		

		

			
				
记录了自己在学习数据结构的过程中刷的题，一棵树的子树，翻转二叉树，平衡二叉树，对称二叉树，平衡二叉树，最近公共祖先等等

			
		

	





	

		

			

				
					
二叉树的经典面试题（你值得拥有）

				
			

			

				

					weixin_49830664的博客
				

				

					10-31
					
					3387
					
				

			

		

		

			
				
二叉树的经典面试题
文章目录二叉树的经典面试题初阶面试题进阶面试题
再之前我已经发布有关二叉树的基础知识：二叉树的详解，那么接下来我将会为你们讲一些经典并且常见的二叉树面试题
初阶面试题
进阶面试题

...

			
		

	





	

		

			

				
					
【C++】10道经典面试题带你玩转二叉树

					
最新发布

				
			

			

				

					C/C++领域,数据结构,linux,MySQl学习者
				

				

					09-23
					
					1106
					
				

			

		

		

			
				
10道有关二叉树的C++经典面试题目,包括: 根据二叉树创建字符串, 二叉树的层序遍历, 二叉树的层序遍历 II, 二叉树的最近公共祖先, 二叉搜索树与双向链表, 从前序与中序遍历序列构造二叉树,  从中序与后序遍历序列构造二叉树,  二叉树的前序遍历(迭代算法), 二叉树的中序遍历(迭代算法),二叉树的后序遍历(迭代算法)等题目的解题思路以及解题代码详解

			
		

	





	

		

			

				
					
【数据结构】二叉树面试题总结(持续更新中...)

				
			

			

				

					weixin_44258092的博客
				

				

					08-10
					
					1675
					
				

			

		

		

			
				
总结了二叉树的相关习题。

			
		

	





	

		

			

				
					
二叉树常见的面试题—C++实现

				
			

			

				

					qq_37941471的博客
				

				

					06-26
					
					2487
					
				

			

		

		

			
				

1. 前序/中序/后序遍历（递归&amp;amp;amp;非递归）
 2. 层序遍历
 3. 求二叉树的高度
4. 求叶子节点的个数
5. 求二叉树第k层的节点个数
6. 判断一个节点是否在一棵二叉树中
7. 求两个节点的最近公共祖先
8. 判断一棵二叉树是否是平衡二叉树
9. 求二叉树中最远的两个节点的距离
10. 由前序遍历和中序遍历重建二叉树（前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1...

			
		

	





	

		

			

				
					
二叉树的经典面试题总结

				
			

			

				

					snow_5288的博客
				

				

					05-04
					
					9219
					
				

			

		

		

			
				
1、二叉树的构造  2、遍历二叉树 3、求二叉树的高度（深度）   4、求二叉树中节点的个数 5、求二叉树中叶子节点的个数 6、求二叉树第K层的节点个数
7、判断一个节点是否在二叉树中 8、求两个节点的最近公共祖先9、判断一棵二叉树是否是平衡二叉树10、求二叉树中最远的两个节点的距离 11、由前序遍历和中序遍历重建二叉树12、判断一棵树是否是完全二叉树13、求二叉树的镜像14、二叉搜索树->有序双链表

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值