二叉树的基本操作，以及相关面试题（C++实现）

最新推荐文章于 2024-05-13 15:38:37 发布
最新推荐文章于 2024-05-13 15:38:37 发布
阅读量944 收藏 5
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoxu00/article/details/82023114
版权

【面试题】

1、创建二叉树

#include<iostream>
using namespace std;

template<class T>
struct BinTreeNode{
	BinTreeNode(const T& data)
	  : _pLeft(NULL)
	  , _pRight(NULL)
	  , _data(data)
	{}
    
	BinTreeNode<T>* _pLeft;
	BinTreeNode<T>* _pRight;
	T _data;
};

template<class T>
class BinTree{
	typedef BinTreeNode<T> Node;
	typedef Node* PNode;
public:
	BinTree()
		: _pRoot(NULL)
	{}

	BinTree(const T* array,size_t size,const T& invalid)
	{
		size_t index = 0;
		CreateBinTree(_pRoot, array, size,index,invalid);
	}


	~BinTree()
	{
		DestoryBinTree(_pRoot);
	}
void CreateBinTree(PNode& pRoot, const T* array, size_t size,size_t& index,const T& invalid)
	{
		if (index<size&&invalid!=array[index]){
			pRoot = new Node(array[index]);
			CreateBinTree(pRoot->_pLeft, array, size, ++index,invalid);
			CreateBinTree(pRoot->_pRight, array, size, ++index,invalid);
		}
	}

	PNode CopyBinTree(PNode pRoot)
	{
		PNode pNewNode = NULL;
		if (pRoot){
			pNewNode = new Node(pRoot->_data);
			if (pRoot->_pLeft)
				pNewNode->_pLeft = CopyBinTree(pRoot->_pLeft);
			if (pRoot->_pRight)
                pNewNode->_pRight = CopyBinTree(pRoot->_pRight);
		}
		return pNewNode;
	}

	void DestoryBinTree(PNode& pRoot)
	{
		if (pRoot){
			DestoryBinTree(pRoot->_pLeft);
			DestoryBinTree(pRoot->_pRight);
			delete pRoot;
			pRoot = NULL;
		}
	}
};

2、前/中/后遍历二叉树(递归&非递归)

        //前序遍历
	void PreOrder(PNode pRoot)
	{
		if (pRoot){
			cout << pRoot->_data << " ";
			PreOrder(pRoot->_pLeft);
			PreOrder(pRoot->_pRight);
		}
	}
	//非递归前序遍历
	void _PreOrder_Nor()
	{
		cout << "_PreOrder_Nor:";
		if (_pRoot == NULL)
			return;
		stack<PNode> s;
		s.push(_pRoot);
		while (!s.empty()){
			PNode pCur = s.top();
			cout << pCur->_data << " ";
			s.pop();
			if (pCur->_pRight)
				s.push(pCur->_pRight);
			if (pCur->_pLeft)
				s.push(pCur->_pLeft);
		}
		cout << endl;
	}

	//中序遍历
	void InOrder(PNode pRoot)
	{
		if (pRoot){
			InOrder(pRoot->_pLeft);
			cout << pRoot->_data << " ";
			InOrder(pRoot->_pRight);
		}
	}

	//非递归中序遍历
	void _InOrder_Nor()
	{
		cout << "_InOrder_Nor";
		if (_pRoot == NULL)
			return;
			stack<PNode> s;
			PNode pCur = _pRoot;
			while (pCur || !s.empty()){
				while (pCur){
					s.push(pCur);
					pCur = pCur->_pLeft;
				}
				pCur = s.top();
				cout << pCur->_data << " ";
				s.pop();
				pCur = pCur->_pRight;
			}
			cout << endl;
	}

	//后序遍历
	void EndOrder(PNode pRoot)
	{
		if (pRoot){
			EndOrder(pRoot->_pLeft);
			EndOrder(pRoot->_pRight);
			cout << pRoot->_data << " ";
		}
	}
	//非递归后序遍历
	void _EndOrder_Nor()
	{
		cout << "_EndOrder_Nor:";
		if (_pRoot == NULL)
			return;

		stack<PNode> s;
		PNode pCur = _pRoot;
		PNode pTmp = NULL;
		while (pCur || !s.empty()){
			while (pCur){
				s.push(pCur);
				pCur = pCur->_pLeft;
			}
			_pRoot = s.top();
			if (NULL == _pRoot->_pRight || _pRoot->_pRight == pTmp){
				cout << _pRoot->_data << " ";
				s.pop();
				pTmp = _pRoot;
			}
			else{
				pCur = _pRoot->_pRight;
			}	
		}
		cout << endl;
	}

