树treenode

树

1.0 题目

1、力扣257题：二叉树的所有路径
2、力扣112题：路径总和

---

1.1 二叉树的分类

1.1.1 满二叉树

如果一棵树只有度为0的节点和度为2的节点，并且度为0的节点在同一层上，则这棵二叉树是满二叉树；

---

1.1.2 完全二叉树

除了底层节点可能没填满，其余每层的节点数都达到最大值，并且底层的节点都集中在最左边的若干位置；

---

1.1.3 二叉搜索树

• 若它的左子树不空，则左子树上所有的节点的值均小于它的根节点的值；
• 若它的右子树不空，则右子树上所有的节点的值均大于它的根节点的值；
• 它的左、右子树也分别为二叉搜索树；

---

1.1.4 平衡二叉搜索树

平衡二叉搜索树又叫AVL树，它是一颗空树，或者左右两个子树的高度差不超过1，并且左右两个子树都是一颗平衡二叉树；

---

1.2 二叉树的遍历方式

1.2.0 二叉树定义

struct tree_node {
    int val;
    tree_node *left;
    tree_node *right;
    tree_node(int val) : val(val), left(nullptr), right(nullptr) {}
}

1.2.1 深度优先遍历

• 递归法

# 前序遍历
void preorder(tree_node *cur, vector<int> &vec)
{
    if (cur == NULL) return;
    vec.push_back(cur.val);
    preorder(cur->left, vec);
    preorder(cur->right, vec);
}
# 中序遍历
void inorder(tree_node *cur, vector<int> &vec)
{
    if (cur == NULL) return;
    inorder(cur->left, vec);
    vec.push_back(cur.val);
    inorder(cur->right, vec);
}
# 后序遍历
void postorder(tree_node *cur, vector<int> &vec)
{
    if (cur == NULL) return;
    postorder(cur->left, vec);
    postorder(cur->right, vec);
    vec.push_back(cur.val); 
}

• 迭代法

# 前序遍历
vector <int> preorder(tree_node *root)
{
    stack<tree_node *> st;
    vector<int> result;
    if (root =! NULL) st.push(root);
    while(!st.empty()) {
        tree_node *node = st.top();
        if (node != NULL) {
            st.pop();
            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
            st.push(node);
            st.push(NULL);
        } else {
            st.pop();
            node = st.top();
            st.pop();
            result.push_back(node->val);
        }
    }
}
# 中序遍历
vector <int> preorder(tree_node *root)
{
    stack<tree_node *> st;
    vector<int> result;
    if (root =! NULL) st.push(root);
    while(!st.empty()) {
        tree_node *node = st.top();
        if (node != NULL) {
            st.pop();
            if (node->right) st.push(node->right);
            st.push(node);
            st.push(NULL);
            if (node->left) st.push(node->left);
        } else {
            st.pop();
            node = st.top();
            st.pop();
            result.push_back(node->val);
        }
    }
}

# 后序遍历
vector <int> preorder(tree_node *root)
{
    stack<tree_node *> st;
    vector<int> result;
    if (root =! NULL) st.push(root);
    while(!st.empty()) {
        tree_node *node = st.top();
        if (node != NULL) {
            st.pop();
            st.push(node);
            st.push(NULL);
            if (node->right) st.push(node->right);

            if (node->left) st.push(node->left);
        } else {
            st.pop();
            node = st.top();
            st.pop();
            result.push_back(node->val);
        }
    }
}

---

1.2.1 广度优先遍历

vector<vector<int>> level_order(tree_node *root)
{
    queue<tree_node*> que;
     if (root != NULL) que.push(root);
     vector<vector<int>> result;
     while(!que.empty()) {
        int size = que.size();
        vector<int> vec;
        for (int i = 0; i < size; i++) {
            tree_node *node = que.front();
            que.pop();
            vec.push_back(node->val);
            if (node->left) que.push(node->left);
            if (node->right) que.push(node->right);
        }
        result.push_back(vec);
     }
     return result;
}