java数据结构之二叉树的前中后遍历

分手后的思念是犯贱 2022-09-21 13:08 54阅读 0赞

感谢[笃志近思][Link 1]的分享。原文链接地址为：[点击打开链接][Link 2]

## 二叉树的定义： ##

二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。  
    二叉树(BinaryTree)是n(n≥0)个结点的有限集，它或者是空集(n=0)，或者由一个根结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。  
    这个定义是递归的。由于左、右子树也是二叉树， 因此子树也可为空树。下图中展现了五种不同基本形态的二叉树。

![SouthEast][]

其中 (a) 为空树， (b) 为仅有一个结点的二叉树， (c) 是仅有左子树而右子树为空的二叉树， (d) 是仅有右子树而左子树为空的二叉树， (e) 是左、右子树均非空的二叉树。这里应特别注意的是，二叉树的左子树和右子树是严格区分并且不能随意颠倒的，图 (c) 与图 (d) 就是两棵不同的二叉树。

## 二叉树的遍历 ##

对于二叉树来讲最主要、最基本的运算是遍历。  
    遍历二叉树 是指以一定的次序访问二叉树中的每个结点。所谓 访问结点 是指对结点进行各种操作的简称。例如，查询结点数据域的内容，或输出它的值，或找出结点位置，或是执行对结点的其他操作。遍历二叉树的过程实质是把二叉树的结点进行线性排列的过程。假设遍历二叉树时访问结点的操作就是输出结点数据域的值，那么遍历的结果得到一个线性序列。

从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作：  
    　（1）访问结点本身(N)，  
    　（2）遍历该结点的左子树(L)，  
    　（3）遍历该结点的右子树(R)。  
以上三种操作有六种执行次序：  
    　NLR、LNR、LRN、NRL、RNL、RLN。  
注意：  
    前三种次序与后三种次序对称，故只讨论先左后右的前三种次序。  
　　由于被访问的结点必是某子树的根，所以N(Node)、L(Left subtlee)和R(Right subtree)又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

## 二叉树的java实现 ##

首先创建一棵二叉树如下图，然后对这颗二叉树进行遍历操作（遍历操作的实现分为递归实现和非递归实现），同时还提供一些方法如获取双亲结点、获取左孩子、右孩子等。

![SouthEast 1][]

[Java][]实现代码：

