二叉树的遍历方式及实现

前序遍历

若树为空，则空操作返回。否则，先访问根节点，然后前序遍历左子树，再前序遍历右子树。（中 左 右）

实现（递归）

void preOrder(Node *node){
    if(node){
        std::cout<<node->value;
        preOrder(node->left);
        preOrder(node->right);
    }
}

实现（非递归）

void preOrder1(Node *node){
    if(node==NULL){
        return;
    }
    std::stack<Node *> nstack;
    nstack.push(node);
    while(!nstack.empty()){
        Node *temp=nstack.top();
        std::cout<<temp->value;
        nstack.pop();
        if(temp->right){
            nstack.push(temp->right);
        }
        if(temp->left){
            nstack.push(temp->left);
        }
    }
}

中序遍历

若树为空，则空操作返回。否则，从根节点开始（注意并不是先访问根节点），中序遍历根节点的左子树，然后是访问根节点，最后中序遍历根节点的右子树。（M）型，（左 中 右）

实现（递归）

void inOrder(Node *node){
    if(node){
        inOrder(node->left);
        std::cout<<node->value;
        inOrder(node->right);
    }
}

实现（非递归）

void inOrder1(Node *node){
    std::stack<Node *> nstack;
    Node *temp=node;
    while(temp||!nstack.empty()){
        if(temp){
            nstack.push(temp);
            temp=temp->left;
        }
        else{
            temp=nstack.top();
            std::cout<<temp->value;
            nstack.pop();
            temp=temp->right;
        }
    }
}

后续遍历

若树为空，则空操作返回。否则，从左到右先叶子后节点的方式遍历访问左右子树，最后访问根节点。（左右中）逆时针型 （左 右 中）

实现（递归）

void posOrder(Node *node){
    if(node){
        posOrder(node->left);
        posOrder(node->right);
        std::cout<<node->value;
    }
}

实现（非递归）

void posOrder1(Node *node){
    if(node==NULL)
        return;
    std::stack<Node *> nstack1, nstack2;
    nstack1.push(node);
    while (!nstack1.empty()){
        Node *temp=nstack1.top();
        nstack1.pop();
        nstack2.push(temp);
        if(temp->left)
            nstack1.push(temp->left);
        if(temp->right)
           nstack1.push(temp->right);
    }
    while(!nstack2.empty())
    {
        std::cout<<nstack2.top()->value;
        nstack2.pop();
    }
}

层序遍历

若树为空，则空操作返回。否则，从树的第一层，也就是根节点开始访问，从上到下逐层遍历，在同一层中，按从左到右的顺序结点逐个访问。

实现

void Levelorder(TreeNode *T)
{
	if (!T)
		return;
	TreeNode *temp;
	queue<TreeNode*>q;
	q.push(T);
	while (!q.empty())
	{
		temp = q.front();
		cout << temp->val;
		if (temp->left)
			q.push(temp->left);
		if (temp->right)
			q.push(temp->right);
		q.pop();
	}
}

深度遍历

void DeepOrder(TreeNode *T)
{
	if (!T)
		return;
	TreeNode *temp;
	stack<TreeNode*>s;
	s.push(T);
	while (!s.empty())
	{
		temp = s.top();
		cout << temp->val;
		s.pop();
		if (temp->left)
			s.push(temp->left);
		if (temp->right)
			s.push(temp->right);
	}
}