117.填充每个节点的下一个右侧节点指针II、104.二叉树的最大深度、111.二叉树的最小深度

最新推荐文章于 2024-09-14 23:40:40 发布
最新推荐文章于 2024-09-14 23:40:40 发布
阅读量185 收藏 2
点赞数 1
分类专栏： 代码随想录 文章标签： 数据结构 c语言 leetcode 广度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48369273/article/details/136218076
版权

题目链接/文章讲解/视频讲解： 代码随想录

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

1.1分析及思路

和116.填充每个节点的下一个右侧节点指针是一样的，我们都用队列，一层一层的指。前n-1个都指向其队列后面的元素。

1.2代码及注释

typedef struct Node ElemType;  // 定义结构体 Node 为 ElemType
#define MaxSize 6001  // 定义队列的最大容量为 6001
 
typedef struct {
    ElemType* data[MaxSize];  // 存储元素的数组
    int size;  // 队列当前元素个数
    int front, rear;  // 队列头尾指针
} SqQueue;

void InitQueue(SqQueue* Queue) {
    Queue->rear = Queue->front = 0;  // 初始化队列头尾指针
    Queue->size = 0;  // 初始化队列元素个数为 0
}
 
bool isEmpty(SqQueue Queue) {
    if (Queue.rear == Queue.front)  // 判断队列是否为空
        return true;
    return false;
}
 
bool GetTopQueue(SqQueue Queue, ElemType** x) {
    if ((Queue.size == 0) || (Queue.rear == Queue.front))  // 判断队列是否为空或已满
    return false;
    
    *x = Queue.data[Queue.front];  // 获取队首元素
    return true;
}
 
bool EnQueue(SqQueue* Queue, ElemType* x) {
    if ((Queue->rear + 1) % MaxSize == Queue->front)  // 判断队列是否已满
        return false;
    
    Queue->data[Queue->rear] = x;  // 入队
    Queue->rear = (Queue->rear + 1) % MaxSize;  // 更新 rear 指针
    Queue->size++;  // 更新队列元素个数
    return true;
}
 
bool DeQueue(SqQueue* Queue, ElemType** data) {
    if ((Queue->size == 0) || (Queue->rear == Queue->front))  // 判断队列是否为空
        return false;
    
    *data = (*Queue).data[Queue->front];  // 出队
    Queue->front = (Queue->front + 1) % MaxSize;  // 更新 front 指针
    Queue->size--;  // 更新队列元素个数
    return true;
}
 
struct Node* connect(struct Node* root) {
    if(root == NULL)  // 判断根节点是否为空
        return NULL;
    
    SqQueue Queue;  // 定义队列
    InitQueue(&Queue);  // 初始化队列
    EnQueue(&Queue,root);  // 根节点入队
 
    while(!isEmpty(Queue)){  // 遍历队列中的节点
        int QueueLen = Queue.size;  // 获取当前队列长度
        struct Node* Node = NULL;  // 定义节点指针
        for(int i=0;i<QueueLen;i++){  // 遍历当前队列中的节点
            DeQueue(&Queue,&Node);  // 出队一个节点
            if (i < QueueLen - 1)  // 如果不是最后一个节点
                Node->next = Queue.data[Queue.front];  // 直接连接下一个节点
            if(Node->left != NULL)  // 如果左子节点不为空
                EnQueue(&Queue,Node->left);  // 左子节点入队
            if(Node->right != NULL)  // 如果右子节点不为空
                EnQueue(&Queue,Node->right);  // 右子节点入队
        }
    }
    return root;  // 返回根节点
}

2.104.二叉树的最大深度

2.1分析及思路

与上几个题目类似，这个就相当于求的是层数，有几层就是就是树的深度。

2.2代码及注释

typedef struct Node ElemType;  // 定义结构体 Node 为 ElemType
#define MaxSize 10001  // 定义队列的最大容量为 10001
 
