1.题目要求:

给你一棵 完美 二叉树的根节点 root ，请你反转这棵树中每个 奇数 层的节点值。

例如，假设第 3 层的节点值是 [2,1,3,4,7,11,29,18] ，那么反转后它应该变成 [18,29,11,7,4,3,1,2] 。
反转后，返回树的根节点。

完美 二叉树需满足：二叉树的所有父节点都有两个子节点，且所有叶子节点都在同一层。

节点的 层数 等于该节点到根节点之间的边数。

2.全部代码:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
//创建队列结构体
typedef struct queue{
    struct TreeNode* value;
    struct queue* next;
}queue_t;
//入队
void push(queue_t** head,struct TreeNode* data){
    queue_t* newnode = (queue_t*)malloc(sizeof(queue_t));
    newnode->value = data;
    newnode->next = NULL;
    if(*head == NULL){
        *head = newnode;
        return;
    }
    queue_t* tail = *head;
    while(tail->next != NULL){
        tail = tail->next;
    }
    tail->next = newnode;
}
//出队
struct TreeNode* pop(queue_t** head){
    struct TreeNode* x = (*head)->value;
    (*head) = (*head)->next;
    return x;
}
//逆置函数
void reverse(int* number,int left,int right){
    while(left <= right){
        int temp = number[left];
        number[left] = number[right];
        number[right] = temp;
        left++;
        right--;
    }
}
struct TreeNode* reverseOddLevels(struct TreeNode* root) {
    queue_t* quence = NULL;
    int nextcount = 0;
    int count = 1;
    int depth = -1;
    int* number = (int*)malloc(sizeof(int) * 20000);//层序遍历的数组
    int j = 0;
    int index = 0;//记录每一层的起点索引
    int size = 0;
    //开始层序遍历
    push(&quence,root);
    size++;
    while(size != 0){
        depth++;
        for(int i = 0;i < count;i++){
            struct TreeNode* temp = pop(&quence);
            number[j] = temp->val;//把层序遍历的节点值存入数组中
            j++;
            size--;
            if(temp->left != NULL){
                push(&quence,temp->left);
                size++;
                nextcount++;
            }
            if(temp->right != NULL){
                push(&quence,temp->right);
                size++;
                nextcount++;
            }
        }
        //如果高度是偶数,则起点索引加上这一层的结点数，变为下一层的起点索引
        if(depth % 2 == 0){
            index += count;
        }else{
            reverse(number,index,j - 1);//如果高度是奇数，则把这一层进行逆置
            index += count;
        }
        //把下一层的结点数赋给count;
        count = nextcount;
        nextcount = 0;
    }
    size = 0;
    int i = 0;
    push(&quence,root);
    size++;
    //再进行一次层序遍历，把数组的值反过来，赋给树中的结点
    while(size != 0){
        struct TreeNode* temp = pop(&quence);
        size--;
        temp->val = number[i];
        i++;
        if(temp->left != NULL){
            push(&quence,temp->left);
            size++;
        }
        if(temp->right != NULL){
            push(&quence,temp->right);
            size++;
        }
    }
    return root;
}

全部步骤都标在代码中，大家如果觉得好的话，不妨给个免费的赞吧，谢谢了^ _ ^