树的非递归遍历（深度优先：前|中|后序遍历) & (广度优先：层次遍历）

Notes:( http://en.wikipedia.org/wiki/Tree_traversal) （看了几天简单总结下， 多多指教）

1. Because from a given node there is more than one possible next node(it is not a linear data structure),

then, assuming sequential computation(not parallel),some nodes must be deferred-stored in some way

for later visiting. (Stack || Queue)

2. The name given to a particular style of traversal comes from the order in which nodes are visited.Most

 simply, does one go down first(DepthFirst: PreOrder | InOrder | PostOrder), or across first(Breadth-First: LevelOrder).

3. The trace of a traversal is called a sequentialization of the tree. Either pre-order or post-order paired

 with in-order is sufficient to describe the tree uniquely,while pre-order with post-order leaves some

 ambiguity in the tree structure.

Implementations:

PreOrder: 

void PreOrder_Recur(struct node* root) {
	if (root == NULL)
		return ;
	printf("%d ", root->data);
	Recursive(root->left);
	Recursive(root->right);
}

// Iterative Implementation
void PreOrder1(struct node* root) {
	if (root == NULL)
		return ;
	stack<BiTree> s;

	while (root) {
		printf("%d ", root->data);
		s.push(root);
		root = root->left;
	}
	while (!s.empty()) {
		struct node* temp = s.top()->right;
		s.pop();
		while (temp) {
			printf("%d ", temp->data);
			s.push(temp);
			temp = temp->left;
		}
	}
}
void PreOrder2(struct node* root) {
	if (root == NULL)
		return ;
	stack<BiTree> s;
	s.push(root);
	while (!s.empty()) {
		struct node* node = s.top();
		printf("%d ", node->data);
		s.pop();

		if (node->right)
			s.push(node->right);
		if (node->left)
			s.push(node->left);
	}
}
void PreOrder3(struct node* node) {
	if (node == NULL)
		return ;
	stack<BiTree> s;
	while (!s.empty() || node != NULL) {
		if (node != NULL) {
			printf("%d ", node->data);
			s.push(node->right);
			node = node->left;
		} else {
             node = s.top();
             s.pop();
		}
	}
} 

void InOrder(struct node* node) {
	if (node == NULL)
		return ;

	stack<BiTree> s;
	while (node) {
		s.push(node);
		node = node->left;
	}
	while (!s.empty()) {
		struct node* temp = s.top()->right;
		printf("%d ", s.top()->data);
		s.pop();

		while (temp) {
			s.push(temp);
			temp = temp->left;
		}
	}
}

void InOrder2(struct node* node) {
	if (node == NULL)
		return ;

	stack<BiTree> s;
	while (!s.empty() || node) {
		if (node != NULL) {
			s.push(node);
			node = node->left;
		} else {
			node = s.top();
			printf("%d ", node->data);
			s.pop();
			node = node->right;
		}
	}
}

//using one stack
void PostOrder(struct node* node) {
    if (node == NULL)
        return ;
    stack<BiTree> s;
    s.push(node);
    BiTree prev = NULL;

    while (!s.empty()) {
        struct node* currNode = s.top();
        if (prev == NULL || prev->left == currNode ||
                    prev->right == currNode) {
            if (currNode->left)
                s.push(currNode->left);
            else if (currNode->right)
                s.push(currNode->right);
        } else if (currNode->left == prev) {
            if (currNode->right)
                s.push(currNode->right);
        } else {
            printf("%d ", currNode->data);
            s.pop();
        }
        prev = currNode;
    }
}
//using two stack. (NLR | NRL | LRN)
//using a visited flag (above two to LRN)

//For BFS, using queue is easy.  
//Above 3 questions if needed , I will add it next time.