二叉树前序、中序、后序遍历、层序（广度优先)遍历、深度优先遍历具体代码实现

1. 前序遍历

// 递归实现
void preOrder(TreeNode* root){
    if(root != nullptr){
        cout<<root->data<<" ";
        preOrder(root->left);
        preOrder(root->right);
    }
}
// 迭代实现
void preOrder(TreeNode* root){
    if(root == nullptr) return;
    TreeNode* node = nullptr; 
    stack<TreeNode*> S; 
    S.push(root); // 初始化栈
    while(!S.empty()){
        node = S.top();
        cout << node->val << " "; 
        S.pop(); 
        // 先右后左
        if(node != nullptr) S.push(cur->right);  
        if(node != nullptr) S.push(cur->left);  
    }
}

2. 中序遍历

迭代遍历规则：对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按照相同的规则访问其 右子树。

// 递归实现
void inOrder(TreeNode* root){
    if(root != nullptr){
        preOrder(root->left);
        cout << root->val << " ";
        preOrder(root->right);
    }
}
// 迭代实现

void inOrder(TreeNode* root){
    if(root == NULL) return;
    stack<TreeNode*> S;
    TreeNode* p = root;
    while(p!=nullptr|| !S.empty()){
    	while(p != NULL)}{ 
 		  S.push(p);
        	  p= p->left;
    	}
           // 不断循环进左节点结束，出栈  
        	TreeNode* node = S.top();
            S.pop();
            cout << node->val << " ";   // 中序遍历：在弹出栈顶指针时访问
            p = node->right; // 指向左节点
    }
}

3. 后序遍历

迭代遍历规则：可以先将前序遍历换成跟先右后左进行遍历，最后将得到的结果翻转即为后序遍历的结果。

void postOrder(TreeNode* root){
    if(root != nullptr){
        postOrder(root->left);
        postOrder(root->right);
        cout << root->val << " ";
    }
}

void postOrder(TreeNode* root){
    vector<int> res;
    if (root == nullptr) return res;
    stack<TreeNode*> S;
    S.push(root);
    while(!S.empty())) {
        TreeNode* node = S.top();
        S.pop();
        res.push_back(node->val);
        if(node->left) S.push(node->left);
        if(node->right) S.push(node->right);

    }
    reverse(res.begin(), res.end());
    return res;
}

4. 层序遍历

void levelOrder(TreeNode* root){
    if(root == nullptr) return;
    queue<TreeNode*> Q;
    Q.push(root);
    while(!Q.empty()){
        TreeNpde* node = Q.front();
        Q.pop();
        cout << node->val << " ";
        if(node->left) Q.push(node->left);
        if(node->right) Q.push(node->right);
    }
}

5. 深度优先遍历

// 递归实现
void depthOrder(TreeNode* root){
    if(root == nullptr) return;
    depthOrder(root->left);
    depthOrder(root->right);
}
// 迭代实现
void depthOrder(TreeNode* root){
    if(root == nullptr) return;
    stack<int> S;
    S.push(root);
    while(!S.empty()){
       TreeNode* node = S.pop();
       cout << node->val << " "; // 先进右节点，再进左节点，形成前序遍历
       if(node->right) S.push(node->right);
       if(node->left) S.push(node->left); 
    }
}