(能够直接运行 C++版）试给出二叉树的自下而上、从右到左的层次遍历算法

我们现在操作的数据元素不是简单的int，char，而是一个节点

首先我们需要定义一棵树的结构，并实现初始化和插入节点等操作。

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


typedef struct BiTNode{
	int data;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree; 

void initTree(BiTree& tree) {
    tree = nullptr;
}

BiTNode* createNode(int data) {
    BiTNode* newNode = new BiTNode();
    newNode->data = data;
    newNode->lchild = nullptr;
    newNode->rchild = nullptr;
    return newNode;
}

void buildTree(BiTree& tree) {
    // 创建节点
    BiTNode* node1 = createNode(1);
    BiTNode* node2 = createNode(2);
    BiTNode* node3 = createNode(3);
    BiTNode* node4 = createNode(4);
    BiTNode* node5 = createNode(5);

    // 构建树的结构
    tree = node1;
    node1->lchild = node2;
    node1->rchild = node3;
    node2->rchild = node4;
    node3->lchild = node5;
}

void printTree(BiTree tree) {
    if (tree == nullptr) {
        return;
    }
    cout << tree->data << " ";  	 // 打印节点数据
    printTree(tree->lchild);         // 递归打印左子树
    printTree(tree->rchild);         // 递归打印右子树
}

接着我们需要定义栈的结构及相关基本操作：

#define MaxSize 50

typedef struct {
    BiTNode* data[MaxSize];
    int top;
} SqStack;

void initStack(SqStack& S) {
    S.top = -1;
}

bool stackEmpty(SqStack S) {
    return S.top == -1;
}

bool push(SqStack& S, BiTNode* x) {
    if (S.top == MaxSize - 1)
        return false;
    S.data[++S.top] = x;
    return true;
}

bool pop(SqStack& S, BiTNode*& x) {
    if (S.top == -1)
        return false;
    x = S.data[S.top--];
    return true;
}

bool getTop(SqStack S, BiTNode*& x) {
    if (S.top == -1)
        return false;
    x = S.data[S.top];
    return true;
}

void printStackElements(SqStack S) {
    if (stackEmpty(S)) {
        cout << "Stack is empty.\n";
        return;
    }

    cout << "Stack elements: ";
    for (int i = S.top; i >= 0; --i) {
        cout << S.data[i]->data << " ";
    }
    cout << "\n";
}

然后是队列：

typedef struct {
    BiTNode* data[MaxSize];
    int front, rear;
} SqQueue;


void initQueue(SqQueue& queue) {
    queue.front = queue.rear = 0;
}

bool isQueueEmpty(SqQueue& queue) {
    return queue.front == queue.rear;
}

bool isQueueFull(SqQueue& queue) {
    return (queue.rear + 1) % MaxSize == queue.front;
}

bool enQueue(SqQueue& queue, BiTNode* item) {
    if (isQueueFull(queue)) {
        cout << "Queue is full. Cannot enqueue item.\n";
        return false;
    }
    queue.data[queue.rear] = item;
    queue.rear = (queue.rear + 1) % MaxSize;
    return true;
}

bool deQueue(SqQueue& queue, BiTNode * &item) {
    if (isQueueEmpty(queue)) {
        cout << "Queue is empty. Cannot dequeue item.\n";
        return false;
    }
    item = queue.data[queue.front];
    queue.front = (queue.front + 1) % MaxSize;
    return true;
}

下一个就是关键代码了，自底而上，自右向左，层序遍历一棵树

void reverse_operate(BiTree tree){
	SqStack stack;			// 定义一个栈 
	initStack(stack); 		// 初始化该栈 
	
	SqQueue queue;			// 定义一个队列 
	initQueue(queue);		// 初始化队列 
	
	enQueue(queue , tree);	// 将第一个元素入队 
	BiTNode* x;				// 记录出队列的元素 
	while(!isQueueEmpty(queue)){
		deQueue(queue , x) ;
		if(x->lchild != nullptr) enQueue(queue , x->lchild);
		if(x->rchild != nullptr) enQueue(queue , x->rchild);
		push(stack , x);
	}
	printStackElements(stack);
} 

最后是主函数

int main() {
	
    BiTree tree;		//定义一个树 
    initTree(tree);   	// 初始化树
    buildTree(tree);  	// 构建树

    reverse_operate(tree);

    return 0;
}

运行结果：