递归实现遍历二叉树

 1 <!doctype html>
 2 <html lang="en">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>Document</title>
 6 </head>
 7 <body>
 8 <script>
 9         var treeNodes = [
10             {
11                 id: "1",
12                 name: ‘name1‘,
13                 children: [
14                     {
15                         id: "1-1",
16                         name: ‘name1-1‘,
17                         children: [
18                             {
19                                 id: "1-1-1",
20                                 name: ‘name1-1-1‘,
21                                 children:[]
22                             },
23                             {
24                                 id: "1-1-2",
25                                 name: ‘name1-1-2‘
26                             }
27                         ]
28                     },
29                     {
30                         id: "1-2",
31                         name: ‘name1-2‘,
32                         children: []
33                     }
34                 ],
35                 users: []
36             },
37             {
38                 id: "2",
39                 name: ‘name2‘,
40                 children: [
41                     {
42                         id: "2-2",
43                         name: ‘name2-1‘,
44                         children: []
45                     }
46                 ]
47             }
48         ];
49
50         //递归实现
51         var parseTreeJson = function(treeNodes){
52             if (!treeNodes || !treeNodes.length) return;
53
54             for (var i = 0, len = treeNodes.length; i < len; i++) {
55
56                 var childs = treeNodes[i].children;
57
58                 console.log(treeNodes[i].id+‘ID‘);
59
60                 if(childs && childs.length > 0){
61                     parseTreeJson(childs);
62                 }
63             }
64         };
65
66         console.log(‘------------- 递归实现 ------------------‘);
67         parseTreeJson(treeNodes);
68
69 </script>
70 </body>
71 </html>

此方法对二叉树提供的数据有要求,第一层循环遍历时,treeNodes,而后每深入一层,用的都是childs,比方说第二层就是children.children,第三层也是如此,这就要求提供的数据必须按照一定的格式;

时间: 2024-11-06 05:21:34

递归实现遍历二叉树的相关文章

用递归方式遍历二叉树

问题 思路说明 遍历二叉树的方法有广度优先和深度优先两类,下面阐述的是深度优先. 以下图的二叉树为例: 先定义三个符号标记: 访问结点本身(N) 遍历该结点的左子树(L) 遍历该结点的右子树(R) 有四种方式: 前序遍历(PreorderTraversal,NLR):先访问根结点,然后遍历其左右子树 中序遍历(InorderTraversal,LNR):先访问左子树,然后访问根节点,再访问右子树 后序遍历(PostorderTraversal,LRN):先访问左右子树,再访问根结点 层序遍历(l

非递归实现遍历二叉树

非递归实现二叉树主要利用queue和stack的特点,对于层次遍历二叉树主要运用queue队头出,队尾插入,先进先出的特点,先将根插入队尾,然后输出队头的元素,同时将队头的左子树和右子树元素插入队尾,依次输出输出队头的元素,同时将队头的左子树和右子树元素插入队尾,直到队列为空. void levelorder() { queue<BinaryTreeNode<T> *>s; if (_root == NULL) return; s.push(_root); while (!s.em

非递归前序遍历二叉树

#include<stdio.h> #include<stdlib.h> //定义结构体 typedef struct BiTNode { char data; struct BiTNode *lchild,*rchild; }BiNode,* pBiNode; pBiNode stack[100]; void later(pBiNode * p) //前序创建树 { char ch; scanf("%c",&ch); if(ch=='#') *p=NU

递归方式遍历二叉树:

/* * 先根序 */ public static void beforeShow(Node node) { if (node == null) { return; } System.out.println(node.data); beforeShow(node.left); beforeShow(node.right); } /* * 中根序 */ public static void middleShow(Node node) { if (node == null) { return; }

非递归方式遍历二叉树

/** * 非递归方式的先根序 * @param root */ public static void preOrder(Node root){ Stack<Node> stack = new Stack<Node>(); while (!stack.isEmpty() || root != null) { while (root != null) { System.out.println(root.data); stack.push(root); root = root.left

完整类实现:构造,析构,遍历二叉树

根据前面一个博文内容已经讲述了如何根据两种遍历方式进行构建二叉树 这里利用递归方式遍历二叉树,递归方式比较简单,后续补充其余非递归方式 再此主要是完善类的使用: 其中重点在于:接口定义 二叉树的析构删除 以及类成员变量中如果有指针,同时涉及复制构造函数和赋值操作符函数时需要用到的智能指针 如果接口方面定义不够好,还望包涵 如果有对智能指针不理解的地方,可以移步 http://blog.csdn.net/xietingcandice/article/details/39670269 .h文件 #i

Qt实现 动态化遍历二叉树(前中后层次遍历)

binarytree.h 头文件 1 #ifndef LINKEDBINARYTREE_H 2 #define LINKEDBINARYTREE_H 3 #include<c++/algorithm> 4 #include<c++/cstdio> 5 #include<string> 6 #include<c++/string> 7 #include<c++/vector> 8 #include<vector> 9 #include&

JAVA递归、非递归遍历二叉树(转)

原文链接: JAVA递归.非递归遍历二叉树 import java.util.Stack; import java.util.HashMap; public class BinTree { private char date; private BinTree lchild; private BinTree rchild; public BinTree(char c) { date = c; } // 先序遍历递归 public static void preOrder(BinTree t) {

递归遍历二叉树

递归遍历分三种: 1.前序遍历二叉树(二叉树非空) 1.访问根节点 2.前序遍历左子树 3.前序遍历右子树 2.中序遍历二叉树(二叉树非空) 1.中序遍历左子树 2.访问根节点 3.中序遍历右子树 3.后序遍历二叉树(二叉树非空) 1.后序遍历左子树 2.后序遍历右子树 3.访问根节点 三种递归的算法遍历,终止条件是二叉树为空的时候. 记忆的方法呢,前中后,都是以根节点命名的,前序,先访问根节点,中序,根节点在第二,后序,根节点最后进行访问.