3、层序遍历二叉树

void LevelOrder(PNode pRoot)
	{
		if (NULL == pRoot)
			return;
		queue<PNode> q;
		q.push(pRoot);
		while (!q.empty()){
			PNode pCur = q.front();
			cout << pCur->_data <<" " ;
			if (pCur->_pLeft)
				q.push(pCur->_pLeft);
			if (pCur->_pRight)
				q.push(pCur->_pRight);
			q.pop();
		}
		cout << endl;
	}

4、求二叉树的高度

size_t Height(PNode pRoot)
	{
		if (NULL == pRoot)
			return 0;
		if (NULL == pRoot->_pLeft&&NULL == pRoot->_pRight)
			return 1;
		size_t LeftHeight = Height(pRoot->_pLeft);
		size_t RightHeight = Height(pRoot->_pRight);
		return LeftHeight > RightHeight ? (LeftHeight + 1) : (RightHeight + 1);
	}

5、求二叉树中结点的个数

size_t Size(PNode pRoot)
	{
		if (NULL == pRoot)
			return 0;
		return Size(pRoot->_pLeft) + Size(pRoot->_pRight) + 1;
	}

6、求叶子结点的个数

size_t GetLeaf(PNode pRoot)
	{
		if (NULL == pRoot)
			return 0;
		if (NULL == pRoot->_pLeft&&NULL == pRoot->_pRight)
			return 1;
		return GetLeaf(pRoot->_pLeft) + GetLeaf(pRoot->_pRight);
	}

7、求二叉树中第k层结点的个数

size_t GetKLevelNode(PNode pRoot,size_t K)
	{
		if (NULL == pRoot ||K == 0)
			return 0;
		if (K == 1)
			return 1;
		return GetKLevelNode(pRoot->_pLeft, K-1) + GetKLevelNode(pRoot->_pRight, K-1);
	}

8、判断一个节点是否在一棵二叉树中

bool IsNodeInBinTree(PNode pRoot, PNode pNode)
	{
		if (NULL == pRoot || NULL == pNode)
			return false;
		if (pRoot == pNode)
			return true;
		bool IsIn = false;
		if (IsIn = IsNodeInBinTree(pRoot->_pLeft, pNode))
			return true;
		return IsNodeInBinTree(pRoot->_pRight, pNode);
	}

 

9、判断一棵二叉树是否是完全二叉树

bool IsComporeBinTree()
	{
		if (_pRoot == NULL)
			return true;
		bool IsFlag = false;
		queue<PNode> q;
		q.push(_pRoot);
		while (!q.empty()){
			PNode pCur = q.front();
			if (IsFlag){
				if (pCur->_pLeft || pCur->_pRight)
					return true;
			}
			if (pCur->_pLeft&&pCur->_pRight){
				q.push(pCur->_pLeft);
				q.push(pCur->_pRight);
			}
			else if (pCur->_pLeft){
				q.push(pCur->_pLeft);
				IsFlag = true;
			}
			else if (pCur->_pRight)
				return false;
			else
				IsFlag = true;
			q.pop();
		}
		return true;
	}