**\[java\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** study\_02.datastructure.tree;  
2.    
3.  **import** java.util.Stack;  
4.    
5.  /\*\* 
6.   \* 二叉树的链式存储 
7.   \* @author WWX 
8.   \*/  
9.  **public** **class** BinaryTree \{  
10.   
11.       
12.     **private** TreeNode root=**null**;  
13.       
14.     **public** BinaryTree()\{  
15.         root=**new** TreeNode(1,"rootNode(A)");  
16.     \}  
17.       
18.     /\*\* 
19.      \* 创建一棵二叉树 
20.      \* <pre> 
21.      \*           A 
22.      \*     B          C 
23.      \*  D     E            F 
24.      \*  </pre> 
25.      \* @param root 
26.      \* @author WWX 
27.      \*/  
28.     **public** **void** createBinTree(TreeNode root)\{  
29.         TreeNode newNodeB = **new** TreeNode(2,"B");  
30.         TreeNode newNodeC = **new** TreeNode(3,"C");  
31.         TreeNode newNodeD = **new** TreeNode(4,"D");  
32.         TreeNode newNodeE = **new** TreeNode(5,"E");  
33.         TreeNode newNodeF = **new** TreeNode(6,"F");  
34.         root.leftChild=newNodeB;  
35.         root.rightChild=newNodeC;  
36.         root.leftChild.leftChild=newNodeD;  
37.         root.leftChild.rightChild=newNodeE;  
38.         root.rightChild.rightChild=newNodeF;  
39.     \}  
40.       
41.       
42.     **public** **boolean** isEmpty()\{  
43.         **return** root==**null**;  
44.     \}  
45.   
46.     //树的高度  
47.     **public** **int** height()\{  
48.         **return** height(root);  
49.     \}  
50.       
51.     //节点个数  
52.     **public** **int** size()\{  
53.         **return** size(root);  
54.     \}  
55.       
56.       
57.     **private** **int** height(TreeNode subTree)\{  
58.         **if**(subTree==**null**)  
59.             **return** 0;//递归结束：空树高度为0  
60.         **else**\{  
61.             **int** i=height(subTree.leftChild);  
62.             **int** j=height(subTree.rightChild);  
63.             **return** (i<j)?(j+1):(i+1);  
64.         \}  
65.     \}  
66.       
67.     **private** **int** size(TreeNode subTree)\{  
68.         **if**(subTree==**null**)\{  
69.             **return** 0;  
70.         \}**else**\{  
71.             **return** 1\+size(subTree.leftChild)  
72.                     +size(subTree.rightChild);  
73.         \}  
74.     \}  
75.       
76.     //返回双亲结点  
77.     **public** TreeNode parent(TreeNode element)\{  
78.         **return** (root==**null**|| root==element)?**null**:parent(root, element);  
79.     \}  
80.       
81.     **public** TreeNode parent(TreeNode subTree,TreeNode element)\{  
82.         **if**(subTree==**null**)  
83.             **return** **null**;  
84.         **if**(subTree.leftChild==element||subTree.rightChild==element)  
85.             //返回父结点地址  
86.             **return** subTree;  
87.         TreeNode p;  
88.         //现在左子树中找，如果左子树中没有找到，才到右子树去找  
89.         **if**((p=parent(subTree.leftChild, element))!=**null**)  
90.             //递归在左子树中搜索  
91.             **return** p;  
92.         **else**  
93.             //递归在右子树中搜索  
94.             **return** parent(subTree.rightChild, element);  
95.     \}  
96.       
97.     **public** TreeNode getLeftChildNode(TreeNode element)\{  
98.         **return** (element!=**null**)?element.leftChild:**null**;  
99.     \}  
100.       
101.     **public** TreeNode getRightChildNode(TreeNode element)\{  
102.         **return** (element!=**null**)?element.rightChild:**null**;  
103.     \}  
104.       
105.     **public** TreeNode getRoot()\{  
106.         **return** root;  
107.     \}  
108.       
109.     //在释放某个结点时，该结点的左右子树都已经释放，  
110.     //所以应该采用后续遍历，当访问某个结点时将该结点的存储空间释放  
111.     **public** **void** destroy(TreeNode subTree)\{  
112.         //删除根为subTree的子树  
113.         **if**(subTree!=**null**)\{  
114.             //删除左子树  
115.             destroy(subTree.leftChild);  
116.             //删除右子树  
117.             destroy(subTree.rightChild);  
118.             //删除根结点  
119.             subTree=**null**;  
120.         \}  
121.     \}  
122.       
123.     **public** **void** traverse(TreeNode subTree)\{  
124.         System.out.println("key:"\+subTree.key+"--name:"\+subTree.data);;  
125.         traverse(subTree.leftChild);  
126.         traverse(subTree.rightChild);  
127.     \}  
128.       
129.     //前序遍历  
130.     **public** **void** preOrder(TreeNode subTree)\{  
131.         **if**(subTree!=**null**)\{  
132.             visted(subTree);  
133.             preOrder(subTree.leftChild);  
134.             preOrder(subTree.rightChild);  
135.         \}  
136.     \}  
137.       
138.     //中序遍历  
139.     **public** **void** inOrder(TreeNode subTree)\{  
140.         **if**(subTree!=**null**)\{  
141.             inOrder(subTree.leftChild);  
142.             visted(subTree);  
143.             inOrder(subTree.rightChild);  
144.         \}  
145.     \}  
146.       
147.     //后续遍历  
148.     **public** **void** postOrder(TreeNode subTree) \{  
149.         **if** (subTree != **null**) \{  
150.             postOrder(subTree.leftChild);  
151.             postOrder(subTree.rightChild);  
152.             visted(subTree);  
153.         \}  
154.     \}  
155.       
156.     //前序遍历的非递归实现  
157.     **public** **void** nonRecPreOrder(TreeNode p)\{  
158.         Stack<TreeNode> stack=**new** Stack<TreeNode>();  
159.         TreeNode node=p;  
160.         **while**(node!=**null**||stack.size()>0)\{  
161.             **while**(node!=**null**)\{  
162.                 visted(node);  
163.                 stack.push(node);  
164.                 node=node.leftChild;  
165.             \}  
166.            **if**(stack.size()>0)\{  
167.                 node=stack.pop();  
168.                 node=node.rightChild;  
169.             \}   
170.         \}  
171.     \}  
172.       
173.     //中序遍历的非递归实现  
174.     **public** **void** nonRecInOrder(TreeNode p)\{  
175.         Stack<TreeNode> stack =**new** Stack<BinaryTree.TreeNode>();  
176.         TreeNode node =p;  
177.         **while**(node!=**null**||stack.size()>0)\{  
178.             //存在左子树  
179.             **while**(node!=**null**)\{  
180.                 stack.push(node);  
181.                 node=node.leftChild;  
182.             \}  
183.             //栈非空  
184.             **if**(stack.size()>0)\{  
185.                 node=stack.pop();  
186.                 visted(node);  
187.                 node=node.rightChild;  
188.             \}  
189.         \}  
190.     \}  
191.       
192.     //后序遍历的非递归实现  
193.     **public** **void** noRecPostOrder(TreeNode p)\{  
194.         Stack<TreeNode> stack=**new** Stack<BinaryTree.TreeNode>();  
195.         TreeNode node =p;  
196.         **while**(p!=**null**)\{  
197.             //左子树入栈  
198.             **for**(;p.leftChild!=**null**;p=p.leftChild)\{  
199.                 stack.push(p);  
200.             \}  
201.             //当前结点无右子树或右子树已经输出  
202.             **while**(p!=**null**&&(p.rightChild==**null**||p.rightChild==node))\{  
203.                 visted(p);  
204.                 //纪录上一个已输出结点  
205.                 node =p;  
206.                 **if**(stack.empty())  
207.                     **return**;  
208.                 p=stack.pop();  
209.             \}  
210.             //处理右子树  
211.             stack.push(p);  
212.             p=p.rightChild;  
213.         \}  
214.     \}  
215.     **public** **void** visted(TreeNode subTree)\{  
216.         subTree.isVisted=**true**;  
217.         System.out.println("key:"\+subTree.key+"--name:"\+subTree.data);;  
218.     \}  
219.       
220.       
221.     /\*\* 
222.      \* 二叉树的节点数据结构 
223.      \* @author WWX 
224.      \*/  
225.     **private** **class**  TreeNode\{  
226.         **private** **int** key=0;  
227.         **private** String data=**null**;  
228.         **private** **boolean** isVisted=**false**;  
229.         **private** TreeNode leftChild=**null**;  
230.         **private** TreeNode rightChild=**null**;  
231.           
232.         **public** TreeNode()\{\}  
233.           
234.         /\*\* 
235.          \* @param key  层序编码 
236.          \* @param data 数据域 
237.          \*/  
238.         **public** TreeNode(**int** key,String data)\{  
239.             **this**.key=key;  
240.             **this**.data=data;  
241.             **this**.leftChild=**null**;  
242.             **this**.rightChild=**null**;  
243.         \}  
244.   
245.   
246.     \}  
247.       
248.       
249.     //测试  
250.     **public** **static** **void** main(String\[\] args) \{  
251.         BinaryTree bt = **new** BinaryTree();  
252.         bt.createBinTree(bt.root);  
253.         System.out.println("the size of the tree is " + bt.size());  
254.         System.out.println("the height of the tree is " + bt.height());  
255.           
256.         System.out.println("\*\*\*\*\*\*\*(前序遍历)\[ABDECF\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
257.         bt.preOrder(bt.root);  
258.           
259.         System.out.println("\*\*\*\*\*\*\*(中序遍历)\[DBEACF\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
260.         bt.inOrder(bt.root);  
261.          
262.         System.out.println("\*\*\*\*\*\*\*(后序遍历)\[DEBFCA\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
263.         bt.postOrder(bt.root);  
264.           
265.         System.out.println("\*\*\*非递归实现\*\*\*\*(前序遍历)\[ABDECF\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
266.         bt.nonRecPreOrder(bt.root);  
267.           
268.         System.out.println("\*\*\*非递归实现\*\*\*\*(中序遍历)\[DBEACF\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
269.         bt.nonRecInOrder(bt.root);  
270.           
271.         System.out.println("\*\*\*非递归实现\*\*\*\*(后序遍历)\[DEBFCA\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*");  
272.         bt.noRecPostOrder(bt.root);  
273.     \}  
274. \}

输出结果

the size of the tree is 6  
the height of the tree is 3  
\*\*\*\*\*\*\*(前序遍历)\[ABDECF\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
key:1--name:rootNode(A)  
key:2--name:B  
key:4--name:D  
key:5--name:E  
key:3--name:C  
key:6--name:F  
\*\*\*\*\*\*\*(中序遍历)\[DBEACF\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
key:4--name:D  
key:2--name:B  
key:5--name:E  
key:1--name:rootNode(A)  
key:3--name:C  
key:6--name:F  
\*\*\*\*\*\*\*(后序遍历)\[DEBFCA\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
key:4--name:D  
key:5--name:E  
key:2--name:B  
key:6--name:F  
key:3--name:C  
key:1--name:rootNode(A)  
\*\*\*非递归实现\*\*\*\*(前序遍历)\[ABDECF\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
key:1--name:rootNode(A)  
key:2--name:B  
key:4--name:D  
key:5--name:E  
key:3--name:C  
key:6--name:F  
\*\*\*非递归实现\*\*\*\*(中序遍历)\[DBEACF\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
key:4--name:D  
key:2--name:B  
key:5--name:E  
key:1--name:rootNode(A)  
key:3--name:C  
key:6--name:F  
\*\*\*非递归实现\*\*\*\*(后序遍历)\[DEBFCA\]遍历\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
key:4--name:D  
key:5--name:E  
key:2--name:B  
key:6--name:F  
key:3--name:C  
key:1--name:rootNode(A)

**如果有什么不清楚或者有啥疑问意见可以加我QQ/[微信][Link 3]  208017534  / qiang220316，欢迎一起交流一起进步。**

**![Center][]**

[Link 1]: http://my.csdn.net/wuwenxiang91322
[Link 2]: http://blog.csdn.net/wuwenxiang91322/article/details/12231657
[SouthEast]: /images/20220721/5e93a3489a1b4ab4918e440fe5070740.png
[SouthEast 1]: /images/20220721/91c5615d71aa42a5b64adae0314c0802.png
[Java]: http://lib.csdn.net/base/17
[view plain]: http://blog.csdn.net/wuwenxiang91322/article/details/12231657#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/90171
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/90171/fork
[Link 3]: http://lib.csdn.net/base/5
[Center]: /images/20220721/656eced89ace410fad0747314d6220c6.png