算法村-二叉树的递归和迭代遍历

   二叉树的结构

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

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

前序遍历

//前序递归遍历
void preorderTraversal(TreeNode* root, vector<int>& result)
{
	if (root == nullptr) {
		return;
	}
	result.push_back(root->val);
	preorderTraversal(root->left, result);
	preorderTraversal(root->right, result);
}
//前序迭代遍历
vector<int> preorderTraversal1(TreeNode* root) {
	vector<int> res;
	if (root == nullptr) {
		return res;
	}
	
	stack<TreeNode*> s;
	TreeNode* node = root;
	while (!s.empty()||node!=nullptr)
	{
		while (node != nullptr) {
			
			res.emplace_back(node->val);
			
			s.emplace(node);
			node = node->left;
		}
		node = s.top();
		s.pop();
		node = node->right;
	}

	return res;
}

迭代前序遍历
emplace_back()函数用于在vector的尾部插入一个新元素。
emplace()函数用于在stack的顶部插入一个新元素。
第一轮 
[1,2]
[1,2]
第二轮
[1,2,3,4]
[1,3,4]
第三轮
[1,2,3,4]
[1,3]
第四轮
[1,2,3,4,5]
[1,5]
第五轮
[1,2,3,4,5]
[6]
第六轮
[1,2,3,4,5,6]
[7]
第七轮
[1,2,3,4,5,6,7]
[8]
第八轮
[1,2,3,4,5,6,7,8]

中序遍历
 

//中序递归遍历
void inorderTraversal(TreeNode* root, vector<int>& result) 
{ 
	if (root == nullptr) {
		return;
	} 
	inorderTraversal(root->left, result);
	result.push_back(root->val);
	inorderTraversal(root->right, result); 
}

//中序迭代遍历
vector<int> inorderTraversal1(TreeNode* root) {
	vector<int> res;
	if (root == nullptr) {
		return res;
	}
	stack<TreeNode*> s;
	TreeNode* node = root;
	while (!s.empty() || node != nullptr)
	{
		while (node != nullptr) {			
			s.emplace(node);
			node = node->left;
		}
		node = s.top();
		s.pop();
		res.emplace_back(node->val);	
		node = node->right;
	}
	return res;
}

第一轮
[1,2]
[2]
第二轮
[1,3,4]
[2,4]
第三轮
[1,3]
[2,4,3]
第四轮
[1,5]
[2,4,3,5]
第五轮
[1]
[2,4,3,5,1]
第六轮
[6]
[2,4,3,5,1,6]
第七轮
[7 ,8]
[2,4,3,5,1,6,8]
第八轮
[7]
[2,4,3,5,1,6,8,7]

后序遍历

//后序递归遍历
void postorderTraversal(TreeNode* root, vector<int>& result) {
	if (root == nullptr) { 
		return; 
	}
postorderTraversal(root->left, result);
postorderTraversal(root->right, result);
result.push_back(root->val);
}
//后序迭代遍历
vector<int> postorderTraversal1(TreeNode* root) {
	vector<int> res;
	if (root == nullptr) {
		return res;
	}
	stack<TreeNode*> st;
	st.push(root);
	TreeNode* cur = root;
	while (!st.empty()) {
		cur = st.top();
		st.pop();
		res.insert(res.begin(), cur->val);
		if (cur->left != nullptr) {
			st.push(cur->left);
		}
		if (cur->right != nullptr) {
			st.push(cur->right);
		}
	}

	return res;
}

迭代后序遍历
res.insert(res.begin(), cur->val);
每次从开始位置取值
第一轮
[1]
[1]
第二轮
[2,6]
[6,1]
第三轮
[2,7]
[7,6,1]
第四轮
[2,8]
[8,7,6,1]
第五轮
[2]
[2,8,7,6,1]
第六轮
[3]
[3,2,8,7,6,1]
第七轮
[4,5]
[5,3,2,8,7,6,1]
第八轮
[4]
[4,5,3,2,8,7,6,1]

测试数据

void test() {
	TreeNode nodeA = { 1, nullptr, nullptr };
	TreeNode nodeB = { 2, nullptr, nullptr };
	TreeNode nodeC = { 3, nullptr, nullptr }; 
	TreeNode nodeD = { 4, nullptr, nullptr };
	TreeNode nodeE = { 5, nullptr, nullptr };
	TreeNode nodeF = { 6, nullptr, nullptr };
	TreeNode nodeG = { 7, nullptr, nullptr }; 
	TreeNode nodeH = { 8, nullptr, nullptr };

	vector<int> preorder;
	vector<int> inorder;
	vector<int> postorder;
	vector<int> preorder1;
	vector<int> inorder1;
	vector<int> postorder1;
	nodeA.left = &nodeB;
	nodeA.right = &nodeF;

	nodeB.right = &nodeC;

	nodeC.left = &nodeD;
	nodeC.right = &nodeE;

	nodeF.right = &nodeG;
	nodeG.left = &nodeH;

	preorderTraversal(&nodeA, preorder);
	inorderTraversal(&nodeA, inorder);
	postorderTraversal(&nodeA, postorder);
	preorder1 = preorderTraversal1(&nodeA);
	inorder1 = inorderTraversal1(&nodeA);
	postorder1 = postorderTraversal1(&nodeA);
	cout << "迭代前序遍历: ";
	for (int num : preorder1) {
		cout << num << " ";
	}
	cout << endl;
	cout << "迭代中序遍历: ";
	for (int num : inorder1) {
		cout << num << " ";
	}
	cout << endl;
	cout << "迭代后序遍历: ";
	for (int num : postorder1) {
		cout << num << " ";
	}
	cout << endl;

	cout << "递归前序遍历: ";
	for (int num : preorder) {
		cout << num << " ";
	}
	cout << endl;

	cout << "递归中序遍历: ";
	for (int num : inorder) {
		cout << num << " ";
	}
	cout << endl;

	cout << "递归后序遍历: ";
	for (int num : postorder) {
		cout << num << " ";
	}
	cout << endl;
}