【C++】二叉树

一、二叉树的种类

1、 满二叉树

• 只有度为0和2的节点；度为0的节点在同一层上

2、完全二叉树

• 除底层没有填满，底层节点集中在左边

3、二叉搜索树

• 二叉搜索树的节点有数值，且左值<根值<右值

4、平衡二叉树

• 又称AVL树，左右两个子树的高度差的绝对值不超过1
• C++中：map、set、multimap、multiset的底层实现都是平衡二叉树；
• unordered_map、unordered_set、unordered_multimap、unordered_multiset的底层实现是哈希表

二、二叉树的存储方式

• 二叉树既可以链式存储；也可以顺序储存。
• 链式存储：指针
• 顺序储存：数组【父节点i，左孩子2i+1，右孩子2i+2】

三、二叉树的遍历方式

1、深度优先

• 先往深处遍历，遇到叶子节点再往回遍历
• 递归法、迭代法【可以使用栈实现】

（1）前序遍历

• 根→左→右
• 递归法：

void traversal(TreeNode *cur,vector<int>& vec){
	if(cur==nullptr) return;//终止条件
	vec.push_back(cur->val);//根
	traversal(cur->left,vec);//左
	traversal(cur->right,vec);//右
}

• 迭代法：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;//利用栈实现二叉树前中后序遍历
        vector<int> vec;
        if(root==nullptr) return vec;
        st.push(root);
        while(!st.empty()){
            TreeNode* node=st.top();
            st.pop();
            if(node!=nullptr) vec.push_back(node->val);
            if(node->right!=nullptr) st.push(node->right);//入栈先右后左
            if(node->left!=nullptr) st.push(node->left);//出栈先左后右
        }   
        return vec;
    }
};

（2） 中序遍历

• 左→根→右
• 递归法：

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

• 迭代法：

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;//利用栈实现二叉树前中后序遍历
        vector<int> vec;
        TreeNode* node=root;//先访问的是根节点
        while(node!=nullptr||!st.empty()){
            if(node!=nullptr){
                st.push(node);//一层一层访问，直到最左边
                node=node->left;//左
            }
            else{
                node=st.top();//然后开始出栈处理
                st.pop();
                vec.push_back(node->val);//中
                node=node->right;//右
            }
        }
        return vec;
    }
};

（3） 后序遍历

• 左→右→根
• 递归法：

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

• 迭代法：

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> vec;
        if(root==nullptr) return vec;
        st.push(root);
        while(!st.empty()){
            TreeNode* cur=st.top();
            st.pop();
            if(cur!=nullptr) vec.push_back(cur->val);//中
            if(cur->left!=nullptr) st.push(cur->left);//入栈左右
            if(cur->right!=nullptr) st.push(cur->right);//出栈右左
            
        }
        reverse(vec.begin(),vec.end());//反转中右左，变为左右中
        return vec;

    }
};

2、广度优先

• 一层一层遍历
• 迭代法【可以使用队列实现】

（1）层序遍历

class Solution {
public:
    vector<vector<int> > levelOrder(TreeNode* root) {
        queue<TreeNode*> que;//利用队列实现层序遍历
        if(root!=nullptr) que.push(root);
        vector<vector<int>> result; 
        while(!que.empty()){
            vector<int> vec;//保留每一层元素
            int size=que.size();
            for(int i=0;i<size;i++){
                TreeNode* 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;
    }
};

四、二叉树的定义

struct TreeNode{
	int val;//节点上的元素
	TreeNode *left;//指向下一个节点的左指针
	TreeNode *right;//指向下一个节点的右指针
	TreeNode(int val):val(val),left(nullptr),right(nullptr){}//节点的构造函数
};