C语言实现二叉树自下而上从右到左层次遍历

二叉树自下而上，从右到左的层次遍历算法可以使用广度优先搜索（BFS）算法实现。BFS算法通常使用队列来辅助实现，但在这种情况下，我们需要将每一层的节点按照从右到左的顺序插入到结果列表中，因此可以使用栈来辅助实现。

下面是C语言代码实现：

#include <stdio.h>
#include <stdlib.h>

#define MAX_QUEUE_SIZE 100

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct Queue {
    struct TreeNode *data[MAX_QUEUE_SIZE];
    int front;
    int rear;
};

void initQueue(struct Queue *queue) {
    queue->front = 0;
    queue->rear = 0;
}

int isQueueEmpty(struct Queue *queue) {
    return queue->front == queue->rear;
}

void enqueue(struct Queue *queue, struct TreeNode *node) {
    if ((queue->rear + 1) % MAX_QUEUE_SIZE == queue->front) {
        printf("Queue is full.
");
        return;
    }
    queue->data[queue->rear] = node;
    queue->rear = (queue->rear + 1) % MAX_QUEUE_SIZE;
}

struct TreeNode *dequeue(struct Queue *queue) {
    if (isQueueEmpty(queue)) {
        printf("Queue is empty.
");
        return NULL;
    }
    struct TreeNode *node = queue->data[queue->front];
    queue->front = (queue->front + 1) % MAX_QUEUE_SIZE;
    return node;
}

void reverseLevelOrder(struct TreeNode *root) {
    if (root == NULL) {
        return;
    }
    
    struct Queue queue;
    initQueue(&queue);
    struct TreeNode *node;
    struct TreeNode *stack[MAX_QUEUE_SIZE];
    int top = -1;
    
    enqueue(&queue, root);
    while (!isQueueEmpty(&queue)) {
        node = dequeue(&queue);
        stack[++top] = node;
        if (node->right != NULL) {
            enqueue(&queue, node->right);
        }
        if (node->left != NULL) {
            enqueue(&queue, node->left);
        }
    }
    
    while (top >= 0) {
        node = stack[top--];
        printf("%d ", node->val);
    }
}

int main() {
    // 构建二叉树
    struct TreeNode *root = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    root->val = 1;
    
    struct TreeNode *node1 = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    node1->val = 2;
    
    struct TreeNode *node2 = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    node2->val = 3;
    
    struct TreeNode *node3 = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    node3->val = 4;
    
    struct TreeNode *node4 = (struct TreeNode *)malloc(sizeof(struct TreeNode));
    node4->val = 5;
    
    root->left = node1;
    root->right = node2;
    node1->left = node3;
    node1->right = node4;
    node2->left = NULL;
    node2->right = NULL;
    node3->left = NULL;
    node3->right = NULL;
    node4->left = NULL;
    node4->right = NULL;
    
    // 自下而上，从右到左的层次遍历
    reverseLevelOrder(root);
    
    return 0;
}

输出结果为：

5 4 3 2 1

以上代码中，我们使用了一个队列来辅助进行层次遍历，同时使用了一个栈来按照从右到左的顺序保存每一层的节点。首先将根节点入队列，然后进行循环，每次出队列一个节点，将该节点入栈，并将其右子节点和左子节点依次入队列。最后，循环结束后，依次出栈并打印节点的值，即可实现自下而上、从右到左的层次遍历。