二叉树的面试题

二叉树的面试题

1.递归创建二叉树；

2.由前序遍历和中序遍历重建二叉树（前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6 5）；

3.前、中、后三种遍历的递归；

4.层次遍历-队列应用；

5.前、中、后三种遍历的非递归-用桟实现非递归；

6.求结点的个数；

7.求二叉树的高度；

8.求叶子结点的个数；

9.查找一个数据；

10.求第k层结点的个数；

11.求二叉树的镜像；

12.判断二叉树是不是完全二叉树；

<span style="font-size:18px;">#pragma once

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

template <class T>
struct BinaryTreeNode
{
	BinaryTreeNode<T>* _left;
	BinaryTreeNode<T>* _right;
	T _data;

	BinaryTreeNode(T data)
		:_left(NULL)
		, _right(NULL)
		, _data(data)
	{}
};

template <class T>
class BinaryTree
{
	typedef BinaryTreeNode<T> Node;
public:
	BinaryTree()
		:_root(NULL)
	{}

	/递归创建二叉树//
	BinaryTree(const T* arr, int len, const T& invalid)
	{
		assert(arr);
		int index = 0;
		_CreateBinaryTree(_root, arr, len, index, invalid);
	}

	//由前序遍历和中序遍历重建二叉树（前序序列：1 2 3 4 5 6 - 中序序列:3 2 4 1 6 5）
	BinaryTree(T* Prev,T* InOrder,int len)
	{
		assert(Prev);
		assert(InOrder);
		_ReBuildCreateBinaryTree(_root,Prev,InOrder,len);
	}
	