10、求二叉树的镜像 

	void PreMarroy(PNode pRoot)
	{
		if (pRoot){
			swap(pRoot->_pLeft, pRoot->_pRight);
			cout << pRoot->_data << " ";
			PreMarroy(pRoot->_pLeft);
			PreMarroy(pRoot->_pRight);
		}
	}

	void InMarroy(PNode pRoot)
	{
		if (pRoot){
			swap(pRoot->_pLeft, pRoot->_pRight);
			InMarroy(pRoot->_pLeft);
			cout << pRoot->_data << " ";
			InMarroy(pRoot->_pRight);
		}
	}

	void EndMarroy(PNode pRoot)
	{
		if (pRoot){
			swap(pRoot->_pLeft, pRoot->_pRight);
			EndMarroy(pRoot->_pLeft);
			EndMarroy(pRoot->_pRight);
			cout << pRoot->_data << " ";
		}
	}

	void FeiMarroy(PNode pRoot)
	{
		if (pRoot == NULL)
			return;
		queue<PNode> q;
		q.push(pRoot);

		while (!q.empty()){
			PNode pCur = q.front();
			swap(pCur->_pLeft, pCur->_pRight);
			if (pCur->_pLeft)
				q.push(pCur->_pLeft);
			if (pCur->_pRight)
				q.push(pCur->_pRight);
			q.pop();
			cout << pCur->_data <<" ";
		}
	}


整体代码：

#include<iostream>
#include<string.h>
#include<queue>
#include<stack>
using namespace std;

template<class T>
struct BinTreeNode{
	BinTreeNode(const T& data)
	  : _pLeft(NULL)
	  , _pRight(NULL)
	  , _data(data)
	{}
    
	BinTreeNode<T>* _pLeft;
	BinTreeNode<T>* _pRight;
	T _data;
};

template<class T>
class BinTree{
	typedef BinTreeNode<T> Node;
	typedef Node* PNode;
public:
	BinTree()
		: _pRoot(NULL)
	{}

	BinTree(const T* array,size_t size,const T& invalid)
	{
		size_t index = 0;
		CreateBinTree(_pRoot, array, size,index,invalid);
	}

	//BinTree<T>& operator=(const BinTree<T>& bt)
	//{
	//	if (this != &bt){
	//		DestoryBinTree(_pRoot);
	//		_pRoot = CopyBinTree(bt->_pRoot);
	//	}
	//	return *this;
	//}

	~BinTree()
	{
		DestoryBinTree(_pRoot);
	}

	//前序遍历
	void _PreOrder()
	{
		cout << "_PreOrder:" ;
		PreOrder(_pRoot);
		cout << endl;
	}

	//非递归前序遍历
	void _PreOrder_Nor()
	{
		cout << "_PreOrder_Nor:";
		if (_pRoot == NULL)
			return;
		stack<PNode> s;
		s.push(_pRoot);
		while (!s.empty()){
			PNode pCur = s.top();
			cout << pCur->_data << " ";
			s.pop();
			if (pCur->_pRight)
				s.push(pCur->_pRight);
			if (pCur->_pLeft)
				s.push(pCur->_pLeft);
		}
		cout << endl;
	}

	//中序遍历
	void _InOrder()
	{
		cout << "_InOrder:";
		InOrder(_pRoot);
		cout << endl;
	}	

	//非递归中序遍历
	void _InOrder_Nor()
	{
		cout << "_InOrder_Nor";
		if (_pRoot == NULL)
			return;
			stack<PNode> s;
			PNode pCur = _pRoot;
			while (pCur || !s.empty()){
				while (pCur){
					s.push(pCur);
					pCur = pCur->_pLeft;
				}
				pCur = s.top();
				cout << pCur->_data << " ";
				s.pop();
				pCur = pCur->_pRight;
			}
			cout << endl;
	}

	//后序遍历
	void _EndOrder()
	{
		cout << "_EndOrder:";
		EndOrder(_pRoot);
		cout << endl;
	}

	//非递归后序遍历
	void _EndOrder_Nor()
	{
		cout << "_EndOrder_Nor:";
		if (_pRoot == NULL)
			return;

		stack<PNode> s;
		PNode pCur = _pRoot;
		PNode pTmp = NULL;
		while (pCur || !s.empty()){
			while (pCur){
				s.push(pCur);
				pCur = pCur->_pLeft;
			}
			_pRoot = s.top();
			if (NULL == _pRoot->_pRight || _pRoot->_pRight == pTmp){
				cout << _pRoot->_data << " ";
				s.pop();
				pTmp = _pRoot;
			}
			else{
				pCur = _pRoot->_pRight;
			}	
		}
		cout << endl;
	}

