02 diversos recorrido de árbol (después de la primera recursivo y no recursivo en traversal orden, atraviesan el nivel)

Después de atravesar el árbol binario antes, recursivo y no recursivo

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

};

recursividad

preorden:

void PreOrderTraversal(TreeNode* root) {
	if (!root) {
		return;
	}
	cout << root->val << " ";
	PreOrderTraversal(root->left);
	PreOrderTraversal(root->right);
}

preorden

void InOrderTraversal(TreeNode* root) {
	if (!root) {
		return;
	}
	InOrderTraversal(root->left);
	cout << root->val << " ";
	InOrderTraversal(root->right);
}

postorden

void PostOrderTraversal(TreeNode* root) {
	if (!root) {
		return;
	}
	PostOrderTraversal(root->left);
	PostOrderTraversal(root->right);
	cout << root->val << " ";
}

Los tres transversal de la misma, sólo diferente ubicación a la salida.
Para empezar, si el ganado o el poder botón de apagado por encima de preguntas, entonces, además de su función y los nombres de variables cambian fuera de la definición de un resultado vectorial en una función, a continuación, toda la producción en result.push_back (Raíz> val) , junto con el resultado de retorno, se puede.

A no recursiva

Una travesía no recursiva se basa principalmente en la pila de lograr:

preorden:

vector<int> PreOrderTra(TreeNode* root) {
	vector<int>result;
	if (root == NULL) return result;
	stack<TreeNode*>s;
	TreeNode* p = root;
	while (p != NULL || !s.empty()) {
		while (p != NULL) {			//遍历左子树
			result.push_back(p->val);
			s.push(p);				//把遍历的节点全部压栈。
			p = p->left;
		}
		if (!s.empty()) {
			p = s.top();	//得到栈顶内容
			s.pop();		//出栈
			p = p->right;	//指向右子节点，下一次循环时，就会先续遍历左子树
		}
	}
	return result;
}

preorden

vector<int> InOrderTra(TreeNode* root) {
	vector<int>result;
	if (root == NULL) return result;
	stack<TreeNode*>s;
	TreeNode* p = root;
	while (p != NULL || !s.empty()) {
		while (p != NULL) {			//遍历左子树			
			s.push(p);				//把遍历的节点全部压栈。
			p = p->left;
		}
		if (!s.empty()) {
			p = s.top();	//得到栈顶内容
			s.pop();		//出栈
			result.push_back(p->val);
			p = p->right;	//指向右子节点，下一次循环时，就会先续遍历左子树
		}
	}
	return result;
}

postorden

Orden posterior diferente frente y
necesidad de orden posterior para acceder al nodo raíz después de caminar los subárboles izquierdo y derecho. Se requiere la determinación de si los subárboles izquierdo y derecho del nodo raíz son atravesados

método de marcaje pueden ser empleados, la pila de nodo, el conjunto de pila con una etiqueta FLAG (campo de la etiqueta para proteger la parte delantera del recorrido subárbol izquierdo representa 0, 1 representa un campo de etiqueta está protegido antes de atravesar subárbol derecho)
primera etiqueta y T ( 0) pila, recorrer el subárbol izquierdo; devoluciones, etiqueta de pila de modificación es 1, atravesar el subárbol derecho; y, finalmente, el acceso root

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

};

vector<int> PostOrderTra(TreeNode* root) {
	vector<int>result;
	if (root == NULL) return result;
	stack<TreeNode*>s;
	TreeNode* p = root;
	while (p != NULL || !s.empty()) {
		while (p != NULL) {			//遍历左子树			
			s.push(p);				//把遍历的节点全部压栈。
			p = p->left;
		}
		if (!s.empty()) {
			p = s.top();	//得到栈顶内容
			if (p->tag) {	//tag为1时
				result.push_back(p->val);
				s.pop();		//出栈
				p = NULL;		//第二次访问标志其柚子树已经遍历
			}
			else {
				p->tag = 1;		//修改tag为1
				p = p->right;	//指向右节点，下次遍历其左子树
			}
		}
	}
	return result;
}

// travesía del nivel

vector<int> LeveOrderTra(TreeNode* root) {
	vector<int>result;
	queue<TreeNode*>q;
	TreeNode* ptr = NULL;
	q.push(root);			//根节点入队
	while (!q.empty()) {	
		ptr = q.front();	//得到头结点
		q.pop();			
		result.push_back(ptr->val);	
		if (ptr->left != NULL) {	//当前节点存在左节点则左节点入队
			q.push(ptr->left);
		}
		if (ptr->right != NULL) {	//当前节点存在右节点则右节点入队
			q.push(ptr->right);
		}
	}
	return result;
}