1 /// <summary>
2 /// 二叉树
3 /// </summary>
4 /// <typeparam name="T"></typeparam>
5 class Road<T>
6 {
7 T data;
8 Road<T> Lnode, rnode, pnode;
9 public T Data
10 {
11 get { return data; }
12 set { data = value; }
13 }
14 public Road<T> LNode
15 {
16 get { return Lnode; }
17 set { Lnode = value; }
18 }
19 public Road<T> RNode
20 {
21 get { return rnode; }
22 set { rnode = value; }
23 }
24 public Road<T> PNode
25 {
26 get { return pnode; }
27 set { pnode = value; }
28 }
29 public Road() { }
30 public Road(T data)
31 {
32 this.data = data;
33 }
34 }
35
36 class 叉树测试
37 {
38 //测试的主方法
39 static void Main(string[] args)
40 {
41 Road<string> rootNode = BinTree();
42 Stack<string> stack = new Stack<string>();
43 findPathNode<string>(rootNode, stack);
44 Console.WriteLine("");
45
46 RoadLink<string> roadNode = BinRoad();
47 Stack<string> roadStack = new Stack<string>();
48 findPath<string>(roadNode, roadStack);
49 Console.WriteLine("over");
50 Console.Read();
51 }
52
53 static Road<string> BinTree()
54 {
55 Road<string>[] binTree = new Road<string>[8];
56
57 //创建节点
58 binTree[0] = new Road<string>("A");
59 binTree[1] = new Road<string>("B");
60 binTree[2] = new Road<string>("C");
61 binTree[3] = new Road<string>("D");
62 binTree[4] = new Road<string>("E");
63 binTree[5] = new Road<string>("F");
64 binTree[6] = new Road<string>("G");
65 binTree[7] = new Road<string>("H");
66
67 //使用层次遍历二叉树的思想，构造一个已知的二叉树
68 binTree[0].LNode = binTree[1];
69 binTree[0].RNode = binTree[2];
70 binTree[1].RNode = binTree[3];
71 binTree[2].LNode = binTree[4];
72 binTree[2].RNode = binTree[5];
73 binTree[3].LNode = binTree[6];
74 binTree[3].RNode = binTree[7];
75
76 //返回二叉树根节点
77 return binTree[0];
78 }
79
80 static void findPathNode<T>(Road<T> root, Stack<T> stack)
81 {
82 if (root == null)
83 {
84 return;
85 }
86 // 把当前结点进栈
87 stack.Push(root.Data);
88 // 如果是叶子结点，而且和为给定的值，则打印路径
89 bool isLeaf = root.LNode == null && root.RNode == null;
90 if (isLeaf)
91 {
92 List<object> tmpDatas = new List<object>();
93 foreach (var item in stack)
94 {
95 tmpDatas.Add(item);
96 }
97 tmpDatas.Reverse();
98
99 foreach (var item in tmpDatas)
100 {
101 Console.Write(item + "-");
102 }
103 Console.WriteLine("");
104
105 }
106
107 // 如果不是叶子结点，则遍历它的子结点
108 if (root.LNode != null)
109 {
110 findPathNode(root.LNode, stack);
111 }
112 if (root.RNode != null)
113 {
114 findPathNode(root.RNode, stack);
115 }
116 // 在返回到父结点之前，在路径上删除当前结点
117 stack.Pop();
118 }
119
120 static RoadLink<string> BinRoad()
121 {
122 RoadLink<string>[] binTree = new RoadLink<string>[10];
123
124 //创建节点
125 binTree[0] = new RoadLink<string>("A");
126 binTree[1] = new RoadLink<string>("B");
127 binTree[2] = new RoadLink<string>("C");
128 binTree[3] = new RoadLink<string>("D");
129 binTree[4] = new RoadLink<string>("E");
130 binTree[5] = new RoadLink<string>("F");
131 binTree[6] = new RoadLink<string>("G");
132 binTree[7] = new RoadLink<string>("H");
133 binTree[8] = new RoadLink<string>("I");
134 binTree[9] = new RoadLink<string>("J");
135
136 //使用层次遍历二叉树的思想，构造一个已知的二叉树
137 binTree[0].SubRoads = new List<object>();
138 binTree[0].SubRoads.Add(binTree[1]);
139 binTree[0].SubRoads.Add(binTree[2]);
140
141 binTree[1].SubRoads = new List<object>();
142 binTree[1].SubRoads.Add(binTree[3]);
143
144 binTree[2].SubRoads = new List<object>();
145 binTree[2].SubRoads.Add(binTree[3]);
146
147 binTree[3].SubRoads = new List<object>();
148 binTree[3].SubRoads.Add(binTree[4]);
149 binTree[3].SubRoads.Add(binTree[5]);
150 binTree[3].SubRoads.Add(binTree[7]);
151
152 binTree[4].SubRoads = new List<object>();
153 binTree[4].SubRoads.Add(binTree[6]);
154
155 binTree[5].SubRoads = new List<object>();
156 binTree[5].SubRoads.Add(binTree[6]);
157
158 binTree[7].SubRoads = new List<object>();
159 binTree[7].SubRoads.Add(binTree[8]);
160 binTree[7].SubRoads.Add(binTree[9]);
161
162 binTree[8].SubRoads = new List<object>();
163 binTree[8].SubRoads.Add(binTree[6]);
164
165 binTree[9].SubRoads = new List<object>();
166 binTree[9].SubRoads.Add(binTree[6]);
167
168 //返回二叉树根节点
169 return binTree[0];
170 }
171
172 static void findPath<T>(RoadLink<T> root, Stack<T> stack)
173 {
174 if (root == null)
175 {
176 return;
177 }
178 // 把当前结点进栈
179 stack.Push(root.Data);
180 // 如果是叶子结点，而且和为给定的值，则打印路径
181 bool isLeaf = root.SubRoads == null;
182 //bool isLeaf = root.Data.Equals("E");//寻找的点
183 if (isLeaf)
184 {
185 List<object> tmpDatas = new List<object>();
186 foreach (var item in stack)
187 {
188 tmpDatas.Add(item);
189 }
190 tmpDatas.Reverse();
191
192 foreach (var item in tmpDatas)
193 {
194 Console.Write(item + "-");
195 }
196 Console.WriteLine("");
197
198 }
199 // 如果不是叶子结点，则遍历它的子结点
200 if (root.SubRoads != null)
201 {
202 foreach (var item in root.SubRoads)
203 {
204 var obj = item as RoadLink<T>;
205 findPath(obj, stack);
206 }
207
208 }
209 // 在返回到父结点之前，在路径上删除当前结点
210 stack.Pop();
211 }
212 }
213
214 /// <summary>
215 /// 多叉树
216 /// </summary>
217 /// <typeparam name="T"></typeparam>
218 class RoadLink<T>
219 {
220 T data;
221 /// <summary>
222 /// 子节点
223 /// </summary>
224 List<object> subRoads = null;
225 public T Data
226 {
227 get { return data; }
228 set { data = value; }
229 }
230 /// <summary>
231 /// 子节点
232 /// </summary>
233 public List<object> SubRoads
234 {
235 get { return subRoads; }
236 set { subRoads = value; }
237 }
238 public RoadLink() { }
239 public RoadLink(T data)
240 {
241 this.data = data;
242 }
243
244 public void AddSubRoad(object subRoad)
245 {
246 if (subRoads == null) subRoads = new List<object>();
247 if (subRoads.Contains(subRoad)) subRoads.Add(subRoad);
248 }
249 }
二叉树、多叉树子路径遍历
时间： 2024-11-09 03:54:13
二叉树、多叉树子路径遍历的相关文章
二叉树递归与非递归遍历，最近公共父节点算法
#include <iostream> #include <stack> using namespace std; #define MAX 100 //字符串最大长度 typedef struct Node //二叉树结点 { char data; Node *lchild,*rchild; } *Btree; void createBT(Btree &t); //先序构造二叉树 void preorder(Btree &t); //二叉树递归先序遍历 void i
[LeetCode] Binary Tree Zigzag Level Order Traversal 二叉树的之字形层序遍历
Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between). For example:Given binary tree {3,9,20,#,#,15,7}, 3 / 9 20 / 15 7 return its zigz
七：重建二叉树（根据先序遍历（或者后序遍历）和中序遍历重建二叉树）
对于一颗二叉树,可以根据先序遍历(或者后序遍历)和中序遍历(树中不含重复的数字)重新还原出二叉树. 解析: 1. 先序遍历序列的第一个元素必定是根节点,可以由此获取二叉树的根节点. 2. 根据根节点,在中序遍历序列中查找该节点,由中序遍历的性质可知,中序遍历中该根节点左边的序列必定在根节点的左子树中,而根节点右边的序列必定在右子树中.由此可以知道先序遍历中左子树以及右子树的起止位置. 3. 找到了左右子树前序遍历和中序遍历再用同样的方法分别构建左右子树,典型的递归思想. 代码如下: Binary
算法题——二叉树结点的中序遍历的后继结点
题目:给出二叉树的一个结点,返回它中序遍历顺序的下一个结点. 思路: 如果有指向父亲的结点,则: 如果当前结点有右儿子,或者当前结点是根结点,则后继结点为右子树的最左叶节点: 否则,如果当前结点是父结点的左儿子,则后继结点就是父结点:(其实是第三种情况的一个特例,即自己是第0代祖先,返回第一代祖先) 否则,向上遍历,直到n-1代祖先是n代祖先的左儿子,则后继结点为n代祖先:或者遍历到根节点后未找到符合的n代结点,则该结点为中序遍历的最后结点,没有后继. 时间复杂度为树的高度O(lgN). 代码:
LeetCode 103 二叉树的锯齿形层次遍历 以及 LinkedList
LeetCode103 二叉树的锯齿形层次遍历: 给定一个二叉树,返回其节点值的锯齿形层次遍历.(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行). 例如:给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7返回锯齿形层次遍历如下:[[3],[20,9],[15,7]] import java.util.List; import java.util.ArrayList; import java.util.LinkedList;
树（二叉树）的建立和遍历算法（一）（前序，中序，后序）
最近学习树的概念,有关二叉树的实现算法记录下来... 不过学习之前要了解的预备知识:树的概念:二叉树的存储结构:二叉树的遍历方法.. 二叉树的存储结构主要了解二叉链表结构,也就是一个数据域,两个指针域,(分别为指向左右孩子的指针),从下面程序1,二叉树的存储结构可以看出. 二叉树的遍历方法:主要有前序遍历,中序遍历,后序遍历,层序遍历.(层序遍历下一篇再讲,本篇主要讲的递归法) 如这样一个二叉树: 它的前序遍历顺序为:ABDGHCEIF(规则是先是根结点,再前序遍历左子树,再前序遍历右子树) 它
Java学习(十八)：二叉树的三种递归遍历
二叉树的三种递归遍历: 1 public class StudentNode 2 { 3 private String name; 4 5 private StudentNode leftNode; 6 7 private StudentNode rightNode; 8 9 public String getName() 10 { 11 return name; 12 } 13 14 public void setName(String name) 15 { 16 this.name = na
写了一个二叉树构造及中序遍历函数
本题就是测试读入数据的速度的. 如果有大量的数据读入,使用cin是很慢的. 那么使用scanf那么会快很多,但是如果数据量更大的话那么就还是不够快了. 所以这里使用fread. 首先开一个buffer,然后使用fread大块大块地读入数据就可以非常快地读入了. 题目如下: Input The input begins with two positive integers n k (n, k<=107). The next n lines of input contain one positive
lintcode 二叉树的锯齿形层次遍历 （双端队列）
题目链接: http://www.lintcode.com/zh-cn/problem/binary-tree-zigzag-level-order-traversal/ 二叉树的锯齿形层次遍历 给出一棵二叉树,返回其节点值的锯齿形层次遍历(先从左往右,下一层再从右往左,层与层之间交替进行) 样例 给出一棵二叉树 {3,9,20,#,#,15,7}, 3 / 9 20 / 15 7 返回其锯齿形的层次遍历为: [ [3], [20,9], [15,7] ] 思路: 我们用双端队列模拟一下这个过程