	//层序遍历
	void _LevelOrder()
	{
		cout << "_LevelOrder:";
		LevelOrder(_pRoot);
		cout << endl;
	}

	//求树的高度
	void _Height()
	{
		cout << "_Height:";
		size_t p;
		p=Height(_pRoot);
		cout << p << endl;
	}

	//树的节点个数
	void _Size()
	{
		cout << "_Size:";
		size_t p;
		p = Size(_pRoot);
		cout << p << endl;
	}

	//树的叶子节点个数
	void _GetLeaf()
	{
		cout << "_GetLeaf:";
		size_t p;
		p = GetLeaf(_pRoot);
		cout << p << endl;
	}

	//第K层节点个数
	void _GetKLevelNode(size_t K)
	{
		cout << "_GetKLevelNode:";
		size_t p;
		p = GetKLevelNode(_pRoot,K);
		cout << p << endl;
	}

	//查找结点是否存在
	void _IsNodeInBinTree(PNode pNode)
	{
		cout << "_IsNodeInBinTree:";
		bool p;
		p=IsNodeInBinTree(_pRoot,pNode);
		if (p == true)
			cout << "存在" << endl;
		if (p == false)
			cout << "不存在" << endl;
	}

	//查找结点
	PNode _Find(const T& data)
	{
		return Find(_pRoot, data);
	}

	//判断二叉树是否为完全二叉树
	void _IsComporeBinTree()
	{
		cout << "_IsComporeBinTree:";
		bool p;
		p = IsComporeBinTree();
		if (p == true)
			cout << "是完全二叉树" << endl;
		if (p == false)
			cout << "不是完全二叉树" << endl;
	}

    //求二叉树的镜像
	void _PreMarroy()
	{
		cout << "_PreMarroy:";
		PreMarroy(_pRoot);
		cout << endl;
	}	
	
	void _InMarroy()
	{
		cout << "_InMarroy:";
		InMarroy(_pRoot);
		cout << endl;
	}

	void _EndMarroy()
	{
		cout << "_EndMarroy:";
		EndMarroy(_pRoot);
		cout << endl;
	}

	//非递归的方法求二叉树的镜像
	void _FeiMarroy()
	{
		cout << "_FeiMarroy:";
		FeiMarroy(_pRoot);
		cout << endl;
	}

private:
	void CreateBinTree(PNode& pRoot, const T* array, size_t size,size_t& index,const T& invalid)
	{
		if (index<size&&invalid!=array[index]){
			pRoot = new Node(array[index]);
			CreateBinTree(pRoot->_pLeft, array, size, ++index,invalid);
			CreateBinTree(pRoot->_pRight, array, size, ++index,invalid);
		}
	}

	PNode CopyBinTree(PNode pRoot)
	{
		PNode pNewNode = NULL;
		if (pRoot){
			pNewNode = new Node(pRoot->_data);
			if (pRoot->_pLeft)
				pNewNode->_pLeft = CopyBinTree(pRoot->_pLeft);
			if (pRoot->_pRight)
                pNewNode->_pRight = CopyBinTree(pRoot->_pRight);
		}
		return pNewNode;
	}

	void DestoryBinTree(PNode& pRoot)
	{
		if (pRoot){
			DestoryBinTree(pRoot->_pLeft);
			DestoryBinTree(pRoot->_pRight);
			delete pRoot;
			pRoot = NULL;
		}
	}

	void PreOrder(PNode pRoot)
	{
		if (pRoot){
			cout << pRoot->_data << " ";
			PreOrder(pRoot->_pLeft);
			PreOrder(pRoot->_pRight);
		}
	}

	void InOrder(PNode pRoot)
	{
		if (pRoot){
			InOrder(pRoot->_pLeft);
			cout << pRoot->_data << " ";
			InOrder(pRoot->_pRight);
		}
	}

	void EndOrder(PNode pRoot)
	{
		if (pRoot){
			EndOrder(pRoot->_pLeft);
			EndOrder(pRoot->_pRight);
			cout << pRoot->_data << " ";
		}
	}

