二叉树的创建和遍历

前言：用c++写一篇二叉树的创建和遍历，有需要改正的请指出！

二叉树的创建

class TreeNode
{
public:
    int val;
    TreeNode *left,*right;
};
class solution
{
public:
//创建二叉树
    TreeNode* createLink()
    {
        int data;
        TreeNode *node;
        cin>>data;
        if(data == -1)//输入-1代表此节点下不存数据，也就是不继续递归
        {
            return NULL;
        }else
        {
            node = new TreeNode;
            node->val = data;//把输入的值放入当前节点指针的数据域中
            cout<<data<<" left:"<<endl;
            node->left=createLink();//递归创建左子树
            cout<<data<<" right:"<<endl;
            node->right=createLink();//递归创建右子树
            return node;
        }
    }
    //输出遍历后的数组
    void showVercotr(vector<int> res)
    {
        vector<int>::iterator it;
        for(it=res.begin();it!=res.end();it++)
            cout<<*it<<endl;
    }
}

二叉树先序遍历

class solution
{
public:
 void preorder(vector<int> &res,TreeNode* root)
    {
        //遇到空节点返回
        if(root == NULL)
        {
            return;
        }
        //先遍历根节点
        res.push_back(root->val);
        preorder(res,root->left);//再递归遍历左子树
        preorder(res,root->right);//递归遍历右子树
    }

    vector<int> preorderTraversal(TreeNode* root)
    {
        vector<int> res;
        preorder(res,root);
        return res;
    }
}

输入：5 3 2 -1 -1 4 -1 -1 8 7 -1 -1 9 -1 10 -1 -1 //二叉树已创建
输出：5 3 2 4 8 7 9 10

遍历的结果跟创建的二叉树的顺序一致

二叉树中序遍历

	//中序遍历
    void inorder(vector<int> &res,TreeNode* root)
    {
        //遇到空节点返回
        if(root == NULL)
        {
            return;
        }
        //先遍历左子树
        inorder(res,root->left);
        //再遍历根节点
        res.push_back(root->val);
        //最后遍历右子树
        inorder(res,root->right);
    }

输入：5 3 2 -1 -1 4 -1 -1 8 7 -1 -1 9 -1 10 -1 -1 //二叉树已创建
输出：3 2 4 5 8 7 9 10

二叉树后序遍历

	//后序遍历
    void postorder(vector<int> &res,TreeNode* root)
    {
        //遇到空节点返回
        if(root == NULL)
        {
            return;
        }
        //先遍历左子树
        postorder(res,root->left);
        //再遍历右子树
        postorder(res,root->right);
        //最后遍历根节点
        res.push_back(root->val);
    }

输入：5 3 2 -1 -1 4 -1 -1 8 7 -1 -1 9 -1 10 -1 -1 //二叉树已创建
输出：3 2 4 8 7 9 10 5

二叉树的层次遍历

非递归—队列
思路：
二叉树的层次遍历就是按照从上到下每行，然后每行中从左到右依次遍历，得到的二叉树的元素值。对于层次遍历，通常使用队列来辅助。
步骤：
1.首先判断二叉树是否为空，空树没有遍历结果。
2.建立辅助队列，根节点首先进入队列。不管层次怎么访问，根节点一定是第一个，那它肯定排在队伍的最前面。
3.每次进入一层，统计队列中元素的个数。因为每当访问完一层，下一层作为这一层的子节点，一定都加入队列，而再下一层还没有加入，因此此时队列中的元素个数就是这一层的元素个数。
4.每次遍历这一层这么多的节点数，将其依次从队列中弹出，然后加入这一行的一维数组中，如果他们右子节点，依次加入队列排队等待访问。
5.访问完这一层的元素后，将这个一维数组加入二维数组中，再访问下一层。

	//层次遍历
    vector<vector<int> > leveOreder(TreeNode *root)
    {
        vector<vector<int> > res;
        if(root == NULL)
        {
            //如果为空，则直接返回vector
            return res;
        }
        queue<TreeNode *> q;
        q.push(root);
        TreeNode * cur;
        while(!q.empty())
        {
            //记录二叉树的每一行
            vector<int> row;
            int n = q.size();
            //因为先进入的是根节点，故每层节点多少，队列的大小就为多少
            for(int i = 0;i<n;i++)
            {
                cur=q.front();
                q.pop();
                row.push_back(cur->val);
                //若有左右孩子存在，则存入左右孩子作为下一个层次
                if(cur->left)
                    q.push(cur->left);
                if(cur->right)
                    q.push(cur->right);
            }
            //每一层加入输出
            res.push_back(row);
        }
        return res;
    }
    void showVercotr(vector<vector<int> > res)
    {

        for(int it=0;it<res.size();it++)
        {
            vector<int>::iterator iit;
            for(iit=res[it].begin();iit!=res[it].end();iit++)
                cout<<*iit<<endl;
        }
    }

输入：5 3 2 -1 -1 4 -1 -1 8 7 -1 -1 9 -1 10 -1 -1 //二叉树已创建
输出：5 3 8 2 4 7 9 10