Java实现二叉搜索树的最近祖先节点

标题：Java实现二叉搜索树的最近祖先节点

一、题解
1） 方法一：得到两个list
执行用时：8 ms, 在所有 Java 提交中击败了14.00% 的用户
内存消耗：39.3 MB, 在所有 Java 提交中击败了92.33% 的用户

/*
	方法一：得到两个list
	执行用时：8 ms, 在所有 Java 提交中击败了14.00% 的用户
	内存消耗：39.3 MB, 在所有 Java 提交中击败了92.33% 的用户
	*/
	public TreeNode commonBstNode(TreeNode head, TreeNode p1, TreeNode p2){
		List<TreeNode> list1 = this.getFaNodeToList(head, p1);
		List<TreeNode> list2 = this.getFaNodeToList(head, p2);

		TreeNode node = null;
		for(int i = 0; i < list1.size() && i < list2.size(); i++){
			if(list1.get(i) == list2.get(i)){
				node = list1.get(i);
			}else{
				break;
			}
		}	
		
		return node;
	}


	/*得到list，父节点集合*/
	public List<TreeNode> getFaNodeToList(TreeNode head, TreeNode p){
		List<TreeNode> list = new ArrayList<>();
		if(head == null || p == null){
			return list;
		}
		TreeNode node = head;
		while(node.val != p.val){  //利用bst的搜索快
			list.add(node);
			if(node.val > p.val){  //细心
				node = node.left;
			}else{
				node = node.right;
			}
		}
		list.add(node);//自己也可能是父节点
		
		return list;
	}

2） 方法二，使用递归
执行用时：6 ms, 在所有 Java 提交中击败了99.93% 的用户
内存消耗：39.1 MB, 在所有 Java 提交中击败了98.17% 的用户

/*
	方法二，使用递归
	执行用时：6 ms, 在所有 Java 提交中击败了99.93% 的用户
	内存消耗：39.1 MB, 在所有 Java 提交中击败了98.17% 的用户
	*/
	public TreeNode commonBstNode02(TreeNode head, TreeNode p1, TreeNode p2){
		if(p1.val > p2.val){
			return this.commonBstNode(head, p2, p1);
		}
		if(head == null || head.val == p1.val || head.val == p2.val || (p1.val < head.val && p2.val > head.val)){
			return head;
		}
		if(p2.val < head.val){
			return this.commonBstNode02(head.left, p1, p2);
		}
		if(p1.val > head.val){
			return this.commonBstNode02(head.right, p1, p2);
		}
		return head;
		
	}
	/*递归，同上
	执行用时：7 ms, 在所有 Java 提交中击败了38.50% 的用户
	内存消耗：38.7 MB, 在所有 Java 提交中击败了99.91% 的用户
	*/
	public TreeNode commonBstNode03(TreeNode head, TreeNode p1, TreeNode p2){
		if(head == null || p1 == null || p2 == null){
			return head;
		}
		if(p1.val < head.val && p2.val < head.val){
			return this.commonBstNode03(head.left, p1, p2);
		}
		if(p1.val > head.val && p2.val > head.val){
			return this.commonBstNode03(head.right, p1, p2);
		}
		return head;
		
	}

补充
3） 递归 对应的 迭代
执行用时：7 ms, 在所有 Java 提交中击败了38.50% 的用户
内存消耗：39 MB, 在所有 Java 提交中击败了99.00% 的用户

/*
	递归 对应的 迭代
	执行用时：7 ms, 在所有 Java 提交中击败了38.50% 的用户
	内存消耗：39 MB, 在所有 Java 提交中击败了99.00% 的用户
	*/
	public TreeNode commonBstNode04(TreeNode head, TreeNode p1, TreeNode p2){
		if(head == null || p1 == null || p2 == null){
			return head;
		}
		TreeNode node = head;
		while(node != null){
			if(p1.val < node.val && p2.val < node.val){
				node = node.left;
			}else if(p1.val > node.val && p2.val > node.val){
				node = node.right;
			}else{
				break;
			}
		}
		
		return node;
	}

完整示例代码：

public class TestCommonBstNode02 {
	//1124
	/*
	方法一：得到两个list
	执行用时：8 ms, 在所有 Java 提交中击败了14.00% 的用户
	内存消耗：39.3 MB, 在所有 Java 提交中击败了92.33% 的用户
	*/
	public TreeNode commonBstNode(TreeNode head, TreeNode p1, TreeNode p2){
		List<TreeNode> list1 = this.getFaNodeToList(head, p1);
		List<TreeNode> list2 = this.getFaNodeToList(head, p2);

		TreeNode node = null;
		for(int i = 0; i < list1.size() && i < list2.size(); i++){
			if(list1.get(i) == list2.get(i)){
				node = list1.get(i);
			}else{
				break;
			}
		}	
		
		return node;
	}


	/*得到list，父节点集合*/
	public List<TreeNode> getFaNodeToList(TreeNode head, TreeNode p){
		List<TreeNode> list = new ArrayList<>();
		if(head == null || p == null){
			return list;
		}
		TreeNode node = head;
		while(node.val != p.val){  //利用bst的搜索快
			list.add(node);
			if(node.val > p.val){  //细心
				node = node.left;
			}else{
				node = node.right;
			}
		}
		list.add(node);//自己也可能是父节点
		
		return list;
	}
	/*
	方法二，使用递归
	执行用时：6 ms, 在所有 Java 提交中击败了99.93% 的用户
	内存消耗：39.1 MB, 在所有 Java 提交中击败了98.17% 的用户
	*/
	public TreeNode commonBstNode02(TreeNode head, TreeNode p1, TreeNode p2){
		if(p1.val > p2.val){
			return this.commonBstNode(head, p2, p1);
		}
		if(head == null || head.val == p1.val || head.val == p2.val || (p1.val < head.val && p2.val > head.val)){
			return head;
		}
		if(p2.val < head.val){
			return this.commonBstNode02(head.left, p1, p2);
		}
		if(p1.val > head.val){
			return this.commonBstNode02(head.right, p1, p2);
		}
		return head;
		
	}
	/*递归，同上
	执行用时：7 ms, 在所有 Java 提交中击败了38.50% 的用户
	内存消耗：38.7 MB, 在所有 Java 提交中击败了99.91% 的用户
	*/
	public TreeNode commonBstNode03(TreeNode head, TreeNode p1, TreeNode p2){
		if(head == null || p1 == null || p2 == null){
			return head;
		}
		if(p1.val < head.val && p2.val < head.val){
			return this.commonBstNode03(head.left, p1, p2);
		}
		if(p1.val > head.val && p2.val > head.val){
			return this.commonBstNode03(head.right, p1, p2);
		}
		return head;
		
	}

	/*
	递归 对应的 迭代
	执行用时：7 ms, 在所有 Java 提交中击败了38.50% 的用户
	内存消耗：39 MB, 在所有 Java 提交中击败了99.00% 的用户
	*/
	public TreeNode commonBstNode04(TreeNode head, TreeNode p1, TreeNode p2){
		if(head == null || p1 == null || p2 == null){
			return head;
		}
		TreeNode node = head;
		while(node != null){
			if(p1.val < node.val && p2.val < node.val){
				node = node.left;
			}else if(p1.val > node.val && p2.val > node.val){
				node = node.right;
			}else{
				break;
			}
		}
		
		return node;
	}
}