	void LevelOrder(PNode pRoot)
	{
		if (NULL == pRoot)
			return;
		queue<PNode> q;
		q.push(pRoot);
		while (!q.empty()){
			PNode pCur = q.front();
			cout << pCur->_data <<" " ;
			if (pCur->_pLeft)
				q.push(pCur->_pLeft);
			if (pCur->_pRight)
				q.push(pCur->_pRight);
			q.pop();
		}
		cout << endl;
	}

	size_t Height(PNode pRoot)
	{
		if (NULL == pRoot)
			return 0;
		if (NULL == pRoot->_pLeft&&NULL == pRoot->_pRight)
			return 1;
		size_t LeftHeight = Height(pRoot->_pLeft);
		size_t RightHeight = Height(pRoot->_pRight);
		return LeftHeight > RightHeight ? (LeftHeight + 1) : (RightHeight + 1);
	}

	size_t Size(PNode pRoot)
	{
		if (NULL == pRoot)
			return 0;
		return Size(pRoot->_pLeft) + Size(pRoot->_pRight) + 1;
	}

	size_t GetLeaf(PNode pRoot)
	{
		if (NULL == pRoot)
			return 0;
		if (NULL == pRoot->_pLeft&&NULL == pRoot->_pRight)
			return 1;
		return GetLeaf(pRoot->_pLeft) + GetLeaf(pRoot->_pRight);
	}

	size_t GetKLevelNode(PNode pRoot,size_t K)
	{
		if (NULL == pRoot ||K == 0)
			return 0;
		if (K == 1)
			return 1;
		return GetKLevelNode(pRoot->_pLeft, K-1) + GetKLevelNode(pRoot->_pRight, K-1);
	}

	bool IsNodeInBinTree(PNode pRoot, PNode pNode)
	{
		if (NULL == pRoot || NULL == pNode)
			return false;
		if (pRoot == pNode)
			return true;
		bool IsIn = false;
		if (IsIn = IsNodeInBinTree(pRoot->_pLeft, pNode))
			return true;
		return IsNodeInBinTree(pRoot->_pRight, pNode);
	}

	PNode Find(PNode pRoot, const T& data)
	{
		if (NULL == pRoot)
			return NULL;
		if (pRoot->_data == data)
			return pRoot;
		PNode _data = NULL;
		if (_data = Find(pRoot->_pLeft, data))
			return _data;
		return Find(pRoot->_pRight, data);
	}

	bool IsComporeBinTree()
	{
		if (_pRoot == NULL)
			return true;
		bool IsFlag = false;
		queue<PNode> q;
		q.push(_pRoot);
		while (!q.empty()){
			PNode pCur = q.front();
			if (IsFlag){
				if (pCur->_pLeft || pCur->_pRight)
					return true;
			}
			if (pCur->_pLeft&&pCur->_pRight){
				q.push(pCur->_pLeft);
				q.push(pCur->_pRight);
			}
			else if (pCur->_pLeft){
				q.push(pCur->_pLeft);
				IsFlag = true;
			}
			else if (pCur->_pRight)
				return false;
			else
				IsFlag = true;
			q.pop();
		}
		return true;
	}

	void PreMarroy(PNode pRoot)
	{
		if (pRoot){
			swap(pRoot->_pLeft, pRoot->_pRight);
			cout << pRoot->_data << " ";
			PreMarroy(pRoot->_pLeft);
			PreMarroy(pRoot->_pRight);
		}
	}

	void InMarroy(PNode pRoot)
	{
		if (pRoot){
			swap(pRoot->_pLeft, pRoot->_pRight);
			InMarroy(pRoot->_pLeft);
			cout << pRoot->_data << " ";
			InMarroy(pRoot->_pRight);
		}
	}

	void EndMarroy(PNode pRoot)
	{
		if (pRoot){
			swap(pRoot->_pLeft, pRoot->_pRight);
			EndMarroy(pRoot->_pLeft);
			EndMarroy(pRoot->_pRight);
			cout << pRoot->_data << " ";
		}
	}

