原理很簡單，二叉樹內最大的路徑的起點和終點一定是葉子。據此可以遍歷所有的葉子進行暴力求解（好好的分治法能解決的問題被我弄成這樣）

二叉樹的節點定義如下：

package cn.edu.nju.zyf.longestPathWithinABinaryTree;

public class Node {
	private String data;
	public Node parent;
	public Node leftChild;
	public Node rightChild;
	
	public Node() {
		
	}
	public Node(String str) {
		this.data = str;
	}
	
	public String getData() {
		return data;
	}
	public void setData(String data) {
		this.data = data;
	}
}
 

package cn.edu.nju.zyf.longestPathWithinABinaryTree;

import java.util.ArrayList;
import java.util.List;

public class LongestPathWithinABinaryTreeUtil {
	private Node root;
	private List<Node> leaves = new ArrayList<Node>();
	private List<ArrayList<Node>> pathsFromLeafToRoot = new ArrayList<ArrayList<Node>>();
	private int longestPathBetween2Leaves = -1;
	
	public List<ArrayList<Node>> getPathsFromLeafToRoot() {
		return pathsFromLeafToRoot;
	}

	public void setPathsFromLeafToRoot(List<ArrayList<Node>> pathsFromLeafToRoot) {
		this.pathsFromLeafToRoot = pathsFromLeafToRoot;
	}

	public Node getRoot() {
		return root;
	}

	public void setRoot(Node root) {
		this.root = root;
	}

	public List<Node> getLeaves() {
		return leaves;
	}

	public void setLeaves(List<Node> leaves) {
		this.leaves = leaves;
	}

	public LongestPathWithinABinaryTreeUtil() {
		
	}
	
	public LongestPathWithinABinaryTreeUtil(Node rt) {
		this.root = rt;
		findLeaves(this.root);
		findPathsFromLeafToRoot();
		findMaxDistanceBetweenPaths();
	}
	
	
	public int findMaxDistanceBetweenPaths() {
		if(pathsFromLeafToRoot.size()>=2) {
			this.longestPathBetween2Leaves = distanceOfLeavesBetween2LeafRootPaths(pathsFromLeafToRoot.get(0), pathsFromLeafToRoot.get(1));
			for(int i = 0;i<this.pathsFromLeafToRoot.size();i++) {
				for(int j = i+1;j<this.pathsFromLeafToRoot.size();j++) {
					if(this.longestPathBetween2Leaves<distanceOfLeavesBetween2LeafRootPaths(pathsFromLeafToRoot.get(i), pathsFromLeafToRoot.get(j))) {
						this.longestPathBetween2Leaves=distanceOfLeavesBetween2LeafRootPaths(pathsFromLeafToRoot.get(i), pathsFromLeafToRoot.get(j));
					}
				}
			}
		}
		return this.longestPathBetween2Leaves;
	}
	
	public int distanceOfLeavesBetween2LeafRootPaths(List<Node> path1, List<Node> path2) {
		int sharedYoungestAncestorForPath1 = -1;
		int sharedYoungestAncestorForPath2 = -1;
		int i = path1.size()-1;
		int j = path2.size()-1;
		while(i>0&&j>0&&path1.get(i)==path2.get(j)) {
			sharedYoungestAncestorForPath1 = i;
			sharedYoungestAncestorForPath2 = j;
			i--;
			j--;
		}
		return sharedYoungestAncestorForPath1+sharedYoungestAncestorForPath2;
	}
	
	public int getLongestPathBetween2Leaves() {
		return longestPathBetween2Leaves;
	}

	public void setLongestPathBetween2Leaves(int longestPathBetween2Leaves) {
		this.longestPathBetween2Leaves = longestPathBetween2Leaves;
	}

	public void findLeaves(Node root) {
		if(root!=null&&root.leftChild==null&&root.rightChild==null) {
			leaves.add(root);
			return;
		}
		if(root!=null&&root.leftChild!=null) {
			findLeaves(root.leftChild);
		}
		if(root!=null&&root.rightChild!=null) {
			findLeaves(root.rightChild);
		}
	}
	
	public void findPathsFromLeafToRoot() {
		ArrayList<ArrayList<Node>> paths = new ArrayList<ArrayList<Node>>();
		for(int i = 0;i<leaves.size();i++) {
			ArrayList<Node> path = new ArrayList<Node>();
			for(Node j = leaves.get(i);j!=null;j = j.parent) {
				path.add(j);
			}
			paths.add(path);
		}
		this.pathsFromLeafToRoot = paths;
		
	}
}
 

package cn.edu.nju.zyf.longestPathWithinABinaryTree;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Node root = new Node("zyf");
		Node son = new Node("l11");
		Node daughter = new Node("l12");
		Node grandSon = new Node("l21");
		Node grandDaughter = new Node("l22");
		root.leftChild = son;
		son.parent = root;
		root.rightChild = daughter;
		daughter.parent=root;
		son.leftChild = grandSon;
		grandSon.parent = son;
		daughter.rightChild = grandDaughter;
		grandDaughter.parent = daughter;
		
		Node asdf = new Node("asdf");
		grandDaughter.leftChild = asdf;
		asdf.parent = grandDaughter;
		
		LongestPathWithinABinaryTreeUtil util = new LongestPathWithinABinaryTreeUtil(root);
		System.out.println(util.getLeaves().size());
		System.out.println(util.getLeaves().get(0).getData());
		System.out.println(util.getPathsFromLeafToRoot().size());
		System.out.println(util.getPathsFromLeafToRoot().get(0).get(0).getData());
		System.out.println(util.getPathsFromLeafToRoot().get(0).get(1).getData());
		System.out.println(util.getPathsFromLeafToRoot().get(0).get(2).getData());
		System.out.println(util.distanceOfLeavesBetween2LeafRootPaths(util.getPathsFromLeafToRoot().get(0), util.getPathsFromLeafToRoot().get(1)));
		System.out.println(util.getLongestPathBetween2Leaves());
	}

}
 

2
l21
2
l21
l11
zyf
5
5