打印二叉树两个叶子节点间的路径

转载请注明出处：http://blog.csdn.net/luonanqin

       前两天在网上看到百度的一个校园招聘面试题：输出二叉树中两个叶子节点间的路径。感觉不是很难，所以花了点时间用Java实现了下。如果有更好的想法可以一起讨论。（另一个面试题是求二叉树中的最长路径，即相距最远的两个叶子节点，由于网上有实现所以我就不放出来了。）

[java]  view plain copy

1. public class TwoLeafPath {  
2.   
3.     // 临时存放要用的两个叶子节点  
4.     public static Node2 leaf = null;  
5.     // 表示已经找到叶子节点  
6.     public static boolean find = false;  
7.   
8.     // 实在没有好办法输出一个非平衡非完全二叉树，所以各位看官自己画画吧:P  
9.     public static Node2 generateTree() {  
10.         Node2 root = new Node2(1);  
11.         Node2 node2 = new Node2(2);  
12.         Node2 node3 = new Node2(3);  
13.         Node2 node4 = new Node2(4);  
14.         Node2 node5 = new Node2(5);  
15.         Node2 node6 = new Node2(6);  
16.         Node2 node7 = new Node2(7);  
17.         Node2 node8 = new Node2(8);  
18.         Node2 node9 = new Node2(9);  
19.         Node2 node10 = new Node2(10);  
20.         Node2 node11 = new Node2(11);  
21.         Node2 node12 = new Node2(12);  
22.   
23.         root.setParentNode(null);  
24.         root.setLeftNode(node2);  
25.         root.setRightNode(node3);  
26.   
27.         node2.setLeftNode(node4);  
28.         node2.setRightNode(node5);  
29.   
30.         node3.setLeftNode(node6);  
31.   
32.         node4.setLeftNode(node7);  
33.         node4.setRightNode(node8);  
34.   
35.         node5.setRightNode(node9);  
36.   
37.         node8.setLeftNode(node10);  
38.   
39.         node9.setLeftNode(node11);  
40.   
41.         node11.setRightNode(node12);  
42.   
43.         return root;  
44.     }  
45.   
46.     // 以后序遍历的方式最快找到叶子节点  
47.     public static void findNode(Node2 root, int data) {  
48.         // 如果找到叶子节点则停止遍历  
49.         if (!find) {  
50.             if (root.getLeftNode() != null) {  
51.                 root.getLeftNode().setParentNode(root);  
52.                 findNode(root.getLeftNode(), data);  
53.             }  
54.         }  
55.   
56.         // 如果找到叶子节点则停止遍历  
57.         if (!find) {  
58.             if (root.getRightNode() != null) {  
59.                 root.getRightNode().setParentNode(root);  
60.                 findNode(root.getRightNode(), data);  
61.             }  
62.         }  
63.   
64.         if (root.getData() == data) {  
65.             leaf = root;  
66.             find = true;  
67.             return;  
68.         } else {  
69.             return;  
70.         }  
71.     }  
72.   
73.     public static void printLeavesPath(Node2 leaf1, Node2 leaf2) {  
74.         int leaf1Data = leaf1.getData();  
75.         int leaf2Data = leaf2.getData();  
76.         Deque<Integer> leaf1Path = new LinkedList<Integer>();  
77.         Deque<Integer> leaf2Path = new LinkedList<Integer>();  
78.   
79.         while (true) {  
80.             leaf1Path.offerFirst(leaf1.getData());  
81.             leaf1 = leaf1.getParentNode();  
82.             if (leaf1 == null) {  
83.                 break;  
84.             }  
85.         }  
86.   
87.         System.out.println("Leaf "+leaf1Data+" Path: " + leaf1Path);  
88.   
89.         while (true) {  
90.             leaf2Path.offerFirst(leaf2.getData());  
91.             leaf2 = leaf2.getParentNode();  
92.             if (leaf2 == null) {  
93.                 break;  
94.             }  
95.         }  
96.   
97.         System.out.println("Leaf "+leaf2Data+" Path: " + leaf2Path);  
98.   
99.         int temp = 0;  
100.         // 比较两个叶子节点的路径。从根节点开始往下查找，若发现节点不同，则说明两条路径从此节点分叉。即可输出两叶子节点间的路径  
101.         while (leaf1Path.peekFirst() == leaf2Path.peekFirst()) {  
102.             temp = leaf1Path.pollFirst();  
103.             leaf2Path.pollFirst();  
104.         }  
105.   
106.         // 顺序输出  
107.         Iterator<Integer> leaf1Iter = leaf1Path.iterator();  
108.         // 逆序输出  
109.         Iterator<Integer> leaf2Iter = leaf2Path.descendingIterator();  
110.   
111.         StringBuffer result = new StringBuffer();  
112.         while (leaf2Iter.hasNext()) {  
113.             result.append(leaf2Iter.next() + ", ");  
114.         }  
115.   
116.         result.append(temp + ", ");  
117.   
118.         while (leaf1Iter.hasNext()) {  
119.             result.append(leaf1Iter.next() + ", ");  
120.         }  
121.   
122.         System.out.println("Leaf " + leaf1Data + " & Leaf " + leaf2Data + " Path: " + result.substring(0, result.length() - 2));  
123.     }  
124.   
125.     public static void main(String[] args) {  
126.         Node2 root = generateTree();  
127.   
128.         int data1 = 6;  
129.         int data2 = 12;  
130.   
131.         findNode(root, data1);  
132.         find = false;  
133.         Node2 leaf1 = leaf;  
134.   
135.         findNode(root, data2);  
136.         find = false;  
137.         Node2 leaf2 = leaf;  
138.   
139.         if (leaf1 == null) {  
140.             System.out.println("Can't find leaf with " + data1);  
141.         }  
142.         if (leaf2 == null) {  
143.             System.out.println("Can't find leaf with " + data2);  
144.         }  
145.   
146.         printLeavesPath(leaf1, leaf2);  
147.     }  
148. }  

关键代码如上，其余代码可自行脑补，或者参考我的github:  https://github.com/luonanqin/study/tree/master/Algorithm/src