Pré-ordre, ordre moyen, post-ordre, traversée hiérarchique d'arbre binaire récursif et non récursif

La traversée récursive est relativement simple ~

Pré-commande traversée-récursivité

void preOrderTraversal(TreeNode* root){
	if(root == nullptr){
		return;
	}
	visit(root);
	preOrderTraversal(root->left);
	preOrderTraversal(root->right);
}

Pré-commande - traversée non récursive - à l'aide de la pile

#include <iostream>
#include <stack>
#include <vector>
using namespace std;
vector<int> preOrderTraversal(TreeNode* root){
	vector<int> result;
	if(root == nullptr){
		return result;
	}
	stack<TreeNode*> s;
	s.push(root);
	while(!s.empty()){
		TreeNode* currentNode = s.pop();
		result.push_back(currentNode->value);
		if(currentNode->right){
			s.push(currentNode->right);
		}
		if(currentNode->left){
			s.push(currentNode->left);	
		}
		s.pop();
	}
	return result;
}

Traversée-récursivité dans l'ordre

void inOrderTraversal(TreeNode* root){
	if(root == nullptr){
		return;
	}
	inOrderTraversal(root->left);
	visit(root);
	inOrderTraversal(root->right);
}

Traversée d'ordre non récursif de niveau moyen à l'aide de la pile

#include <iostream>
#include <stack>
using namespace std;
vector<int> inOrderTraversal(TreeNode* root){
	vector<int> result;
	if(root == nullptr){
		return result;
	}
	stack<TreeNode*> s;
	TreeNode* currentNode = root;
	while(currentNode != nullptr){
		while(currentNode != nullptr){
			s.push(currentNode);
			currentNode = currentNode->left;
		}
		if(!s.empty()){
			currentNode = s.top();
			result.push_back(currentNode->value);
			currentNode = currentNode->right;
		}
	}
	return result;
}

Traversée post-récurrente

void postOrderTraversal(TreeNode* root){
	if(root == nullptr){
		return;
	}
	postOrderTraversal(root->left);
	postOrderTraversal(root->right);
	visit(root);
}

Implémentation de traversée non récursive de post-commande

Traversée-récursion de séquence

Implémentation de séquence non-récursive

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
vector<int> levelOrderTraversal(TreeNode* root){
	vector<int> result;
	if(root == nullptr){
		return result;
	}
	queue<TreeNode*> q;
	q.push(root);
	while(!q.empty()){
		TreeNode* currentNode = q.front();
		result.push(currentNode->value);
		if(currentNode->left != nullptr){
			result.push(currentNode->left);
		}
		if(currentNode->left != nullptr){
			result.push(currentNode->right);
		}
		q.pop();
	}
	return result;
}