【数据结构与算法（十七）】

题目

不分行从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

思路

1、按层打印二叉树的过程

步骤	操作	队列
1	打印节点10	6，14
2	打印节点6	14，4，8
3	打印节点14	4，8，12，16
4	打印节点4	8，12，16
5	打印节点8	12，16
6	打印节点12	16
7	打印节点16

2、以上规律：（先进先出）每次打印一个节点时，如果该节点有子节点，则把该节点的子节点放到一个队列的末尾。接下来到队列的头部取出最早进入队列的节点，重复前面的打印操作，直至队列中的所有节点都被打印出来

struct BinaryTreeNode
{
    int value;
    BinaryTreeNode* leftNode;
    BingryTreeNode* rightNode;
};
//广度遍历一棵二叉树
void PrintFromTopToBottom(BinaryTreeNode* pRoot)
{
    if (!pRoot)//不存在的树
        return;
    deque<BinaryTreeNode*> dequeTreeNode;
    dequeTreeNode.push_back(pRoot);
    while (dequeTreeNode.size())
    {
        //出队，打印，再（子节点）入队
        BinaryTreeNode* pNode = dequeTreeNode.front();
        dequeTreeNode.pop_front();//出队
        cout << pNode->value;
        //当前节点的左右节点入队
        if (pNode->leftNode)//没有坐子节点的话就不用了
            dequeTreeNode.push_back(pNode->leftNode);
        if (pNode->rightNode)//没有右子节点的话就不用了
            dequeTreeNode.push_back(pNode->rightNode);
    }
}

测试用例：
完全二叉树、所有节点只有左子树/右子树、nullptr的根节点、只有一个节点

分行从上到下打印二叉树

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

思路

1、这道题的意思就是打印出来的样子是这样的

2、还是用队列来保存将要打印的节点。为了把二叉树的每一行单独打印到一行里，需要两个变量：一个变量表示再当前层中还没有打印的节点数；另一个变量表示下一层节点的数目。

void Print(BinaryTreeNode* pRoot)
{
    if (!pRoot)
        return;
    queue<BinaryTreeNode*> dequeTreeNodes;  //queue普通队列
    dequeTreeNodes.push(pRoot);
    int nextLevel = 0;  //下一行需要打印的节点数
    int toBePrint = 1;  //当前行还没有打印的节点数
    while (!dequeTreeNodes.empty()) {   //与.size()的功能一样
        BinaryTreeNode* pNode = dequeTreeNodes.front();
        cout << pNode->value;
        if (pNode->leftNode) {
            dequeTreeNodes.push(pNode->leftNode);
            nextLevel++;
        }
        if (pNode->rightNode) {
            dequeTreeNodes.push(pNode->rightNode);
            nextLevel++;
        }
        dequeTreeNodes.pop();
        --toBePrint;
        if (toBePrint == 0) {   //为下一层打印做准备    
            cout << std::endl;
            toBePrint = nextLevel;
            nextLevel = 0;
        }
    }
}

之形打印二叉树

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右打印，第二层按照从右到左打印，第三层按照从左到右打印，以下依次类推

思路【用两个栈】

1、（用具体例子分析）之字形打印二叉树

2、以上图片打印的操作为

步骤	操作	Stcak1中的节点	Stack2中的节点
1	打印节点10	6，14
2	打印节点14	6	4，3
3	打印节点6		4，3，2，1
4	打印节点1	5，7	4，3，2
5	打印节点2	5，7，8，9	4，3
6	打印节点3	5，7，8，9，11，13	4
7	打印节点4	5，7，8，9，11，13，12，16

3、规律：按之字形顺序打印二叉树需要两个栈。我们在打印某一层的节点时，把下一层的子节点保存到相应的栈中。如果当前打印的是奇数层（第一层、第三层等），则先保存左子节点再保存右子节点到第一个栈中；如果当前打印的是偶数层，则先保存右子节点再保存左子节点到第二个栈中。