	//前、中、后三种遍历的递归
	void PreOrder()
	{
		_PreOrder(_root);
		cout << endl;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	void PostOrder()
	{
		_PostOrder(_root);
		cout << endl;
	}

	/层次遍历-队列应用/
	void LevelTraverse()
	{
		queue<Node*> q;
		if (_root)
			q.push(_root);
		while (!q.empty())
		{
			Node* front = q.front();
			cout << front->_data << " ";
			q.pop();
			if (front->_left)
				q.push(front->_left);
			if (front->_right)
				q.push(front->_right);
		}
		cout << endl;
	}

	//前、中、后三种遍历的非递归-用桟实现非递归
	//前序非递归：访问当前结点，利用栈的特性后进先出，将右结点先
	//入桟，再将左结点入桟，这样先访问左，再访问右

	void PreOrder_Non()
	{
		stack<Node*> s;
		if (_root)
			s.push(_root);
		while (!s.empty())
		{
			Node* top = s.top();
			cout << top->_data << " ";
			s.pop();
			if (top->_right)
				s.push(top->_right);
			if (top->_left)
				s.push(top->_left);
		}
		cout << endl;
	}

	//中序遍历：先将左子树入桟，再访问，再将右子树入桟/
	void InOrder_Non()
	{
		stack<Node*> s;
		Node* cur = _root;
		while (cur || !s.empty())
		{
			while (cur)
			{
				s.push(cur);
				cur = cur->_left;
			}
			cur = s.top();
			s.pop();
			cout << cur->_data << " ";
			cur = cur->_right;
		}
		cout << endl;
	}

	//后续遍历,prev法/
	void PostOrder_Non()
	{
		stack<Node*> s;
		Node* cur = _root;
		Node* prev = NULL;
		while (cur || !s.empty())
		{
			//左子树入桟
			while (cur)
			{
				s.push(cur);
				cur = cur->_left;
			}
			cur = s.top();
			//prev指向前一个被访问过的结点,右子树入桟
			if (cur->_right && prev != cur->_right)
			{
				cur = cur->_right;
			}
			//当右子树为空且该结点没有被访问过，则去访问该结点
			else
			{
				cout << cur->_data << " ";
				prev = cur;
				s.pop();
				cur = NULL;
			}
		}
		cout << endl;
	}

	///后续遍历,双桟法
	void PostOrder_Non_Two_Stack()
	{
		if (_root == NULL)
			return;

		stack<Node*> s1, s2;
		s1.push(_root);

		while (!s1.empty())
		{
			Node* top = s1.top();
			s1.pop();
			s2.push(top);
			if (top->_left)
				s1.push(top->_left);
			if (top->_right)
				s1.push(top->_right);
		}

		while (!s2.empty())
		{
			Node* top = s2.top();
			cout << top->_data << " ";
			s2.pop();
		}
		cout << endl;
	}

	求结点的个数/
	//递归
	size_t Size()
	{
		size_t _size = _Size(_root);
		return _size;
	}

	//加在一个静态变量上引入多线程安全问题///
	size_t Size1()
	{
		size_t _size1 = _Size1(_root);
		return _size1;
	}

	///引用解决了多线程安全问题/
	size_t Size2()
	{
		int index = 0;
		size_t _size2 = _Size2(_root, index);
		return _size2;
	}
	
	///求二叉树的高度/
	size_t Height()
	{
		size_t height = _Height(_root);
		return height;
	}

	///求叶子结点的个数//
	size_t LeafNum()
	{
		size_t leaf = _LeafNum(_root);
		return leaf;
	}

	///查找一个数据///
	bool Find(const T& x)
	{
		return _Find(_root, x);
		
	}

	求第k层结点的个数
	size_t KLayerOfNodeNum(int k)
	{
		size_t num = 0;
		num = _KLayerOfNodeNum(_root,k);
		return num;
	}

	///求二叉树的镜像
	void GetMirror()
	{
		_root = _GetMirror(_root);
	}

#include<queue>

	//判断二叉树是不是完全二叉树
	///方法一：广度优先遍历二叉树

	bool IsCompleteBinaryTree()
	{
		if (_root == NULL)
			return true;

		//bool isCompleteTree = false;
		bool HasLeftNoRight = false;
		queue<Node*> q;
		q.push(_root);
		while (!q.empty())
		{
			Node* front = q.front();
			q.pop();

			//第二次遇到只有左子树的结点
			if (front->_left && front->_right == NULL && HasLeftNoRight)
			{
				return false;
			}

			if (front->_left && front->_right)
			{
				//在遇到只有左子树的情况之后，必定不能往进去压结点
				if (HasLeftNoRight)
				{
					return false;
				}
				q.push(front->_left);
				q.push(front->_right);
			}
			else if (front->_left && front->_right == NULL && !HasLeftNoRight)
			{
				q.push(front->_left);

				//HasLeftNoRight为true时表示已经遇到只有左子树的情况
				HasLeftNoRight = true;
			}
			else if (front->_left == NULL && front->_right)
			{
				return false;
			}
			else
			{
				//isCompleteTree = true;
			}
		}
		 //return isCompleteTree;
		return true;
	}

	方法二：按照完全二叉树的定义,左树的深度大于等于右树的深度/
	///一棵树一棵树的递归，前序遍历的过程//
	bool IsCompleteBinaryTree2()
	{
		return _IsCompleteBinaryTree2(_root);
	}

protected:
	void _CreateBinaryTree(Node*& root, const T* arr, int len, int& index, const T& invalid)
	{
		if (root == NULL && index < len && arr[index] != invalid)
		{
			root = new Node(arr[index]);
			_CreateBinaryTree(root->_left, arr, len, ++index, invalid);
			_CreateBinaryTree(root->_right, arr, len, ++index, invalid);
		}
	}

	void _ReBuildCreateBinaryTree(Node*& root, T* Prev, T* InOrder, \
		int len)
	{
		if (Prev == NULL && InOrder == NULL && len <= 0)
			return;

		return _ReBuildTree(root, Prev, Prev + len - 1, InOrder, InOrder + len - 1);
	}

	void _ReBuildTree(Node*& root,T* StartPre,T* EndPre, \
		T* StartIn, T* EndIn)
	{
		//1.前序确定根结点
		int rootValue = StartPre[0];
		root = new Node(rootValue);

		//2.(1).只有一个结点
		if (StartPre == EndPre)
		{
			if (StartIn == EndIn && *StartPre == *StartIn)
			{
				return;
			}
			else
			{
				cout << "Prev and InOrder is not Catching!" << endl;
				return;
			}
		}

		//2.(2).有多个结点,通过在中序中找到根结点
		T* rootIn = StartIn;
		while (rootIn < EndIn && *rootIn != root->_data)
		{
			++rootIn;
		}

		if (rootIn == EndIn && *rootIn != root->_data)
		{
			cout << "Prev and InOrder is not Catching!" << endl;
			return;
		}

		//3.上面找到根结点，同时通过此中序中的根结点计算出左子树结点的个数
		int NumOfLeft = rootIn - StartIn;

		//4.通过根的左子树的个数在前序中计算左子树最后一个数据的位置
		T* LastPlaceOfLeft = StartPre + NumOfLeft;

		//5.递归构建左子树
		if (NumOfLeft > 0)
		{
			_ReBuildTree(root->_left, StartPre + 1, LastPlaceOfLeft, StartIn, rootIn - 1);
		}

		//6.递归构建右子树
		if (NumOfLeft < EndPre - StartPre)
		{
			_ReBuildTree(root->_right, LastPlaceOfLeft + 1, EndPre, rootIn + 1, EndIn);
		}
	}

	void _PreOrder(Node* root)
	{
		if (root == NULL)
			return;
		cout << root->_data << " ";
		_PreOrder(root->_left);
		_PreOrder(root->_right);
	}

	void _InOrder(Node* root)
	{
		if (root == NULL)
			return;
		_InOrder(root->_left);
		cout << root->_data << " ";
		_InOrder(root->_right);
	}

	void _PostOrder(Node* root)
	{
		if (root == NULL)
			return;
		_PostOrder(root->_left);
		_PostOrder(root->_right);
		cout << root->_data << " ";
	}

	size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;
		return _Size(root->_left) + _Size(root->_right) + 1;
	}

