二叉树（一）

 参考文献：二叉树专题精讲 by代码随想录

二叉树的种类

二叉树的两种主要形式：

满二叉树

完全二叉树

 

满二叉树

定义：如果一颗二叉树只有度为0的节点和度为2的节点，并且度为0的节点在同一层上，则这课二叉树为满二叉树。

如图所示：

 

这课树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树

 

完全二叉树

定义：在完全二叉树中，除了最底层可能没有填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第h层，则该层包含1~2^h-1个节点。

如下图：

 

二叉搜索树

二叉搜索树是有数值的，二叉搜索树是一个有序树。

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

 

下面两棵树都是搜索树

 

平衡二叉搜索树

定义：平衡二叉搜索树，又称AVL树，且具有以下性质：它是一颗空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一颗平衡二叉树。

如图：

 

最后一棵不是平衡二叉树，因为它的左右两个子树的高度差的绝对值超过了1

 

c++中的map，set，multimap，multiset的底层实现都是平衡二叉搜索树。所以map，set的增删操作的时间复杂度为logn，而unordered_map，unordered_set的底层实现是哈希表。

 

二叉树的存储方式

 

二叉树可以链式存储，也可以顺序存储。链式存储的方式就用指针，顺序存储的方式用的是数组。

 

链式存储如图：

 

 

 

顺序存储二叉树的方式用的是数组的方式，如图：

 

这种方式存储访问节点是通过下标来访问的，例如：

如果父元素的数组下标是i，那么它的左孩子就是i*2+1，右孩子就是i*2+2。

 

二叉树的遍历方式

 

二叉树主要有两种遍历方式：

1. 深度优先遍历：先往深走，遇到叶子节点再往回走。
2. 广度优先遍历：一层一层的去遍历。

 

• 深度优先遍历

          前序遍历（中左右）

          中序遍历（左中右）

          后序遍历（左右中）

• 广度优先遍历

          层序遍历

 

下图为深度优先遍历下的三种遍历结果：

 

 

代码实现

前序遍历

    void preTraversal(TreeNode* node,vector<int> &result){
        if(node==NULL)return;
        result.push_back(node->val);
        preTraversal(node->left,result);
        preTraversal(node->right,result);
    }

中序遍历

   void inTraversal(TreeNode* node,vector<int> &result){
        if(node==NULL)return;
        inTraversal(node->left,result);
        result.push_back(node->val);
        inTraversal(node->right,result);
    }

后序遍历

void postTraversal(TreeNode* node,vector<int> &result){
        if(node==NULL)return;
        postTraversal(node->left,result);
        postTraversal(node->right,result);
        result.push_back(node->val);
    }

 

二叉树的迭代遍历

中序遍历

vector<int> inorderTraversal(TreeNode* root){
    vector<int> result;
    stack<TreeNode*> st;
    if(root!=NULL) st.push(root);
    while(!st.empty()){
        TreeNode* 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);
        }
    }
    return result;
}

 

第十行处有一个st.push(NULL)，是将处理过的节点进行标记，这样能解决访问节点和处理节点不一致的情况，因为迭代法判断将节点存入result的办法是stack中该节点的头一个节点是NULL，这样做既能防止存入stack中相同的节点，又能将该节点放到结果集中

前序遍历

vector<int> preorderTraversal(TreeNode* root){
    vector<int> result;
    stack<TreeNode*> st;
    if(root!=NULL) st.push(root);
    while(!st.empty()){
        TreeNode* 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);
        }
    }
    return result;
}

后序遍历

vector<int> postorderTraversal(TreeNode* root){
    vector<int> result;
    stack<TreeNode*> st;
    if(root!=NULL) st.push(root);
    while(!st.empty()){
        TreeNode* 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);
        }
    }
    return result;
}

 

二叉树的层序遍历（广度优先遍历）

层序遍历借助一个辅助结构来实现——队列，队列先进先出，符合一层一层遍历的逻辑，而且用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

vector<vector<int>> levelOrder(TreeNode* root){
    queue<TreeNode*> que;
    if(root!=NULL)que.push(root);
    vector<vector<int>> result;
    while(!queue.empty()){
        int size=que.size();
        vector<int> vec;
        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;
}