#include<stack>
void PrintZ(BinaryTreeNode* pRoot)
{
    if (!pRoot) return;
    std::stack<BinaryTreeNode*> levels[2];  //两个栈
    int current = 0;
    int next = 1;
    levels[current].push(pRoot);
    while (!levels[0].empty() || !levels[1].empty())
    {
        BinaryTreeNode* pNode = levels[current].top();  //当前要打印的节点
        levels[current].pop();
        //这里其实与上面画的图的两个栈相反了。
        //Stack1是levels[1]—从左到右入栈，从右到左出栈
        cout << pNode->value << " ";
        if (current == 0) {//next=1
            if (pNode->leftNode != nullptr)
                levels[next].push(pNode->leftNode);
            if (pNode->rightNode != nullptr)
                levels[next].push(pNode->rightNode);
        }//Stcak2是levels[0]—从右到左入栈，从左到右出栈
        else {//next=0
            if (pNode->rightNode != nullptr)
                levels[next].push(pNode->rightNode);
            if (pNode->leftNode != nullptr)
                levels[next].push(pNode->leftNode);
        }
        if (levels[current].empty()) {
            cout << std::endl;
            current = 1 - current;
            next = 1 - next;
        }
    }
}

序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树

思路

1、序列化：把数的节点序列化为一个字符串；反序列化：根据字符串构建出一棵树
2、举个例子：

其中$表示空节点

//序列化二叉树[1,2,4,$,$,$……]4后面有3个$是因为4没有子节点，所以左右两边都是nullptr
//2的左子节点递归结束后，开始右子节点，发现2的右子节点也是nullptr，所以又多了一个$
void Serialize(BinaryTreeNode* pRoot, std::ostream& stream)
{
    //只要是遇到空节点就输入“$”，然后结束此次递归
    if (pRoot == nullptr) {
        stream << "$";
        return;
    }
    stream << pRoot->value << ",";
    //前序遍历的序列化
    Serialize(pRoot->leftNode,stream);
    Serialize(pRoot->rightNode,stream);
}

3、反序列化的时候，“1,2,4,$,$,$,3,5,$,$,6,$,$”。第一个读出来的数字是1.由于前序遍历是从根节点开始的，所以1是根节点的值。接下来2，根据前序遍历的规则，2是根节点的左子节点。同样，4是值为2的节点的左子节点。根据从序列化字符串读出两个$，这表明值为4的节点的左右子节点均为空指针，因此4是一个叶节点。接下来回到值为2的节点，重建它的右子节点。由于下一个字符是$，所以2的右子节点是空指针。这时候节点2的左右子树都建立完毕了，可以回到根节点。反序列化根节点的右子树。以此类推

//每次调用从流中读取一个数字或一个字符“$”
//当从流中读取的是数字时，返回true；读取的是$时，返回false
bool ReadStream(std::istream& stream, int* number)
{
    if (stream.eof())
        return false;

    char buffer[32];
    buffer[0] = '\0';

    char ch;
    stream >> ch;
    int i = 0;
    //把整个数字读完，因为可能是多位的数字
    while (!stream.eof() && ch != ',') {
        buffer[i++] = ch;
        stream >> ch;
    }
    bool isNumberic = false;
    if (i > 0 && buffer[0] != '$') {
        *number = atoi(buffer);
        isNumberic = true;
    }
    return isNumberic;
}
//为什么是**。因为根节点的指向内存要改变，所以就需要有一个指向指针内存的指针
void Deserialize(BinaryTreeNode** pRoot, std::istream& stream)
{
    int number;
    if (ReadStream(stream, &number)) {//读取到了一个数字
        //先创建一个树的节点
        *pRoot = new BinaryTreeNode();
        (*pRoot)->value = number;
        (*pRoot)->leftNode = nullptr;
        (*pRoot)->rightNode = nullptr;
        Deserialize(&(*pRoot)->leftNode, stream);//对当前节点的左节点赋值
        //如果下一个读到的是$，那就直接不用管了，结束当前递归，一层层返回
        Deserialize(&(*pRoot)->rightNode, stream);
    }
}