【二叉树】一条龙输出

所谓一条龙输出，指对一个二叉树中的结点按照奇数行从左到右，偶数行从右到左输出。

思路：可以看作是按层遍历的变形，建立两个栈S1、S2，其中S1按照先左子后右子的顺序存放数行的结点，S2按照先右子后左子的顺序存放偶数行的结点。利用栈的先进后出的性质可以按照要求的顺序对结点进行遍历。

操作：先把root存入S1，然后将root的子结点存入S2，先存左子节点，再存右子节点（空则不操作），弹出root。这时S1空，将S2中的两个结点（根据FILO先是root的右子，再是root的左子）的右子节点和左子节点分别存入S1，并弹出。S2空，于是对S1中的结点进行操作，依次类推…

代码：
main.cpp

#include <iostream>
#include "stack.h"
using namespace std;

class Node {
public:
    int key;
    Node *left, *right;
    Node() { left = right = NULL; }
    Node(int e, Node *p1 = NULL, Node *p2 = NULL) { key = e; left = p1; right = p2; }
};

class Tree {
public:
    Tree() { root = NULL; }
    void insert(int x);
    void reverseOrder();
    void output();
private:
    Node *root;
};

void Tree::insert(int x) {
    if (root == NULL) {
        root = new Node(x);
    }
    else {
        Node *p = root, *q = NULL;
        while (p != NULL) {
            q = p;      // p的父结点
            if (p->key > x)
                p = p->left;
            else
                p = p->right;
        }
        if (x < q->key)
            q->left = new Node(x);
        else
            q->right = new Node(x);
    }
}

void Tree::reverseOrder() {
    Stack<Node*> S1, S2;
    S1.push(root);
    while (!S1.isEmpty() || !S2.isEmpty()) {
        while (!S1.isEmpty()) {
            Node* p = S1.pop();
            cout << p->key << " ";
            if (p->left != nullptr)
                S2.push(p->left);
            if (p->right != nullptr)
                S2.push(p->right);
        }
        while (!S2.isEmpty()) {
            Node* p = S2.pop();
            cout << p->key << " ";
            if (p->right != nullptr)
                S1.push(p->right);
            if (p->left != nullptr)
                S1.push(p->left);
        }
    }
    cout << endl;
}


int main() {

    int data[15] = { 74, 21, 88, 81, 46, 9, 40, 36, 95, 78, 30, 65, 26, 89, 68 };
    Tree T;
    for (int i = 0; i < 15; i++) {
        T.insert(data[i]);
    }
    T.reverseOrder();

    return 0;
}

stack.h

template <typename T>
class SNode {
public:
    T data;
    SNode<T>* next;
    SNode(T x, SNode<T> *p = nullptr) { data = x; next = p; }
};


template <typename T>
class Stack {
public:
    Stack();
    bool isEmpty() { return top == NULL; }
    void push(T x);
    T pop();
private:
    SNode<T>* top;
};

template<typename T>
Stack<T>::Stack() {
    top = nullptr;
}

template<typename T>
void Stack<T>::push(T x) {
    SNode<T> *p = new SNode<T>(x);
    p->next = top;
    top = p;
}

template <typename T>
T Stack<T>::pop() {
    SNode<T> *p = top;
    T x = p->data;
    top = top->next;
    delete p;
    return x;
}

运行结果：