剑指offer 22：从上往下打印二叉树

 从上往下打印二叉树

#include <iostream>
#include <vector>
using namespace std;

using namespace std;
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;

    TreeNode(int x)
        : val(x), left(NULL), right(NULL)
    {

    }

    static void PreOrder(TreeNode *root) {
        if (root == NULL) {
            return;
        }
        cout << root->val;
        PreOrder(root->left);
        PreOrder(root->right);//递归前序打印
    }

    static void InOrder(TreeNode *root) {
        if (root == NULL) {
            return;
        }
        InOrder(root->left);
        cout << root->val;//递归中序打印
        InOrder(root->right);
    }
};
class Solution
{
    vector <int > res;
 public:
    vector<int> PrintFromTopTOBottom(TreeNode *root) {

        LevelOrder(root);

        return this->res;

    }
    // 打印某一层节点，递归实现
    int PrintLevel(TreeNode *root, int level) {
        if (root == NULL || level < 0) {
            return 0;
        }

        else if (level == 0) {
            cout << root->val;
            res.push_back(root->val);

            return 1;
        }
        else {
            return PrintLevel(root->left, level - 1) + PrintLevel(root->right, level - 1);
        }
    }
    //循环每层输出其节点，调用递归
    void LevelOrder(TreeNode *root) {
        res.clear();

        if (root == NULL) {
            return;
        }
        for (int level = 0; ; level++) {
            if (PrintLevel(root, level) == 0) {
                break;
            }

            cout << endl;
        }
    }

    struct TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> in) {
        if (pre.size() != in.size()) {//前序遍历和中序遍历长度应该相同
            return NULL;

        }

        int size = pre.size();
        if (size == 0) {
            return NULL;
        }//长度不能为空

        int length = pre.size();

        int value = pre[0]; //前序遍历的第一个节点是根节点
        TreeNode *root = new TreeNode(value);

        int rootIndex = 0;
        for (rootIndex = 0; rootIndex < length; rootIndex++) {
            if (in[rootIndex] == value) {  //在中序遍历中找到根的位置
                cout << "find" << endl;
                break;
            }
        }

        if (rootIndex >= length) {
            cout << "find" << endl;
            return NULL;
        }

        //确定左右子数的长度
        int leftLength = rootIndex;
        int rightLength = length - 1 - rootIndex;

        vector <int> preLeft(leftLength), inLeft(leftLength);
        vector <int> preRight(rightLength), inRight(rightLength);

        for (int i = 0; i < length; i++) {
            if (i < rootIndex) {
                //前序遍历的第一个是根节点，根后面的（leftLength = rootLength） -1 个节点
                //是左子树，因此是i+1
                preLeft[i] = pre[i+1];
                //中序遍历前（leftLength = rootLength - 1个节点是左子树，第rootIndex
                //个节点是根
                inLeft[i] = in[i];
            }

            else if ( i > rootIndex) {
                //前序遍历根后面rootIndex-1个节点是右子树
                preRight[i - rootIndex - 1] = pre[i];
                //中序遍历根前面rootIndex-1个节点是左子树，根后面是右子树
                inRight[i - rootIndex - 1] = in[i];
            }
        }

        for (int i = 0; i < leftLength; i++) {
            cout << preLeft[i] << "and" << inLeft[i]  << endl;

        }
        cout << endl;

        for (int i = 0; i < rightLength; i++) {
            cout << preRight[i] << "and" << inRight[i] << endl;
        }
        cout << endl;

        root->left = reConstructBinaryTree(preLeft, inLeft);
        root->right = reConstructBinaryTree(preRight, inRight);//递归重建

        return root;
    }



};
int main()
{
    int pre[] = {1,2,4,7,3,5,6,8};
    int in[] ={4,7,2,1,5,3,8,6};
    vector<int> preOrder(pre, pre + 8);
    vector<int> inOrder (in ,in + 8);

    Solution solu;
    TreeNode *root = solu.reConstructBinaryTree(preOrder, inOrder);
    cout << "preOrder";
    TreeNode::PreOrder(root);
    cout << endl;

    cout << "InOrder";
    TreeNode::InOrder(root);
    cout << endl;


    vector<int> b = solu.PrintFromTopTOBottom(root);
    for (int i = 0; i < b.size(); i++) {
        cout << b[i] << "";
    }

    return 0;
}