typedef struct {
    ElemType* data[MaxSize];  // 存储元素的数组
    int size;  // 队列当前元素个数
    int front, rear;  // 队列头尾指针
} SqQueue;

void InitQueue(SqQueue* Queue) {
    Queue->rear = Queue->front = 0;  // 初始化队列头尾指针
    Queue->size = 0;  // 初始化队列元素个数为 0
}
 
bool isEmpty(SqQueue Queue) {
    if (Queue.rear == Queue.front)  // 判断队列是否为空
        return true;
    return false;
}
 
bool GetTopQueue(SqQueue Queue, ElemType** x) {
    if ((Queue.size == 0) || (Queue.rear == Queue.front))  // 判断队列是否为空或已满
    return false;
    
    *x = Queue.data[Queue.front];  // 获取队首元素
    return true;
}
 
bool EnQueue(SqQueue* Queue, ElemType* x) {
    if ((Queue->rear + 1) % MaxSize == Queue->front)  // 判断队列是否已满
        return false;
    
    Queue->data[Queue->rear] = x;  // 入队
    Queue->rear = (Queue->rear + 1) % MaxSize;  // 更新 rear 指针
    Queue->size++;  // 更新队列元素个数
    return true;
}
 
bool DeQueue(SqQueue* Queue, ElemType** data) {
    if ((Queue->size == 0) || (Queue->rear == Queue->front))  // 判断队列是否为空
        return false;
    
    *data = (*Queue).data[Queue->front];  // 出队
    Queue->front = (Queue->front + 1) % MaxSize;  // 更新 front 指针
    Queue->size--;  // 更新队列元素个数
    return true;
}

int maxDepth(struct TreeNode* root) {
    // 初始化高度为 0
    int high = 0;
    // 如果根节点为空，返回高度为 0
    if(root == 0)
        return high;
    
    // 定义一个队列和相关变量
    SqQueue Queue;
    int QueueLen = 0;
    struct TreeNode* Node;
    // 初始化队列并将根节点入队
    InitQueue(&Queue);
    EnQueue(&Queue,root);
    
    // 循环直到队列为空
    while(!isEmpty(Queue)){
        // 获取当前队列的长度
        QueueLen = Queue.size;
        // 遍历当前队列中的节点
        for(int i=0;i<QueueLen;i++){
            // 出队一个节点
            DeQueue(&Queue,&Node);
            // 如果节点的左子树不为空，将左子树入队
            if(Node->left != NULL)
                EnQueue(&Queue,Node->left);
            // 如果节点的右子树不为空，将右子树入队
            if(Node->right != NULL)
                EnQueue(&Queue,Node->right);
        }
        // 更新高度
        high++;
    }
    // 返回最终高度
    return high;
}

3.111.二叉树的最小深度

3.1分析及思路

运用层序遍历，当遇到一个结点左右孩子都没有时，则说明该结点的深度，就是最小深度，只需加一个判断即可。

3.2代码及注释

typedef struct Node ElemType;  // 定义结构体 Node 为 ElemType
#define MaxSize 10001  // 定义队列的最大容量为 10001
 
typedef struct {
    ElemType* data[MaxSize];  // 存储元素的数组
    int size;  // 队列当前元素个数
    int front, rear;  // 队列头尾指针
} SqQueue;

void InitQueue(SqQueue* Queue) {
    Queue->rear = Queue->front = 0;  // 初始化队列头尾指针
    Queue->size = 0;  // 初始化队列元素个数为 0
}
 
bool isEmpty(SqQueue Queue) {
    if (Queue.rear == Queue.front)  // 判断队列是否为空
        return true;
    return false;
}
 
bool GetTopQueue(SqQueue Queue, ElemType** x) {
    if ((Queue.size == 0) || (Queue.rear == Queue.front))  // 判断队列是否为空或已满
    return false;
    
    *x = Queue.data[Queue.front];  // 获取队首元素
    return true;
}
 
