【数据结构】二叉树知识点详解

树的概念

• 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合
• 有一个特殊的结点，称为根结点，根节点没有前驱结点
• 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树

注意：树形结构中，子树之间不能有交集，否则就不是树形结构

树的相关概念

• 节点的度：一个节点含有的子树的个数称为该节点的度；
• 如上图：A的为6叶节点或终端节点**,度为0的节点称为叶节点**；
• 如上图：B、C、H、I…等节点为叶节点非终端节点或分支节点：度不为0的节点；
• 如上图：D、E、F、G…等节点为分支节点双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
• 如上图：A是B的父节点孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
• 如上图：B是A的孩子节点兄弟节点：具有相同父节点的节点互称为兄弟节点；
• 如上图：B、C是兄弟节点树的度：一棵树中，最大的节点的度称为树的度；
• 如上图：树的度为6节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推树的高度或深度：树中节点的最大层次；
• 如上图：树的高度为4堂兄弟节点：双亲在同一层的节点互为堂兄弟；
• 如上图：H、I互为兄弟节点节点的祖先：从根到该节点所经分支上的所有节点；
• 如上图：A是所有节点的祖先子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
• 如上图：所有节点都是A的子孙森林：由m（m>0）棵互不相交的树的集合称为森林

二叉树概念及结构

概念

一棵二叉树是结点的一个有限集合，该集合:

1. 或者为空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成
3. 二叉树不存在度大于2的结点
4. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

二叉树的状态

特殊的二叉树

• 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是，则它就是满二叉树。
• 完全二叉树：对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的性质

• 规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2(i-1) 个结点
• 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2的h次方- 1
• 对任何一棵二叉树,如果度为0其叶结点个数为 n1，度为2的分支结点个数为 n2,则有n1=n2+1
• 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log2(n+1)–(ps:log2(n + 1)是log以2为底n+1为对数)
• 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于席号为i的结点有:

关系位置

1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
2. 若2i+1=n否则无左孩子
3. 若2i+2=n否则无右孩子

二叉树的存储结构

顺序存储

• 顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。
• 而现实中使用中只有堆才会使用数组来存储，二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

链式存储

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。

遍历过程

先序遍历

非递归遍历

class Solution {
public:
    void inorder(TreeNode*root,vector<int>&v)
    {
        if(root==nullptr)return;
        
        v.push_back(root->val);
        inorder(root->left,v);
        inorder(root->right,v);
        
        

    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>v;
        if(!root)return v;
        inorder(root,v);

    return v;
    }
};

非递归遍历（栈）

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int >v;
        stack<TreeNode*>st;
        TreeNode*cur=root; //拷贝一个节点 避免把根节点给删除

        while(cur || !st.empty()) //判断栈是否为空，节点是否为空
        {
            while(cur) //先遍历到最左节点 把节点都压栈
            {
                st.push(cur);
                cur=cur->left;
            }
            TreeNode*top=st.top(); //取栈顶的节点
            v.push_back(top->val);//取值到vtor
            st.pop();//删除栈中的节点
            cur=top->right;//然后就遍历右节点
        }
        return v;
    }
};

中序遍历

递归遍历

class Solution {
public:
    void inorder(TreeNode*root,vector<int>&v)
    {
        if(root==nullptr)return;
        
        
        inorder(root->left,v);
        v.push_back(root->val);
        inorder(root->right,v);

    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>v;
        if(!root)return v;
        inorder(root,v);

    return v;
    }
};

非递归遍历（栈）

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int >v;
        stack<TreeNode*>st;
        TreeNode*cur=root; //拷贝一个节点 避免把根节点给删除

        while(cur || !st.empty()) //判断栈是否为空，节点是否为空
        {
            while(cur) //先遍历到最左节点 把节点都压栈
            {
                st.push(cur);
                cur=cur->left;
            }
            TreeNode*top=st.top(); //取栈顶的节点
            v.push_back(top->val);//取值到vtor
            st.pop();//删除栈中的节点
            cur=top->right;//然后就遍历右节点
        }
        return v;
    }
};

后序遍历

递归遍历

class Solution {
public:
    void inorder(TreeNode*root,vector<int>&v)
    {
        if(root==nullptr)return;
        
        
        inorder(root->left,v);
        inorder(root->right,v);
        v.push_back(root->val);
        
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>v;
        if(!root)return v;
        inorder(root,v);

    return v;
    }
};

非递归遍历（栈）

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode* >st; 
        vector<int>v;
        TreeNode*cur=root;    //拷贝节点
        TreeNode*prev=nullptr;    

        while(cur||!st.empty())  
        {
            while(cur)   //存储根到最左的所有节点
            {
                st.push(cur);
                cur=cur->left;
            }

           TreeNode*top=st.top();      //记录最左节点

            //如果他的右是空那么他的左右都没有子节点了，这时就可以进数据 ；
            //top->right==prev 这里保证了右节点的插入数据，记录上一个经过的节点
            if(top->right==nullptr||top->right==prev)    
            {
                v.push_back(top->val);
                st.pop();
                prev=top;                   //记录上一个节点
            }
            else
            {
                cur=top->right;      
            }
        }
    return v;
    }
};

层次遍历

非递归遍历（队列）

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        
        //层序遍历   同深度的一个集合
        vector<vector<int>> v; //存放每一层的数据
        if(!root)
        {
            return v;
        }
        queue<TreeNode*> q; 
        q.push(root);

        while(!q.empty())//这里一直不为空
        {   
            int ret=q.size();//计算当前层的节点个数
            vector<int>cur;
            while(ret--)
            {
                TreeNode*node =q.front();//头部为左节点
                q.pop();
                cur.push_back(node->val);//取节点值
                if(node->left) 
                    q.push(node->left); //取左节点
                if(node->right) 
                    q.push(node->right);//取右节点
            }
            v.push_back(cur);
        }
        return v;
    }
};

方法2

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        
        queue <TreeNode*>q;
        int size=0;
        if(root)
        {
            q.push(root);
            size=1;
        }
        
    vector<vector<int>> vv;
    while(!q.empty())
    {
        vector<int>v;
        while(size--) //每一层的个数
        {
            TreeNode* t=q.front();
            q.pop();
            v.push_back(t->val);

            if(t->left)
                q.push(t->left);
            if(t->right)
                q.push(t->right);
        }
        vv.push_back(v);
        size=q.size();//更新
    }
    return vv;
    }
};