代码随想录算法训练营day15层序遍历

102.二叉树的层序遍历

关于数组与指针

去二维数组地址的操作

int main()
{
    int arr[2][3];
    arr[0][0] = 1;
    printf("%p\n",&arr[0][0]);
    printf("%p",arr[0]);

    return 0;
}

上示代码的两个printf都输出的是同一地址

代码???二维数组和指针到底是什么关系啊

1. 利用队列先压入根节点，弹出来放到结果数组里面
2. 接着判断有无左右子树并压入队列，为了锁定哪些是本次压入这一层的数值需要有一个变量记录大小，此时队列中的元素是上一层的下一层全部的元素，所以队列的大小就是该层的大小。故在for循环中完成弹出本层以及压入下一层的操作。
3. 在此之前会先定义一个数组vec记录本层的数据再原封不动的给result数组

result[*returnSize] = vec; // 将当前层向量添加至结果数组

/**
 * 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().
 */
 // Define the queue structure
struct Queue {
    struct TreeNode** arr;
    int front;
    int back;
    int size;
};

// Function to initialize the queue
struct Queue* createQueue(int capacity) {
    struct Queue* queue = (struct Queue*)malloc(sizeof(struct Queue));
    queue->arr = (struct TreeNode**)malloc(sizeof(struct TreeNode*) * capacity);
    queue->front = queue->size = 0;
    queue->back = capacity - 1;
    return queue;
}

// Function to check if queue is full
int isFull(struct Queue* queue) {
    return queue->size == 1000;
}

// Function to check if queue is empty
int isEmpty(struct Queue* queue) {
    return queue->size == 0;
}

// Function to add an item to the queue
void enqueue(struct Queue* queue, struct TreeNode* item) {
    if (isFull(queue)) return;
    queue->back = (queue->back + 1) % 1000;
    queue->arr[queue->back] = item;
    queue->size = queue->size + 1;
}

// Function to remove an item from the queue
struct TreeNode* dequeue(struct Queue* queue) {
    if (isEmpty(queue)) return NULL;
    struct TreeNode* item = queue->arr[queue->front];
    queue->front = (queue->front + 1) % 1000;
    queue->size = queue->size - 1;
    return item;
}
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    struct Queue* que = createQueue(1000); // 创建队列
    if (root != NULL) enqueue(que, root); // 如果根不为空，就将其添加到队列中
    int** result = (int**)malloc(sizeof(int*) * 1000);
    *returnColumnSizes = (int*)malloc(sizeof(int) * 1000);
    *returnSize = 0;
    while (!isEmpty(que)) {
        int size = que->size;
        int* vec = (int*)malloc(sizeof(int) * size);
        int vec_size = 0;
        for (int i = 0; i < size; i++) {
            struct TreeNode* node = dequeue(que); // 从队列中获取元素
            vec[vec_size++] = node->val; // 将当前节点的值添加到当前层向量
            if (node->left) enqueue(que, node->left); // 如果左孩子不为空，则将其添加至队列
            if (node->right) enqueue(que, node->right); // 如果右孩子不为空，则将其添加至队列
        }
        result[*returnSize] = vec; // 将当前层向量添加至结果数组
        (*returnColumnSizes)[*returnSize] = vec_size; // 设置当前层的返回列大小
        (*returnSize)++; // 增加层数计数
    }
    // free(que->arr);
    // free(que);
    return result;
}

226.交换二叉树左右子树

递归法

交换完本层的两节点在调用自己去交换下一层的子树
注意swap函数要用二级指针还是不是很懂

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


void swap(struct TreeNode** root1,struct TreeNode** root2)
{
    struct TreeNode* new = *root1;
    *root1 = *root2;
    *root2 = new;
}

struct TreeNode* invertTree(struct TreeNode* root){
    if(root == NULL) return NULL;
    swap(&(root->left),&(root->right));
    invertTree(root->left);
    invertTree(root->right);

    return root;
}

101.对称二叉树

先判断空指针的情况
关于根节点对称，而非每个小子树分别对称

两边的（左左右右）靠里的（左右右左）

    bool ri = compare(right->right,left->left);
    bool le = compare(right->left,left->right);

bool compare(struct TreeNode* left,struct TreeNode* right)
{
    if(left == NULL&&right!=NULL) return false;
    else if(left != NULL&&right == NULL) return false;
    else if(left == NULL&&right == NULL) return true;
    else if(left->val!=right->val) return false;
    bool ri = compare(right->right,left->left);
    bool le = compare(right->left,left->right);
    bool is = ri&≤

    return is;
}


bool isSymmetric(struct TreeNode* root){
    if(root == NULL)
    return true;
    else
    return compare(root->left,root->right);
}