bool EnQueue(SqQueue* Queue, ElemType* x) {
    if ((Queue->rear + 1) % MaxSize == Queue->front)  // 判断队列是否已满
        return false;
    
    Queue->data[Queue->rear] = x;  // 入队
    Queue->rear = (Queue->rear + 1) % MaxSize;  // 更新 rear 指针
    Queue->size++;  // 更新队列元素个数
    return true;
}
 
bool DeQueue(SqQueue* Queue, ElemType** data) {
    if ((Queue->size == 0) || (Queue->rear == Queue->front))  // 判断队列是否为空
        return false;
    
    *data = (*Queue).data[Queue->front];  // 出队
    Queue->front = (Queue->front + 1) % MaxSize;  // 更新 front 指针
    Queue->size--;  // 更新队列元素个数
    return true;
}

int minDepth(struct TreeNode* root) {
    // 初始化高度为 0
    int high = 0;
    // 如果根节点为空，返回高度为 0
    if(root == 0)
        return high;
    
    // 定义一个队列和相关变量
    SqQueue Queue;
    int QueueLen = 0;
    struct TreeNode* Node;
    // 初始化队列并将根节点入队
    InitQueue(&Queue);
    EnQueue(&Queue,root);
    
    // 循环直到队列为空
    while(!isEmpty(Queue)){
        // 获取当前队列的长度
        QueueLen = Queue.size;
        // 遍历当前队列中的节点
        for(int i=0;i<QueueLen;i++){
            // 出队一个节点
            DeQueue(&Queue,&Node);
            // 如果节点的左子树不为空，将左子树入队
            if(Node->left != NULL)
                EnQueue(&Queue,Node->left);
            // 如果节点的右子树不为空，将右子树入队
            if(Node->right != NULL)
                EnQueue(&Queue,Node->right);
            // 当遇到叶子结点时就退出循环
            if((Node->right == NULL) && (Node->left == NULL))
                break;
        }
        // 更新高度
        high++;
        //遇到叶子结点就说明该高度就是最小高度
        if((Node->right == NULL) && (Node->left == NULL))
            break;
    }
    // 返回最终高度
    return high;
}

如有错误还请指正，若有疑问还请评论。

