二叉树( C++ ) 遍历(递归 非递归)、最大深度

二叉树( C++ )

遍历

递归

#include<bits/stdc++.h>
using namespace std;
// 结构体
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    // 构造函数
    // TreeNode(int x):val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x) {
        val = x;
        left = nullptr;
        right = nullptr;
    }
};


// 中序遍历 
void traversal(TreeNode *cur, vector<int> &vec) {
   if (cur == nullptr) return;
    traversal(cur->left, vec);  // 左
    vec.push_back(cur->val);    // 中
    traversal(cur->right, vec); // 右
}


int main() {
    // 创建树
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    vector<int> result;
    traversal(root,result);
    /*
                1
              /  \
             2    3
            / \  
           4  5
    
    */
    // 遍历 root 
    for(int num: result) {
        cout << " " << num <<" ";   // 4 2 5 1 3
    }

    // 释放 资源
    delete root->left->left;
    delete root->left->right;
    delete root->left;
    delete root->right;
    delete root;
return 0;
}

迭代法(栈)

#include<bits/stdc++.h>
using namespace std;

// 结构体
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    // 构造函数
    // TreeNode(int x):val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x) {
        val = x;
        left = nullptr;
        right = nullptr;
    }
};
 
 // 前序遍历
void preorderTraversal(TreeNode *root,vector<int> &vec) {
    // 出栈 判断是否有左右分支 如果有就是左右分支入栈 ( 先入 右边 再入 左边 )
    stack<TreeNode*> st;
    if(root == nullptr) {
        return;
    }
    st.push(root);
    while (!st.empty())
    {
        TreeNode* node = st.top();
        st.pop();  // 出栈
        vec.push_back(node->val); // 保存
        if(node->right !=  nullptr ) {
            st.push(node->right);
        }
        if(node->left) {
            st.push(node->left);
        }
    } 
}


// 中序遍历 
void inorderTraversal(TreeNode *root,vector<int> &vec) {
    stack<TreeNode*> st;
    TreeNode* cur = root;
    while(cur != nullptr || !st.empty()) {
        if(cur != nullptr) {
            st.push(cur);
            cur = cur->left;
        }
        // 到达最左边 
        else {
            // 出栈
            cur = st.top();
            st.pop();   
            vec.push_back(cur->val);
            cur = cur->right;
        }
    }
}


// 后序遍历


int main() {
    // 创建树
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    vector<int> result;
    preorderTraversal(root,result);
    // 打印 
      for(int num: result) {
        cout << " " << num <<" ";   // 4 2 5 1 3
    }
    // 释放 资源
    delete root->left->left;
    delete root->left->right;
    delete root->left;
    delete root->right;
    delete root;
return 0;
}

最大深度

#include<bits/stdc++.h>
using namespace std;
// 结构体
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    // 构造器
     TreeNode(int x) {
        val = x;
        left = nullptr;
        right = nullptr;
    }
};

int result;  // 表示数的高度

// 计算树木的深度   通过前序遍历完成
void TreeDepth(TreeNode* node,int depth) {
    // 中间 比较
    if(result < depth) {
        result = depth;
    }

    // 终止条件
    if(node->left == nullptr && node->right == nullptr) {
        return;
    }
    // 左边
    if(node->left) {
        depth++;
        // 左边
        TreeDepth(node->left,depth);
        depth--;
    }

    // 右边
    if(node->right) {
        depth++;
        // 左边
        TreeDepth(node->right,depth);
        depth--;
    }
    return;
}

// 计算数最大深度
int  getdepth(TreeNode* node) {
    if(node == nullptr) {
        return 0;
    }
    // 后序遍历 左右中
    // 左
    int leftheight = getdepth(node->left);
    // 右边
    int rightheight = getdepth(node->right);
    // 中间
    int res = 1 + max(leftheight, rightheight);
return res;  // 注意这里 res 可能会赋值给 leftheight 或者 rightheight
}




/*
               1
              /  \
             2    3
            / \  
           4  5

*/


int main() {
 // 创建树
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);


    // 计算树的深度
    result = 0;
    if(root == nullptr) {
        return result;
    }
    // 调用函数
    TreeDepth(root, 1); 
    cout<< result<<endl;
    int res = getdepth(root);
    cout<< res<<endl;
    // 释放 资源
    delete root->left->left;
    delete root->left->right;
    delete root->left;
    delete root->right;
    delete root;

return 0;
}