	void FeiMarroy(PNode pRoot)
	{
		if (pRoot == NULL)
			return;
		queue<PNode> q;
		q.push(pRoot);

		while (!q.empty()){
			PNode pCur = q.front();
			swap(pCur->_pLeft, pCur->_pRight);
			if (pCur->_pLeft)
				q.push(pCur->_pLeft);
			if (pCur->_pRight)
				q.push(pCur->_pRight);
			q.pop();
			cout << pCur->_data <<" ";
		}
	}

private:
	PNode _pRoot;
};


void Test(){
	char* arr = "ABD###CE##F";
	BinTree<char> bt(arr, strlen(arr), '#');
	bt._PreOrder();
	bt._PreOrder_Nor();
	bt._InOrder();
	bt._InOrder_Nor();
	bt._EndOrder();
	bt._EndOrder_Nor();
	bt._LevelOrder();
	bt._Height();
	bt._Size();
	bt._GetLeaf();
	bt._GetKLevelNode(1);
	BinTreeNode<char>* pNode = bt._Find('b');
	BinTreeNode<char>* pNode1 = bt._Find('B');
	bt._IsNodeInBinTree(pNode);
	bt._IsNodeInBinTree(pNode1);
	BinTree<char> bt1(bt);
	bt._IsComporeBinTree();
	bt._PreMarroy();
	bt._InMarroy();
	bt._EndMarroy();
	bt._FeiMarroy();

	BinTree<char> bt2;
	bt2 = bt;
}

int main(){
	Test();
	return 0;
}

测试结果截图：

测试截图

 

