代码随想录day15|二叉树层序遍历、 226.翻转二叉树、101. 对称二叉树

题目链接： 二叉树的层序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume
 * caller calls free().
 */
int** levelOrder(struct TreeNode* root, int* returnSize,
                 int** returnColumnSizes) {
    *returnSize = 0;
    if (root == NULL)
        return NULL;
    int** returnNums = (int**)malloc(sizeof(int*) * 2001);
    *returnColumnSizes = (int*)malloc(sizeof(int) * 2001);
    struct TreeNode* queueDat[2001];
    int queueFront = 0;
    int queueRear = 0;
    struct TreeNode* cur;

    queueDat[queueRear++] = root;
    while (queueFront != queueRear) {
        int colSize = 0;
        int last = queueRear;
        returnNums[*returnSize] =
            (int*)malloc(sizeof(int) * (last - queueFront));
        while (queueFront < last) {
            cur = queueDat[queueFront++];
            returnNums[*returnSize][colSize++] = cur->val;
            if (cur->left != NULL)
                queueDat[queueRear++] = cur->left;
            if (cur->right != NULL)
                queueDat[queueRear++] = cur->right;
        }
        (*returnColumnSizes)[*returnSize] = colSize;
        (*returnSize)++;
    }
    return returnNums;
}

代码实现思路：先检查二叉树是否为空，然后初始化数组以及分配内存，然后就左结点入队然后到右结点入队。

107. 二叉树的层序遍历 II

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** levelOrderBottom(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    (*returnSize) = 0;
    int** returnNums = (int**)malloc(sizeof(int*)*2001);
    *returnColumnSizes = (int*)malloc(sizeof(int)*2001);
    if(root == NULL)
        return NULL;

    struct TreeNode* queue[2001];
    struct TreeNode* cur;
    int queueFront = 0;
    int queueRear = 0;
    queue[queueRear++] = root;
    while (queueFront != queueRear) {
        int colSize = 0;
        int last = queueRear;
        returnNums[*returnSize] = (int*)malloc(sizeof(int) * (last - queueFront));
        while (queueFront < last) {
            cur = queue[queueFront++];
            returnNums[*returnSize][colSize++] = cur->val;
            if (cur->left != NULL)
                queue[queueRear++] = cur->left;
            if (cur->right != NULL)
                queue[queueRear++] = cur->right;
        }
        (*returnColumnSizes)[(*returnSize)++] = colSize;       
    }
    for (int i = 0; i*2 < *returnSize ; ++i) {  
        int* temp1 = returnNums[i];  
        returnNums[i] = returnNums[*returnSize - i - 1];  
        returnNums[*returnSize - i - 1] = temp1;  
        int temp2 = (*returnColumnSizes)[i];  
        (*returnColumnSizes)[i] = (*returnColumnSizes)[*returnSize - i - 1];  
        (*returnColumnSizes)[*returnSize - i - 1] = temp2;  
    }  

    return returnNums;
}

这里其实就是在一个数组里面实现两个元素互换

199. 二叉树的右视图

/**  
 * Definition for a binary tree node.  
 * struct TreeNode {  
 *     int val;  
 *     struct TreeNode *left;  
 *     struct TreeNode *right;  
 * };  
 */  
/**  
 * Note: The returned array must be malloced, assume caller calls free().  
 */  
int* rightSideView(struct TreeNode* root, int* returnSize) {  
    if (root == NULL) {  
        *returnSize = 0;  
        return NULL;  
    }  
    struct TreeNode** queue = (struct TreeNode**)malloc(sizeof(struct TreeNode*) * 101);  
    int front = 0;  
    int rear = 0;  
      
    int* returnNums = (int*)malloc(sizeof(int) * 101);  
    *returnSize = 0;  
  
    queue[rear++] = root;  
    while (front < rear) {  
        int levelSize = rear - front; // 当前层的节点数量  
        for (int i = 0; i < levelSize; ++i) {  
            struct TreeNode* node = queue[front++];  
              
            // 只记录每一层最右边的节点的值  
            if (i == levelSize - 1) {  
                returnNums[(*returnSize)++] = node->val;  
            }  
              
            // 将当前节点的子节点加入队列  
            if (node->left) {  
                queue[rear++] = node->left;  
            }  
            if (node->right) {  
                queue[rear++] = node->right;  
            }  
        }  
    }  
     
    return returnNums;  
}

637. 二叉树的层平均值

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
double* averageOfLevels(struct TreeNode* root, int* returnSize) {
   
    struct TreeNode** queue = malloc(sizeof(struct TreeNode*) * 10001);
    int front = 0;
    int rear = 0;
    double* returnNums = (double*)malloc(sizeof(int)*10001);
    *returnSize = 0;
    queue[rear++] = root;
    while(front < rear){
        double sum = 0;
        int size = rear-front; 
        for(int i = 0; i < size; i++){
             struct TreeNode* node = queue[front++];
              sum += node->val;
              if(node->left !=  NULL)
                queue[rear++] = node->left;
              if(node->right != NULL)
                queue[rear++] = node->right;
        }
        returnNums[(*returnSize)++] = sum / size;
    }
    return returnNums;
    }

