二叉树打印所有的路径 & 根据数组构建完全二叉树

这道题目暂时没想起来怎么用递归去做，就用非递归吧。
这道题目是的地址是https://leetcode.com/problems/binary-tree-paths/
主要是用了一个vector来保存节点信息，这个节点信息是对原来节点信息的封装，
增加了两个单独的参数，这两个参数表示“左右子树是不是存在以及是不是访问过”
默认值是-1，取0表示有子树且没有访问过，取1表子树已经访问过。
基本逻辑是先沿着最左路径访问，不断访问不断累加路径上面的数据（打印用）。
当叶子节点打印完之后，要返回到最近的有右子树的父或祖父节点。
然后开始轮询其右孩子。这一步执行之前，要把跟节点到该“父或祖父节点”的数据都打印一份。
这也就是用栈存储的理由。

没想到修改了一个小地方就直接AC了，问题了我总是忘记判断vector.size()>0就直接用vector.[vector.size()-1]。。修改的就是这样地方。

全部代码见下面。

另外这个方法不仅可以解决所有path问题，还可以解决的有
1：求是否存在一个path，上面从根到叶子所有数据和为某值
2：打印‘1’中所有的path
3：BFS即深度优先遍历相关问题。

#include <algorithm>

struct TreeNodeCTL{
     TreeNode *node;
     int right;  
     int left;
     TreeNodeCTL() :left(-1), right(-1){}
 };

 string m_itoa(int m)
 {
      char a[30] = { 0 };
     sprintf(a, "%d",m);//int数字转为字符串打印
     return a;
 }
/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
        if (root == NULL) return vector < string >();
        if (root->left == NULL && root->right == NULL)
        {//只有一个节点时
            string strres;
            strres += m_itoa(root->val);
            vector < string > vc;
            vc.push_back(strres);
            //cout << root->val << endl;
            //cout << strres << endl;
            return vc;
        }

        vector<string> res;//返回值结构
        vector<TreeNodeCTL> vcc;//始于根节点的已访问节点栈
        string strres = "";
        while (1)
        {

            if (root->left && (vcc.size()?root!=vcc[vcc.size()-1].node : 1))
            {//当有左孩子且左孩子未访问过。访问左孩子
                strres +=m_itoa(root->val);
                strres += "->"; 
                TreeNodeCTL cc;
                cc.node = root;
                cc.left = 1;
                cc.right = root->right?0:-1;
                vcc.push_back(cc);
                root = root->left;
            }
            else if (root->right && (vcc.size() ? root != vcc[vcc.size() - 1].node : 1))
            {//当有右孩子且右孩子未访问过。访问右孩子
                strres += m_itoa(root->val);
                strres += "->";
                TreeNodeCTL cc;
                cc.node = root;
                cc.right = 1;
                vcc.push_back(cc);
                root = root->right;
            }
            else if (root->right && (vcc.size() ? root == vcc[vcc.size() - 1].node : 0))
            {//当有右孩子且右孩子访问过
            //这种情况发生于 该节点的左孩子访问完毕之后回退到这个“首个具有双子节点的节点”，访问其右节点
                for (int i = 0; i < vcc.size(); ++i)
                {//打印路径
                    strres += m_itoa(vcc[i].node->val);
                    strres += "->";
                }

                root = root->right;
                vcc[vcc.size() - 1].right = 1;              
            }
            else if (root->left == NULL  && root->right == NULL)
            {//访问到叶子节点，那么则1 调整打印结构，存贮路径
                strres += m_itoa(root->val);
                res.push_back(strres);
                strres = "";
              //回退最近的有双亲的节点
                while (vcc.size()>0 && vcc[vcc.size() - 1].right != 0)
                    vcc.pop_back();
                if (vcc.size() == 0)
                    break;
                    //继续
                root = vcc[vcc.size() - 1].node;
            }

        }
        return res;

    }
};

构建完全二叉树

 void ConstructTree(TreeNode * & root, TreeNode * & parent, int index, int *arr, int len)

 {// ConstructFULLTree by arr

     if (root == NULL)

     {

         root = GetNode(arr[index]);

         parent = root;

     }




     TreeNode * lchild = NULL;

     if (2 * index + 2>len) return;

     else

     {

         lchild = GetNode(arr[2 * index + 1]);

         parent->left = lchild;

     }

     TreeNode * rchild = NULL;

     if (2 * index + 3>len) return;

     else

     {

         rchild = GetNode(arr[2 * index + 2]);

         parent->right = rchild;

     }




     if (2 * index + 2 <= len)

     {

         ConstructTree(root, parent->left, 2 * index + 1, arr, len);

     }




     if (2 * index + 3 <= len)

     {

         ConstructTree(root, parent->right, 2 * index + 2, arr, len);

     }







 }

调用时，可以如
root = NULL, parent = NULL,
ConstructTree(root,parent,0,arr, len);