【树】Level_Order_Traversal

最新推荐文章于 2020-04-13 17:36:08 发布
原创 最新推荐文章于 2020-04-13 17:36:08 发布 · 302 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#树 #遍历

本文介绍了一种实现二叉树层序遍历的方法，使用数组存储每一层的节点，并通过递增的方式记录队列的头部和尾部，确保每个节点只被访问一次。最后对所有节点进行操作。
void Level_order(Tree T, void (*visit)(Tree ThisNode))
{
Tree a[105];
int front, rear, i;
i = front = rear = 0;
a[rear] = T;
if (a[i] == NULL) return;
while (i <= rear)
{

if (a[i]->Left != NULL)
{
rear++;
a[rear] = a[i]->Left;
}
if (a[i]->Right != NULL)
{
rear++;
a[rear] = a[i]->Right;
}
i++;
}
for (i = 0; i <= rear; i++)
{
(*visit)(a[i]);
}
return;
}
Kenneth_Sun
关注
数据结构C语言版（李云清）实验6 树
优快云admin00的博客
12-28 4897
实验6 树 1、编写算法函数void levelorder(tree t)实现树的层次遍历。 #include "tree.h" void levelorder(tree t) /* t为指向树根结点的指针*/ { tree queue[MAXLEN]; /*用队列存放待处理的结点*/ int head=0,end=1; int i; queue[head] = t;...
Binary Tree Level Order Tranversal
RockPaperProgrammer
06-14 270
Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level). For example: Given binary tree [3,9,20,null,null,15,7], 3 / \ 9 2
[LintCode] 二叉树的层序遍历 Binary Tree Level Order Tranversal
wutingyehe的专栏
04-20 708
给出一棵二叉树，返回其节点值的层次遍历（逐层从左往右访问）样例 给一棵二叉树 {3,9,20,#,#,15,7} ： 3 / \ 9 20 / \ 15 7 返回他的分层遍历结果： [ [3], [9,20], [15,7] ]只使用一个队列：/** * Definition of TreeNode: * public class Tree
N-ary Tree Level Order Traversal N叉树的层序遍历
qq_26410101的博客
09-12 199
给定一个N叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。   例如，给定一个 3叉树 :     返回其层序遍历: [ [1], [3,2,4], [5,6] ]   说明: 树的深度不会超过 1000。 树的节点总数不会超过 5000。 思路：这道题其实就是树的层序遍历，按照之前二叉树的层序遍历进行就行，我们需要一个辅助队列q...
二叉树水平顺序遍历level-order traversal
“点点”专栏
09-30 4493
有个很有名的算法叫广度优先搜索（Breadth-First Search）BFS，这个算法被用于遍历或者搜索数据结构，比如树或者图。 BFS使用到树上就是level-order traversal. 进行广度优先搜索算法时，需要用到java的Queue，Queue是继承自Collection的，所以Collection中的方法都是可以用的。 Queue常用方法：offer、poll、size...
binary-tree-level-order-traversal
weixin_36909758的博客
05-28 324
（i） 【题目描述】Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level). For example: Given binary tree{3,9,20,#,#,15,7}, 3 / 9 20 / 15 7 r...
Binary_Tree_Level_Order_Traversa
03-12
从文件名称“Binary_Tree_Level_Order_Traversal_II”来看，这可能涉及到层次遍历的变种或扩展问题。例如，可能需要实现非递归版本的层次遍历，或者在层次遍历的基础上解决更复杂的问题，比如找出二叉树每一层的节点...
class TreeNode: """ 孩子兄弟表示法的节点类 """ def __init__(self, data): self.data = data # 节点数据 self.firstChild = None # 第一个孩子 self.nextSibling = None # 下一个兄弟 class Tree: def __init__(self, root_data): self.root = TreeNode(root_data) def build_tree(): # 创建节点 A = Tree('A').root B = TreeNode('B') C = TreeNode('C') D = TreeNode('D') E = TreeNode('E') F = TreeNode('F') G = TreeNode('G') H = TreeNode('H') I = TreeNode('I') J = TreeNode('J') K = TreeNode('K') L = TreeNode('L') M = TreeNode('M') # 设置孩子关系（firstChild） A.firstChild = B B.firstChild = E C.firstChild = G D.firstChild = M E.firstChild = K # 设置兄弟关系（nextSibling） B.nextSibling = C C.nextSibling = D E.nextSibling = F H.nextSibling = I I.nextSibling = J K.nextSibling = L return A def parent_representation(): """ 双亲表示法：返回 (data, parent_index) 列表 """ nodes = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I','J', 'K', 'L', 'M'] parents = [-1, 0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5] # 索引对应双亲位置 print("双亲表示法:") for i, data in enumerate(nodes): print(f"Index {i}: {data}, Parent Index: {parents[i]}") def level_order_traversal(root): """ 层次遍历（广度优先） """ if not root: return [] result = [] queue = [root] while queue: node = queue.pop(0) result.append(node.data) # 先加入第一个孩子 child = node.firstChild while child: queue.append(child) child = child.nextSibling return result def pre_order_traversal(root): """ 先序遍历（DLR） """ if not root: return [] return [root.data] + pre_order_traversal(root.firstChild) + pre_order_traversal(root.nextSibling) def in_order_traversal(root): """ 中序遍历（LDR） """ if not root: return [] left = in_order_traversal(root.firstChild) middle = [root.data] right = in_order_traversal(root.nextSibling) return left + middle + right def post_order_traversal(root): """ 后序遍历（LRD） """ if not root: return [] left = post_order_traversal(root.firstChild) right = post_order_traversal(root.nextSibling) return left + right + [root.data] # 主程序执行 if __name__ == "__main__": # 1. 双亲表示法 parent_representation() print() # 2. 构建孩子兄弟表示法的树 root = build_tree() # 层次遍历 print("层次遍历:", " ".join(level_order_traversal(root))) # 先序遍历 print("先序遍历:", " ".join(pre_order_traversal(root))) # 中序遍历 print("中序遍历:", " ".join(in_order_traversal(root))) # 后序遍历 print("后序遍历:", " ".join(post_order_traversal(root)))
最新发布
11-14
[root.data] + pre_order_traversal(root.firstChild) + pre_order_traversal(root.nextSibling) 注意：对于根节点A，先访问A，然后递归遍历A的第一个孩子B（得到B及其所有子孙），然后递归遍历A的兄弟？但是A...
优化下面代码class TreeNode: def __init__(self, val): self.val = val self.left = None self.right = None root = TreeNode('a') root.left = TreeNode('b') root.right = TreeNode('c') root.left.left = TreeNode('d') root.left.right = TreeNode('e') root.right.left = TreeNode('f') root.right.right = TreeNode('g') root.left.left.left = TreeNode('h') root.left.left.right = TreeNode('i') def preorder_traversal(root): if not root: return print(root.val, end=' ') preorder_traversal(root.left) preorder_traversal(root.right) def inorder_traversal(root): if not root: return inorder_traversal(root.left) print(root.val, end=' ') inorder_traversal(root.right) def postorder_traversal(root): if not root: return postorder_traversal(root.left) postorder_traversal(root.right) print(root.val, end=' ') from collections import deque def level_order_traversal(root): if not root: return queue = deque() queue.append(root) while queue: node = queue.popleft() print(node.val, end=' ') if node.left: queue.append(node.left) if node.right: queue.append(node.right) def get_height(root): if not root: return 0 left_height = get_height(root.left) right_height = get_height(root.right) return max(left_height, right_height) + 1 def get_node_count(root): if not root: return 0 left_node_count = get_node_count(root.left) right_node_count = get_node_count(root.right) return left_node_count + right_node_count + 1 print("先序遍历：") preorder_traversal(root) print("中序遍历：") inorder_traversal(root) print("后序遍历：") postorder_traversal(root) print("层次遍历：") level_order_traversal(root) print("该二叉树的高度为：") get_height(root) print("该二叉树的节点个数为 ") get_node_count(root)
06-01
print("层次遍历：", list(level_order_traversal(root))) height, node_count = get_tree_info(root) print("该二叉树的高度为：", height) print("该二叉树的节点个数为：", node_count) ```
from collections import deque class TreeNode: def __init__(self, val): self.val = val self.children = [] def build_tree(n, edges): nodes = {} parents = set() children = set() for p, c in edges: parents.add(p) children.add(c) if p not in nodes: nodes[p] = TreeNode(p) if c not in nodes: nodes[c] = TreeNode(c) nodes[p].children.append(nodes[c]) root_val = (parents - children).pop() return nodes[root_val] def level_order_traversal(root): result = [] queue = deque([root]) while queue: node = queue.popleft() result.append(node.val) queue.extend(node.children) return result n = int(input()) edges = [eval(input()) for j in range(n)] root = build_tree(n, edges) print(level_order_traversal(root)) 问题
04-01
print(level_order(tree, 'A')) # 输出: ['A','B','C','D'] ``` #### 4. 关键特性说明 1. **邻接表优势**：空间复杂度为$O(n)$，适合存储稀疏树结构[^2] 2. **队列选择**：使用`deque`实现$O(1)$时间复杂度的头尾...
数据结构与算法[LeetCode]—Binary Tree Level Order Traversal II 从底至上层次输出二叉树每层元素
清水
06-18 1343
Binary Tree Level Order Traversal II
挑战408——数据结构（19）——树的遍历（先序，中序，后序）
redAnt的博客
11-05 892
树的存储结构 之前我们提到过堆是一棵特殊的树，在堆的存储方式中，我们选择了数组的方式去存储。因为只要知道一个节点的位置我们就能找到其他的节点的位置。但是前提是堆是一棵完全二叉树。树的结构多种多样，没人规定说一个节点只能有一个孩子。 我们先看下图，一个最简单的二叉树： 怎么表达？看到箭头，我们应该立马反应过来一个基本的工具，没错就是指针，应该立马反应过来一个数据结构，那就是链表！ 把value换...
数据结构实验6-树
12-05 4414
/* 编写算法函数void levelorder(tree t)实现树的层次遍历。 */#include "tree.h"void levelorder(tree t) /* t为指向树根结点的指针*/ { tree queue[100]; int f,r,i; //f,r分别为队头和队尾指针 tree p; f=0; r=1; queue[0]=t;
数据结构——二叉树的遍历
uilotus
08-01 1409
二叉树主要有三种遍历方式：前序遍历、中序遍历和后序遍历，每种方式都有递归和非递归两种方法。递归的方法简单明了，但是会比较耗时，非递归的方法效率相对较高，但是算法也比较晦涩。本文就这三种遍历方式做简单的介绍。
Level-order Traversal
dxz935的博客
10-15 3360
Write a routine to list out the nodes of a binary tree in "level-order". List the root, then nodes at depth 1, followed by nodes at depth 2, and so on. You must do this in linear time. Format of func
二叉树 level order 遍历问题汇总
binling的专栏
12-26 1766
一 如何确定层结束？ 1 维护一个levelEnd，如果当前结点是level end，更新levelEnd 为queue.back()，注意先判断queue是否empty，（最后一层结束后，queue就空了）。 2 维护一个curLevelNum 和 一个nextLevelNum，当curLevelNum count down 到0时候，交替 3 遍历完一层的时候，队列里的元素就是下一层的所
6-6-Level-order Traversal-函数题
Aruasg的博客
04-13 426
6-6-Level-order Traversal-函数题解题代码测试结果问题整理 解题代码 void Level_order(Tree T, void(*visit)(Tree ThisNode)) { Tree* queue = (Tree)malloc(10 * sizeof(struct TreeNode)); int front = -1, rear = -1; queue[++r...
4-3 Level-order Traversal   (25分)
叶鸿飞的博客
01-10 1498
4-3 Level-order Traversal   (25分) Write a routine to list out the nodes of a binary tree in "level-order". List the root, then nodes at depth 1, followed by nodes at depth 2, and so on. You must
Level-order Traversal（c语言函数指针样例）
weixin_30386713的博客
10-25 435
Write a routine to list out the nodes of a binary tree in “level-order”. List the root, then nodes at depth 1, followed by nodes at depth 2, and so on. You must do this in linear time...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值