429. N 叉树的层序遍历

#define MAX_LEVE_SIZE 1000
#define MAX_NODE_SIZE 10000

int** levelOrder(struct Node* root, int* returnSize, int** returnColumnSizes) {
    int ** ans = (int **)malloc(sizeof(int *) * MAX_LEVE_SIZE);
    *returnColumnSizes = (int *)malloc(sizeof(int) * MAX_LEVE_SIZE);
    if (!root) {
        *returnSize = 0;
        return ans;
    }
    struct Node ** queue = (struct Node **)malloc(sizeof(struct Node *) * MAX_NODE_SIZE);
    int head = 0, tail = 0;
    int level = 0;
    queue[tail++] = root;

    while (head != tail) {
        int cnt = tail - head;
        ans[level] = (int *)malloc(sizeof(int) * cnt);
        for (int i = 0; i < cnt; ++i) {
            struct Node * cur = queue[head++];
            ans[level][i] = cur->val;
            for (int j = 0; j < cur->numChildren; j++) {
                queue[tail++] = cur->children[j];
            }
        }
        (*returnColumnSizes)[level++] = cnt;
    }
    *returnSize = level;
    free(queue);
    return ans;
}

515. 在每个树行中找最大值

#define MAX_NODE_SIZE 10001
#define MAX(a, b) ((a) > (b) ? (a) : (b))

int* largestValues(struct TreeNode* root, int* returnSize) {
    if (!root) {
        *returnSize = 0;
        return NULL;
    }
    int *res = (int *)malloc(sizeof(int) * MAX_NODE_SIZE);
    *returnSize = 0;
    struct TreeNode **queue = (struct TreeNode *)malloc(sizeof(struct TreeNode *) * MAX_NODE_SIZE);
    int head = 0, tail = 0;
    queue[tail++] = root;
    while (head != tail) {
        int len = tail - head;
        int maxVal = INT_MIN;
        while (len > 0) {
            len--;
            struct TreeNode *node = queue[head++];
            maxVal = MAX(maxVal, node->val);
            if (node->left) {
                queue[tail++] = node->left;
            }
            if (node->right) {
                queue[tail++] = node->right;
            }
        }
        res[(*returnSize)++] = maxVal;
    }

    free(queue);
    return res;
}

116. 填充每个节点的下一个右侧节点指针117. 填充每个节点的下一个右侧节点指针 II116. 填充每个节点的下一个右侧节点指针

struct Node* connect(struct Node* root) {
    if (root == NULL) {
        return root;
    }

    struct Node* Q[5000];
    int left = 0, right = 0;
    Q[right++] = root;


    while (left < right) {
      
        int size = right - left;

        
        for (int i = 0; i < size; i++) {
       
            struct Node* node = Q[left++];

     
            if (i < size - 1) {
                node->next = Q[left];
            }

   
            if (node->left != NULL) {
                Q[right++] = node->left;
            }
            if (node->right != NULL) {
                Q[right++] = node->right;
            }
        }
    }
    
    return root;
}

117. 填充每个节点的下一个右侧节点指针 II

struct Node *connect(struct Node *root) {
    if (!root) {
        return NULL;
    }
    struct Node *q[10001];
    int left = 0, right = 0;
    q[right++] = root;
    while (left < right) {
        int n = right - left;
        struct Node *last = NULL;
        for (int i = 1; i <= n; ++i) {
            struct Node *f = q[left++];
            if (f->left) {
                q[right++] = f->left;
            }
            if (f->right) {
                q[right++] = f->right;
            }
            if (i != 1) {
                last->next = f;
            }
            last = f;
        }
    }
    return root;
}

题目链接：226.翻转二叉树

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* invertTree(struct TreeNode* root) {
    if(!root)
        return NULL;
    struct TreeNode* temp = root->right;
    root->right = root->left;
    root->left = temp;
    invertTree(root->left);
    invertTree(root->right);
    return root;
}

层序

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* invertTree(struct TreeNode* root) {
    if(!root)
        return NULL;
    struct TreeNode** stack = ( struct TreeNode**)malloc(sizeof( struct TreeNode*)*101);
    int stackTop = 0;
    stack[stackTop++] = root;
    while(stackTop){
        struct TreeNode* temp = stack[--stackTop];
        struct TreeNode* tempNode = temp->right;
        temp->right = temp->left;
        temp->left = tempNode;
        if(temp->right)
            stack[stackTop++] = temp->right;
        if(temp->left)
            stack[stackTop++] = temp->left;
    } 
   return root;
}

题目链接：101. 对称二叉树

为什么要用到后序遍历

——要先比较左右两个子结点的情况，然后再比较父结点的情况

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool judge(struct TreeNode *p ,struct TreeNode *q){
    if(p == NULL && q == NULL){
        return true;
    }
    else if(p == NULL || q == NULL){
        return false;
    }
    else if(p -> val != q -> val){
        return false;
    }
    return judge(p -> left,q -> right) && judge(p -> right,q -> left);
}
bool isSymmetric(struct TreeNode* root){
    return judge(root -> left,root -> right);
}