	size_t _Size1(Node* root)
	{
		if (root == NULL)
			return 0;
		static int count = 0;
		++count;
		_Size1(root->_left);
		_Size1(root->_right);
		return count;
	}

	size_t _Size2(Node* root,int& count)
	{
		if (root == NULL)
			return 0;

		++count;
		_Size2(root->_left, count);
		_Size2(root->_right, count);
		return count;
	}
	
	size_t _Height(Node* root)
	{
		if (root == NULL)
			return 0;
		size_t left = _Height(root->_left);
		size_t right = _Height(root->_right);
		return left + 1 > right + 1 ? left + 1 : right + 1;
	}

	size_t _LeafNum(Node* root)
	{
		if (root == NULL)
			return 0;
		if (root->_left == NULL && root->_right == NULL)
			return 1;
		size_t leftOfLeaf = _LeafNum(root->_left);
		size_t rightOfLeaf = _LeafNum(root->_right);
		return leftOfLeaf + rightOfLeaf;
	}

	bool _Find(Node*& root, const T& x)
	{
		if (root && root->_data == x)
			return true;

		if (root->_left)
			return _Find(root->_left, x);

		if (root->_right)
			return _Find(root->_right, x);

		return false;
	}

	size_t _KLayerOfNodeNum(Node* root,const int& k)
	{
		if (root == NULL || k < 1)
			return 0;

		if (k == 1)
			return 1;

		//k层结点=左子树的k - 1层的结点 + 右子树的k - 1层的结点
		size_t KOfLeft = _KLayerOfNodeNum(root->_left, k - 1);
		size_t ROfRight = _KLayerOfNodeNum(root->_right, k - 1);
		return KOfLeft + ROfRight;
	}
	
	Node* _GetMirror(Node* root)
	{
		if (root == NULL)
			return NULL;

		//求左子树与右子树的镜像
		Node* leftMirror = _GetMirror(root->_left);
		Node* rightMirror = _GetMirror(root->_right);

		//交换左右子树 
		root->_left = rightMirror;
		root->_right = leftMirror;
		return root;
	}

	bool _IsCompleteBinaryTree2(Node* root)
	{
		if (root == NULL)
			return true;

		int left = _Height(root->_left);
		int right = _Height(root->_right);
		if (left - right < 0 || left - right > 1)
		{
			return false;
		}

		return _IsCompleteBinaryTree2(root->_left) && _IsCompleteBinaryTree2(root->_right);
	}

private:
	Node* _root;
};

void TestBinaryTree()
{
	//int a[10] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6 };
	//int a[15] = { 1, 2, '#', 3, '#', '#', 4, 5, '#', 6, '#', 7, '#', '#', 8 };
	//int a[] = { 1, 2, '#', 3, '#', '#', 4, 5, 6, '#', 7, 8 };
	int a[] = { 0, 1, 3, 7,'#', '#', 8, '#', '#', 4, 9, '#', '#','#', 2, 5, '#', '#', 6 };
	//int a[] = { 1, 2, '#', 4, '#', '#', 3};
	BinaryTree<int> bt(a, sizeof(a) / sizeof(a[0]),'#');
	//前、中、后三种遍历的递归测试及层次遍历测试
	bt.PreOrder();
	bt.InOrder();                            
	bt.PostOrder();
	bt.LevelTraverse();

	//前、中、后三种遍历的非递归测试
	bt.PreOrder_Non();
	bt.InOrder_Non();
	bt.PostOrder_Non();
	bt.PostOrder_Non_Two_Stack();

	//总结点个数、高度、叶子结点个数、k层结点个数、查找函数及二叉树镜像问题
	cout <<"Size():"<< bt.Size() << endl;
	cout <<"Size1():"<< bt.Size1() << endl;
	cout <<"Size2():"<< bt.Size2() << endl;
	cout <<"Height:"<< bt.Height() << endl;
	cout <<"LeafNum():"<< bt.LeafNum() << endl;
	cout <<"KLayerOfNodeNum(3):"<< bt.KLayerOfNodeNum(3) << endl;
	//bt.GetMirror();
	cout << "IsCompleteBinaryTree()?" << bt.IsCompleteBinaryTree() << endl;
	cout << "IsCompleteBinaryTree2()?" << bt.IsCompleteBinaryTree2() << endl;
}

void TestPrevAndInReBuildBinaryTree()
{
	int PrevOrder[] = { 0, 1, 3, 7, 8, 4, 9, 2, 5, 6 };
	int InOrder[] = { 7, 3, 8, 1, 9, 4, 0, 5, 2, 6 };

	BinaryTree<int> bt(PrevOrder, InOrder, sizeof(PrevOrder) / sizeof(PrevOrder[0]));
}</span>