guoxu00
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++与操作系统等面试题88
06-14
### C++与操作系统等面试题88：二叉树遍历方法详解 #### 一、题目背景 在软件开发及算法设计领域，二叉树是一种常见的数据结构，它广泛应用于各种场景，如文件系统的目录结构、数据库索引、编译器语法分析等。对于...
c++二叉树构建及面试常见问题代码实现
小熊的博客
08-07 676
二叉树的面试常见问题包括： 二叉树中的节点个数二叉树的深度前序遍历，中序遍历，后序遍历，层序遍历将二叉查找树变为有序的双向链表二叉树第K层的节点个数二叉树中叶子节点的个数判断二叉树是不是平衡二叉树二叉树的镜像二叉树中两个节点的最低公共祖先节点二叉树中节点的最大距离判断二叉树是不是完全二叉树 下面是完整二叉树及这些常见问题的代码实现： 头文件BTree.h #ifndef B
[C++算法] - 二叉树《21道常见的面试题》
Snoopy_Dream
10-21 850
自己动手写代码，记录中间出现的错误。 这个网址不错https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E6%A0%91.md 目录 中序遍历！ 先序遍历 后序遍历 按层遍历 不分行打印（deque） 分行打印（queue） Z字遍历（两个栈） Mo...
C++的数据结构(六）：树的基本操作和遍历
全栈工程师Linda的博客
05-13 410
C++的数据结构：树的基本操作和遍历
C++ 二叉树的基本操作
zhw864680355的博客
03-27 3348
对于一棵二叉树，有三种基本遍历方式： 1、前序遍历（DLR）：先访问根结点，然后遍历左子树，最后遍历右子树。 归结为：从根结点一直从左子树向下直到叶结点，然后返回到叶结点的父亲，再从其父结点的右子树向下。 2、中序遍历（LDR）：先中序遍历左子树，然后访问根结点，最后遍历右子树。 3、后序遍历（LRD）：先后序遍历左子树，然后遍历右子树，最后访问根结点。 对如上图，遍历结果如下： 前...
二叉树的四种遍历方式（前序遍历、中序遍历、后序遍历、测层序遍历）
派拉斯兔子的博客
12-02 7717
二叉树的遍历 遍历是数据结构中的常见的操作，把所有元素都访问一遍。 线性数据结构的遍历比较简单 ①、正序遍历 ②、逆序遍历 根据节点访问顺序的不同，二叉树的常见遍历方式用四种 ①、前序遍历（Preorder Traversal） ②、中序遍历（Inorder Traversal） ③、后序遍历（Postorder Traversal） ④、层序遍历（Level Order Traversal） 前序遍历（Preorder Traversal） 访问顺序 根节点、前序遍历左子树、前序遍历右子
【C++ 二叉树操作详解】【转载】
j8267643的博客
02-16 873
在后续遍历得到的序列中，最后一个元素为树的根结点。1. 1->2->4->6->7，7 无左孩子，也无右孩子，输出 7，此时 6 无左孩子，而 6 的右子树也全部输出，输出 6，此时 4 无左子树，而 4 的右子树已全部输出，接着输出 4，此时 2 的左子树全部输出，且 2 无右子树，输出 2，此时 1 的左子树全部输出，接着转向右子树；3. 7 的左孩子为空，输出 7，右孩子也为空，此时 2 的左子树全部输出，输出 2，2 的右孩子为空，此时 1 的左子树全部输出，输出 1，接着 1 的右孩子；
C++与操作系统等面试题86
最新发布
06-14
### C++与操作系统等面试题86：哈希表与红黑树的使用 #### 哈希表在C++中的实现与应用 哈希表是一种数据结构，它通过使用哈希函数将键映射到特定的位置来加速查找操作。在C++标准库中，有几种容器用于实现哈希表的...
C++与操作系统等面试题37
06-10
综上所述，二叉树、二叉搜索树以及平衡二叉树如AVL树在计算机科学中扮演着极其重要的角色。它们不仅提供了高效的查找、插入和删除功能，而且通过各种优化手段如AVL树的高度平衡策略，使得这些操作在大数据集上也能...
c++ 面试题.zip
01-20
深入理解各种数据结构，如链表、队列、栈、树（二叉树、红黑树等）、图等，以及与之相关的操作（如查找、排序、插入和删除），是C++开发者的基础功。这些知识在解决复杂问题和优化算法效率时尤其关键。 五、操作...
C++面试题整理.zip
01-20
这份"C++面试题整理.zip"文件显然是一份全面的资源，旨在帮助C++开发者巩固和提升他们的技能，以应对各种面试挑战。这份资料涵盖了C++的核心概念，包括但不限于语言特性、设计模式、数据结构、操作系统原理以及网络...
c++二叉树的基本操作
11-25
递归二叉树的基本操作，递归创建，递归先序遍历、中序遍历、后序遍历，求树的高度，求叶子结点的个数，交换树的左右孩子
面试题目集锦--二叉树
10-22
面试的时候，我们会经常碰到二叉树之类的题目，这里，我对二叉树算法进行了许多的总结，希望能对一两位朋友有帮助
常见的二叉树面试题大汇总（涵盖二叉搜索树）
09-05
常见的二叉树面试题大汇总（涵盖二叉搜索树）
二叉树基本操作
04-30
以二叉链表作存储结构，编写程序，实现如下的功能： 1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和最小值。 4、（选作内容）试编写按层次顺序遍历二叉树的算法。参考算法思想：要采用一个队列q，先将二叉树根结点入队列，然后退队列，输出该结点；若它有左子树，便将左子树根结点入队列；若它有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进先出，从而达到按层次顺序遍历二叉树的目的。
二叉树的基本操作
06-25
二叉树的一些基本操作，比如先序遍历，非递归中序遍历，左右子树的查找
二叉树常见的面试题—C++实现
qq_37941471的博客
06-26 2285
1. 前序/中序/后序遍历（递归&amp;amp;amp;非递归） 2. 层序遍历 3. 求二叉树的高度 4. 求叶子节点的个数 5. 求二叉树第k层的节点个数 6. 判断一个节点是否在一棵二叉树中 7. 求两个节点的最近公共祖先 8. 判断一棵二叉树是否是平衡二叉树 9. 求二叉树中最远的两个节点的距离 10. 由前序遍历和中序遍历重建二叉树（前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1...
【C++】经典二叉树面试题
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
11-23 693
二叉树经典面试题
C和C++版本面试题集锦
本资源摘要信息涵盖了C和C++语言面试题集，包括静态变量、引用与指针、实时系统、全局变量和局部变量、平衡二叉树、堆栈溢出、虚函数、冒泡排序算法、浮点数比较、网络协议、IP地址和物理地址转换等多个知识点。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值