川页少年
关注
专栏目录
leetcode117. 填充每个节点的下一个右侧节点指针 II
ShawDa's Blog
03-12 1107
给定一个二叉树 struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 初始状态下，所有 next 指针都被设置为 NULL。 提示： 你只能使用常量级额外空间。 使用递归解题也符合要求，本题中递归程序占...
【LeetCode】117. 填充每个节点的下一个右侧节点指针 II
jiiiiiaaaa的博客
09-28 212
题目 给定一个二叉树 struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 初始状态下，所有next 指针都被设置为 NULL。 进阶： 你只能使用常量级额外空间。 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。 示例： 输入：ro...
LeetCode|二叉树|116.填充每个节点的下一个右侧节点指针 、117. 填充每个节点的下一个右侧节点指针 II 、 104.二叉树的最大深度 、111. 二叉树的最小深度
李___的博客
09-22 213
有关二叉树的题目（递归法和迭代法）
117. 填充每个节点的下一个右侧节点指针 II
weixin_53480838的博客
11-16 106
题目: 给定一个二叉树 struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 初始状态下，所有next 指针都被设置为 NULL。 进阶： 你只能使用常量级额外空间。 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。 示例： 输入：roo...
leetcode_117. 填充每个节点的下一个右侧节点指针 II
qq_37292201的博客
01-15 216
给定一个二叉树 struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 初始状态下，所有 next 指针都被设置为 NULL。 进阶： 你只能使用常量级额外空间。 使用递归解题也符合要求，本题中递归程序占...
leetcode刷题 117. 填充每个节点的下一个右侧节点指针 II，Medium （Java）BFS及优化
Sueko的博客
03-25 197
leetcode刷题 117. 填充每个节点的下一个右侧节点指针 II，Medium （Java）BFS及优化 中等 广度优先搜索
Leetcode刷题笔记 117. 填充每个节点的下一个右侧节点指针 II
cjl的博客
09-28 187
117. 填充每个节点的下一个右侧节点指针 II 知识点：二叉树、队列 时间：2020年9月28日 题目链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/ 题目 给定一个二叉树 struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将
0链表/二叉树中等 LeetCode117. 填充每个节点的下一个右侧节点指针 II
31楼下小黑的博客
03-05 303
117. 填充每个节点的下一个右侧节点指针 II 描述 给定一个二叉树 struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。 初始状态下，所有 next 指针都被设置为 NULL。 分析 把树看成多个上下连接的链表，不用队列借助next指针层序遍历树。 假设当前要遍历的这一层的上一层已经是nex
leetcode-117. 填充每个节点的下一个右侧节点指针 II
Stack_Alan的博客
06-02 196
leetcode-117. 填充每个节点的下一个右侧节点指针 II
Java实现 LeetCode 117 填充每个节点的下一个右侧节点指针 II（二）
01-08
117. 填充每个节点的下一个右侧节点指针 II 给定一个二叉树 struct Node { int val; Node *left; Node *right; Node *next; } 填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧...
python-leetcode面试题解之第117题填充每个节点的下一个右侧节点指针II-题解.zip
05-06
标题中的“python-leetcode面试题解之第117题填充每个节点的下一个右侧节点指针II-题解”表明这是一个关于Python编程语言在LeetCode平台上解决特定面试问题的资源。这个问题是关于填充二叉树节点的下一个右侧节点...
Rogerspy#LeetCode-Py-1#0117. 填充每个节点的下一个右侧节点指针 II1
07-25
0117. 填充每个节点的下一个右侧节点指针 II标签：树、深度优先遍历难度：中等题目大意给定一个完美二叉树，二叉树结构如下：要求填充每个 next 指针，是的
数据结构--树
wxdzuishaui的博客
09-14 443
【代码】数据结构--树。
数据结构之栈和队列的应用
zhj2003_的博客
09-11 911
栈和队列的应用十分广泛，本文简单地展示了这两种数据结构的特点，然而它的魅力不止这些，相信读者一定会遇到更加有趣的算法。上述内容如果有错误的地方，希望大佬们可以指正。我一直在学习的路上，您的帮助使我收获更大！我也会不断更新文章！
C 语言数据结构中的堆与栈：深入理解与应用
最新发布
Thanks_ks的IT探秘之旅
09-14 615
本文深入探讨了 C 语言中栈（Stack）与堆（Heap）的基本概念、特性及其在内存管理和算法实现中的重要作用。通过解析栈的后进先出特性及其在函数调用、表达式求值中的应用，以及堆作为特殊完全二叉树在优先队列、堆排序等场景下的广泛运用，帮助读者构建对这两种基础数据结构的全面理解。文章还提供了栈与堆的 C 语言实现示例，为实际编程提供参考。
数据结构--栈和队列
wxdzuishaui的博客
09-14 310
【代码】数据结构--栈和队列。
从0开始的算法（数据结构和算法）基础（十）
Solidao的博客
09-12 912
分治的字面意思是分而治之，将问题进行分化，从而进行处理，最后将结果进行合并。尽量的将问题分的不可以再分，分到和操作系统里面的原语是一样的，用较为多空间进行多线程的并行，节省时间运行。递归调用可能会导致较大的递归开销，特别是在递归深度较大的情况下，可能会导致栈溢出。在某些情况下，分治方法可能会导致对同一子问题的重复计算，从而降低效率。例如，在动态规划问题中，使用简单的分治方法可能会导致大量重复计算。
数据结构--线性表
wxdzuishaui的博客
09-14 1124
注：把我大二的数据结构实验报告当中书写的代码做一个记录，此系列仅为代码分享，无解析注：把我大二的数据结构实验报告当中书写的代码做一个记录，此系列仅为代码分享，无解析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值