C++二叉树相关操作

C++实现二叉树的相关操作，包括递归和非递归方式。

二叉树的基本结构

struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {

	}
};

遍历

前序遍历

遍历顺序：根左右。
递归方式

/**
* @description 前序遍历(递归)
* @param root
* @return
*/
void preOrderRecur(TreeNode *root) {
	if (root == nullptr) {	// 递归终止条件
		return;
	}
	cout << root->val << " ";	// 前序遍历当前结点
	preOrderRecur(root->left);	// 前序遍历左子树
	preOrderRecur(root->right);	// 前序遍历右子树
	return;
}

非递归方式

/**
* @description 前序遍历(非递归)
* @param root
* @return
*/
void preOrderUnRecur(TreeNode* root) {
	if (root == nullptr) {
		return;
	}
	stack<TreeNode*> nstack;
	nstack.push(root);
	while (!nstack.empty()) {
		TreeNode* root = nstack.top();  //栈顶节点出栈
		cout << root->val << " ";
		nstack.pop();
		if (root->right != nullptr) {	//后遍历的节点先入栈
			nstack.push(root->right);
		}
		if (root->left != nullptr) {	//先遍历的节点后入栈
			nstack.push(root->left);
		}
	}
	return;
}

中序遍历

遍历顺序：左根右。
递归方式

/**
* @description 中序遍历(递归)
* @param root
* @return
*/
void inOrderRecur(TreeNode* root) {
	if (root == nullptr) {	// 递归终止条件
		return;
	}
	inOrderRecur(root->left);	// 中序遍历左子树
	cout << root->val << " ";	// 中序遍历当前结点
	inOrderRecur(root->right);	// 中序遍历右子树
	return;
}

非递归方式

/**
* @description 中序遍历(非递归)
* @param root
* @return
*/
void inOrderUnRecur(TreeNode* root) {
	if (root == nullptr) {
		return;
	}
	stack<TreeNode*> nstack;
	while (!nstack.empty() || root != nullptr) {
		if (root != nullptr) {
			nstack.push(root);
			root = root->left;	//左节点先入栈
		}
		else {
			root = nstack.top();	//栈顶节点出栈
			cout << root->val << " ";
			nstack.pop();
			root = root->right;	//左节点后入栈
		}
	}
	return;
}

后序遍历

遍历顺序：左右根。
递归方式

/**
* @description 后序遍历(递归)
* @param root
* @return
*/
void posOrderRecur(TreeNode* root) {
	if (root == nullptr) {
		return;
	}
	posOrderRecur(root->left);	// 后序遍历左子树
	posOrderRecur(root->right);	// 后序遍历右子树
	cout << root->val << " ";	// 后序遍历当前结点
	return;
}

非递归方式

/**
* @description 后序遍历(非递归)
* @param root
* @return
*/
void posOrderUnRecur(TreeNode* root) {
	if (root == nullptr) {
		return;
	}
	stack<TreeNode*> nstack1, nstack2;
	nstack1.push(root);
	while (!nstack1.empty()) {
		TreeNode* root = nstack1.top();
		nstack2.push(root);
		nstack1.pop();
		if (root->left != nullptr) {	// 左节点先入栈2，后入栈1
			nstack1.push(root->left);
		}
		if (root->right != nullptr) {	// 右节点先入栈1，后入栈2
			nstack1.push(root->right);
		}
	}

	while (!nstack2.empty()) {	//栈2出栈
		cout << nstack2.top()->val << " ";
		nstack2.pop();
	}
	return;
}

层次遍历

遍历顺序：从上往下，每层从左往右。即广度优先搜索。
递归方式

非递归方式

/**
* @description 层次遍历(非递归)
* @param root
* @return 层次遍历vector
*/
vector<int> bfs(TreeNode *root)//返回的是一个int的vector
{
	vector<int>res;
	queue<TreeNode *>q;//辅助队列

	if (root == nullptr) {
		return res;
	}
	q.push(root);

	while (!q.empty())
	{
		//根节点出队列并保存，其左右孩子入队列
		res.push_back(q.front()->val);
		if (q.front()->left != nullptr)
		{
			q.push(q.front()->left);
		}
		if (q.front()->right != nullptr)
		{
			q.push(q.front()->right);
		}
		q.pop();//弹出第一个元素
	}
	return res;
}