samir_liu

面试中的二叉树问题总结【Java版】

2014-10-16 13:42 3718人阅读评论(0) 收藏举报

本文章已收录于：

分类：

数据结构（6）

作者同类文章 X

•二叉树的常见问题及其解决程序
•hash_set哈希集合容器
•list和vector有什么区别？
•经典面试题:设计包含min函数的栈,O(1)空间实现方法
更多

算法（18）

作者同类文章 X

[java] view plain copy

print ?

package Algorithms.tree;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
/**
* REFS:
* http://blog.csdn.net/fightforyourdream/article/details/16843303 面试大总结之二：Java搞定面试中的二叉树题目
* http://blog.csdn.net/luckyxiaoqiang/article/details/7518888 轻松搞定面试中的二叉树题目
* http://www.cnblogs.com/Jax/archive/2009/12/28/1633691.html 算法大全（3）二叉树
*
* 1. 求二叉树中的节点个数: getNodeNumRec（递归），getNodeNum（迭代）
* 2. 求二叉树的深度: getDepthRec（递归），getDepth
* 3. 前序遍历，中序遍历，后序遍历: preorderTraversalRec, preorderTraversal, inorderTraversalRec, postorderTraversalRec
* (https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_2)
* 4.分层遍历二叉树（按层次从上往下，从左往右）: levelTraversal, levelTraversalRec（递归解法）
* 5. 将二叉查找树变为有序的双向链表: convertBST2DLLRec, convertBST2DLL
* 6. 求二叉树第K层的节点个数：getNodeNumKthLevelRec, getNodeNumKthLevel
* 7. 求二叉树中叶子节点的个数：getNodeNumLeafRec, getNodeNumLeaf
* 8. 判断两棵二叉树是否相同的树：isSameRec, isSame
* 9. 判断二叉树是不是平衡二叉树：isAVLRec
* 10. 求二叉树的镜像（破坏和不破坏原来的树两种情况）：
* mirrorRec, mirrorCopyRec
* mirror, mirrorCopy
* 10.1 判断两个树是否互相镜像：isMirrorRec isMirror
* 11. 求二叉树中两个节点的最低公共祖先节点：
* LAC 求解最小公共祖先, 使用list来存储path.
* LCABstRec 递归求解BST树.
* LCARec 递归算法 .
* 12. 求二叉树中节点的最大距离：getMaxDistanceRec
* 13. 由前序遍历序列和中序遍历序列重建二叉树：rebuildBinaryTreeRec
* 14. 判断二叉树是不是完全二叉树：isCompleteBinaryTree, isCompleteBinaryTreeRec
* 15. 找出二叉树中最长连续子串(即全部往左的连续节点，或是全部往右的连续节点）findLongest
*/
public class TreeDemo {
/*
1
/ \
2 3
/ \ \
4 5 6
*/
public static void main(String[] args) {
TreeNode r1 = new TreeNode(1);
TreeNode r2 = new TreeNode(2);
TreeNode r3 = new TreeNode(3);
TreeNode r4 = new TreeNode(4);
TreeNode r5 = new TreeNode(5);
TreeNode r6 = new TreeNode(6);
/*
10
/ \
6 14
/ \ \
4 8 16
/
0
*/
/*
1
/ \
2 3
/ \ \
4 5 6
*/
// TreeNode r1 = new TreeNode(10);
// TreeNode r2 = new TreeNode(6);
// TreeNode r3 = new TreeNode(14);
// TreeNode r4 = new TreeNode(4);
// TreeNode r5 = new TreeNode(8);
// TreeNode r6 = new TreeNode(16);
TreeNode r7 = new TreeNode(0);
r1.left = r2;
r1.right = r3;
r2.left = r4;
r2.right = r5;
r3.right = r6;
r4.left = r7;
TreeNode t1 = new TreeNode(10);
TreeNode t2 = new TreeNode(6);
TreeNode t3 = new TreeNode(14);
TreeNode t4 = new TreeNode(4);
TreeNode t5 = new TreeNode(8);
TreeNode t6 = new TreeNode(16);
TreeNode t7 = new TreeNode(0);
TreeNode t8 = new TreeNode(0);
TreeNode t9 = new TreeNode(0);
TreeNode t10 = new TreeNode(0);
TreeNode t11 = new TreeNode(0);
t1.left = t2;
t1.right = t3;
t2.left = t4;
t2.right = t5;
t3.left = t6;
t3.right = t7;
t4.left = t8;
//t4.right = t9;
t5.right = t9;
// test distance
// t5.right = t8;
// t8.right = t9;
// t9.right = t10;
// t10.right = t11;
/*
10
/ \
6 14
/ \ \
4 8 16
/
0
*/
// System.out.println(LCABstRec(t1, t2, t4).val);
// System.out.println(LCABstRec(t1, t2, t6).val);
// System.out.println(LCABstRec(t1, t4, t6).val);
// System.out.println(LCABstRec(t1, t4, t7).val);
// System.out.println(LCABstRec(t1, t3, t6).val);
//
// System.out.println(LCA(t1, t2, t4).val);
// System.out.println(LCA(t1, t2, t6).val);
// System.out.println(LCA(t1, t4, t6).val);
// System.out.println(LCA(t1, t4, t7).val);
// System.out.println(LCA(t1, t3, t6).val);
// System.out.println(LCA(t1, t6, t6).val);
//System.out.println(getMaxDistanceRec(t1));
//System.out.println(isSame(r1, t1));
// System.out.println(isAVLRec(r1));
//
// preorderTraversalRec(r1);
// //mirrorRec(r1);
// //TreeNode r1Mirror = mirror(r1);
//
// TreeNode r1MirrorCopy = mirrorCopy(r1);
// System.out.println();
// //preorderTraversalRec(r1Mirror);
// preorderTraversalRec(r1MirrorCopy);
//
// System.out.println();
//
// System.out.println(isMirrorRec(r1, r1MirrorCopy));
// System.out.println(isMirror(r1, r1MirrorCopy));
//System.out.println(getNodeNumKthLevelRec(r1, 5));
//System.out.println(getNodeNumLeaf(r1));
// System.out.println(getNodeNumRec(null));
// System.out.println(getNodeNum(r1));
//System.out.println(getDepthRec(null));
// System.out.println(getDepth(r1));
//
// preorderTraversalRec(r1);
// System.out.println();
// preorderTraversal(r1);
// System.out.println();
// inorderTraversalRec(r1);
//
// System.out.println();
// inorderTraversal(r1);
// postorderTraversalRec(r1);
// System.out.println();
// postorderTraversal(r1);
// System.out.println();
// levelTraversal(r1);
//
// System.out.println();
// levelTraversalRec(r1);
// TreeNode ret = convertBST2DLLRec(r1);
// while (ret != null) {
// System.out.print(ret.val + " ");
// ret = ret.right;
// }
// TreeNode ret2 = convertBST2DLL(r1);
// while (ret2.right != null) {
// ret2 = ret2.right;
// }
//
// while (ret2 != null) {
// System.out.print(ret2.val + " ");
// ret2 = ret2.left;
// }
//
// TreeNode ret = convertBST2DLL(r1);
// while (ret != null) {
// System.out.print(ret.val + " ");
// ret = ret.right;
// }
// System.out.println();
// System.out.println(findLongest(r1));
// System.out.println();
// System.out.println(findLongest2(r1));
// test the rebuildBinaryTreeRec.
//test_rebuildBinaryTreeRec();
System.out.println(isCompleteBinaryTreeRec(t1));
System.out.println(isCompleteBinaryTree(t1));
}
public static void test_rebuildBinaryTreeRec() {
ArrayList list1 = new ArrayList();
list1.add(1);
list1.add(2);
list1.add(4);
list1.add(5);
list1.add(3);
list1.add(6);
list1.add(7);
list1.add(8);
ArrayList list2 = new ArrayList();
list2.add(4);
list2.add(2);
list2.add(5);
list2.add(1);
list2.add(3);
list2.add(7);
list2.add(6);
list2.add(8);
TreeNode root = rebuildBinaryTreeRec(list1, list2);
preorderTraversalRec(root);
System.out.println();
postorderTraversalRec(root);
}
private static class TreeNode{
int val;
TreeNode left;
TreeNode right;
public TreeNode(int val){
this.val = val;
left = null;
right = null;
}
}
/*
* null返回0，然后把左右子树的size加上即可。
* */
public static int getNodeNumRec(TreeNode root) {
if (root == null) {
return 0;
}
return getNodeNumRec(root.left) + getNodeNumRec(root.right) + 1;
}
/**
* 求二叉树中的节点个数迭代解法O(n)：基本思想同LevelOrderTraversal，
* 即用一个Queue，在Java里面可以用LinkedList来模拟
*/
public static int getNodeNum(TreeNode root) {
if (root == null) {
return 0;
}
Queue q = new LinkedList();
q.offer(root);
int cnt = 0;
while (!q.isEmpty()) {
TreeNode node = q.poll();
if (node.left != null) {
q.offer(node.left);
}
if (node.right != null) {
q.offer(node.right);
}
cnt++;
}
return cnt;
}
public static int getDepthRec(TreeNode root) {
if (root == null) {
return -1;
}
return Math.max(getDepthRec(root.left), getDepthRec(root.right)) + 1;
}
/*
* 可以用 level LevelOrderTraversal 来实现，我们用一个dummyNode来分隔不同的层，这样即可计算出实际的depth.
* 1
/ \
2 3
/ \ \
4 5 6
*
* 在队列中如此排列： 1, dummy, 2, 3, dummy, 4, 5, 5, dummy
*
*/
public static int getDepth(TreeNode root) {
if (root == null) {
return 0;
}
TreeNode dummy = new TreeNode(0);
Queue q = new LinkedList();
q.offer(root);
q.offer(dummy);
int depth = -1;
while (!q.isEmpty()) {
TreeNode curr = q.poll();
if (curr == dummy) {
depth++;
if (!q.isEmpty()) { // 使用DummyNode来区分不同的层，如果下一层不是为空，则应该在尾部加DummyNode.
q.offer(dummy);
}
}
if (curr.left != null) {
q.offer(curr.left);
}
if (curr.right != null) {
q.offer(curr.right);
}
}
return depth;
}
/*
* 3. 前序遍历，中序遍历，后序遍历: preorderTraversalRec, preorderTraversal, inorderTraversalRec, postorderTraversalRec
* (https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_2)
* */
public static void preorderTraversalRec(TreeNode root) {
if (root == null) {
return;
}
System.out.print(root.val + " ");
preorderTraversalRec(root.left);
preorderTraversalRec(root.right);
}
/*
* 前序遍历，Iteration 算法. 把根节点存在stack中。
* */
public static void preorderTraversal(TreeNode root) {
if (root == null) {
return;
}
Stack s = new Stack();
s.push(root);
while (!s.isEmpty()) {
TreeNode node = s.pop();
System.out.print(node.val + " ");
if (node.right != null) { //
s.push(node.right);
}
// 我们需要先压入右节点，再压入左节点，这样就可以先弹出左节点。
if (node.left != null) {
s.push(node.left);
}
}
}
/*
* 中序遍历
* */
public static void inorderTraversalRec(TreeNode root) {
if (root == null) {
return;
}
inorderTraversalRec(root.left);
System.out.print(root.val + " ");
inorderTraversalRec(root.right);
}
/**
* 中序遍历迭代解法，用栈先把根节点的所有左孩子都添加到栈内，
* 然后输出栈顶元素，再处理栈顶元素的右子树
* http://www.youtube.com/watch?v=50v1sJkjxoc
*
* 还有一种方法能不用递归和栈，基于线索二叉树的方法，较麻烦以后补上
* http://www.geeksforgeeks.org/inorder-tree-traversal-without-recursion-and-without-stack/
*/
public static void inorderTraversal(TreeNode root) {
if (root == null) {
return;
}
Stack s = new Stack();
TreeNode cur = root;
while(true) {
// 把当前节点的左节点都push到栈中.
while (cur != null) {
s.push(cur);
cur = cur.left;
}
if (s.isEmpty()) {
break;
}
// 因为此时已经没有左孩子了，所以输出栈顶元素
cur = s.pop();
System.out.print(cur.val + " ");
// 准备处理右子树
cur = cur.right;
}
}
// 后序遍历
/*
* 1
/ \
2 3
/ \ \
4 5 6
if put into the stack directly, then it should be:
1, 2, 4, 5, 3, 6 in the stack.
when pop, it should be: 6, 3, 5, 4, 2, 1
if I
* */
public static void postorderTraversalRec(TreeNode root) {
if (root == null) {
return;
}
postorderTraversalRec(root.left);
postorderTraversalRec(root.right);
System.out.print(root.val + " ");
}
/**
* 后序遍历迭代解法
* http://www.youtube.com/watch?v=hv-mJUs5mvU
* http://blog.csdn.net/tang_jin2015/article/details/8545457
* 从左到右的后序与从右到左的前序的逆序是一样的，所以就简单喽！哈哈
* 用另外一个栈进行翻转即可喽
*/
public static void postorderTraversal(TreeNode root) {
if (root == null) {
return;
}
Stack s = new Stack();
Stack out = new Stack();
s.push(root);
while(!s.isEmpty()) {
TreeNode cur = s.pop();
out.push(cur);
if (cur.left != null) {
s.push(cur.left);
}
if (cur.right != null) {
s.push(cur.right);
}
}
while(!out.isEmpty()) {
System.out.print(out.pop().val + " ");
}
}
/*
* 分层遍历二叉树（按层次从上往下，从左往右）迭代
* 其实就是广度优先搜索，使用队列实现。队列初始化，将根节点压入队列。当队列不为空，进行如下操作：弹出一个节点
* ，访问，若左子节点或右子节点不为空，将其压入队列
* */
public static void levelTraversal(TreeNode root) {
if (root == null) {
return;
}
Queue q = new LinkedList();
q.offer(root);
while (!q.isEmpty()) {
TreeNode cur = q.poll();
System.out.print(cur.val + " ");
if (cur.left != null) {
q.offer(cur.left);
}
if (cur.right != null) {
q.offer(cur.right);
}
}
}
public static void levelTraversalRec(TreeNode root) {
ArrayList> ret = new ArrayList>();
levelTraversalVisit(root, 0, ret);
System.out.println(ret);
}
/**
* 分层遍历二叉树（递归）
* 很少有人会用递归去做level traversal
* 基本思想是用一个大的ArrayList，里面包含了每一层的ArrayList。
* 大的ArrayList的size和level有关系
*
* http://discuss.leetcode.com/questions/49/binary-tree-level-order-traversal#answer-container-2543
*/
public static void levelTraversalVisit(TreeNode root, int level, ArrayList> ret) {
if (root == null) {
return;
}
// 如果ArrayList的层数不够用，则新添加一层
// when size = 3, level: 0, 1, 2
if (level >= ret.size()) {
ret.add(new ArrayList());
}
// visit 当前节点
ret.get(level).add(root.val);
// 将左子树，右子树添加到对应的层。
levelTraversalVisit(root.left, level + 1, ret);
levelTraversalVisit(root.right, level + 1, ret);
}
/*
* 题目要求：将二叉查找树转换成排序的双向链表，不能创建新节点，只调整指针。
查找树的结点定义如下：
既然是树，其定义本身就是递归的，自然用递归算法处理就很容易。将根结点的左子树和右子树转换为有序的双向链表，
然后根节点的left指针指向左子树结果的最后一个结点，同时左子树最后一个结点的right指针指向根节点；
根节点的right指针指向右子树结果的第一个结点，
同时右子树第一个结点的left指针指向根节点。
* */
public static TreeNode convertBST2DLLRec(TreeNode root) {
return convertBST2DLLRecHelp(root)[0];
}
/*
* ret[0] 代表左指针
* ret[1] 代表右指针
* */
public static TreeNode[] convertBST2DLLRecHelp(TreeNode root) {
TreeNode[] ret = new TreeNode[2];
ret[0] = null;
ret[1] = null;
if (root == null) {
return ret;
}
if (root.left != null) {
TreeNode left[] = convertBST2DLLRecHelp(root.left);
left[1].right = root; // 将左子树的尾节点连接到根
root.left = left[1];
ret[0] = left[0];
} else {
ret[0] = root; // 左节点返回root.
}
if (root.right != null) {
TreeNode right[] = convertBST2DLLRecHelp(root.right);
right[0].left = root; // 将右子树的头节点连接到根
root.right = right[0];
ret[1] = right[1];
} else {
ret[1] = root; // 右节点返回root.
}
return ret;
}
/**
* 将二叉查找树变为有序的双向链表迭代解法
* 类似inOrder traversal的做法
*/
public static TreeNode convertBST2DLL(TreeNode root) {
while (root == null) {
return null;
}
TreeNode pre = null;
Stack s = new Stack();
TreeNode cur = root;
TreeNode head = null; // 链表头
while (true) {
while (cur != null) {
s.push(cur);
cur = cur.left;
}
// if stack is empty, just break;
if (s.isEmpty()) {
break;
}
cur = s.pop();
if (head == null) {
head = cur;
}
// link pre and cur.
cur.left = pre;
if (pre != null) {
pre.right = cur;
}
// 左节点已经处理完了，处理右节点
cur = cur.right;
pre = cur;
}
return root;
}
/*
* * 6. 求二叉树第K层的节点个数：getNodeNumKthLevelRec, getNodeNumKthLevel
* */
public static int getNodeNumKthLevel(TreeNode root, int k) {
if (root == null || k <= 0) {
return 0;
}
int level = 0;
Queue q = new LinkedList();
q.offer(root);
TreeNode dummy = new TreeNode(0);
int cnt = 0; // record the size of the level.
q.offer(dummy);
while (!q.isEmpty()) {
TreeNode node = q.poll();
if (node == dummy) {
level++;
if (level == k) {
return cnt;
}
cnt = 0; // reset the cnt;
if (q.isEmpty()) {
break;
}
q.offer(dummy);
continue;
}
cnt++;
if (node.left != null) {
q.offer(node.left);
}
if (node.right != null) {
q.offer(node.right);
}
}
return 0;
}
/*
* * 6. 求二叉树第K层的节点个数：getNodeNumKthLevelRec, getNodeNumKthLevel
* */
public static int getNodeNumKthLevelRec(TreeNode root, int k) {
if (root == null || k <= 0) {
return 0;
}
if (k == 1) {
return 1;
}
// 将左子树及右子树在K层的节点个数相加.
return getNodeNumKthLevelRec(root.left, k - 1) + getNodeNumKthLevelRec(root.right, k - 1);
}
/*
* 7. getNodeNumLeafRec 把左子树和右子树的叶子节点加在一起即可
* */
public static int getNodeNumLeafRec(TreeNode root) {
if (root == null) {
return 0;
}
if (root.left == null && root.right == null) {
return 1;
}
return getNodeNumLeafRec(root.left) + getNodeNumLeafRec(root.right);
}
/* 7. getNodeNumLeaf
* 随便使用一种遍历方法都可以，比如，中序遍历。
* inorderTraversal，判断是不是叶子节点。
* */
public static int getNodeNumLeaf(TreeNode root) {
if (root == null) {
return 0;
}
int cnt = 0;
// we can use inorderTraversal travesal to do it.
Stack s = new Stack();
TreeNode cur = root;
while (true) {
while (cur != null) {
s.push(cur);
cur = cur.left;
}
if (s.isEmpty()) {
break;
}
// all the left child has been put into the stack, let's deal with the
// current node.
cur = s.pop();
if (cur.left == null && cur.right == null) {
cnt++;
}
cur = cur.right;
}
return cnt;
}
/*
* 8. 判断两棵二叉树是否相同的树。
* 递归解法：
* （1）如果两棵二叉树都为空，返回真
* （2）如果两棵二叉树一棵为空，另一棵不为空，返回假
* （3）如果两棵二叉树都不为空，如果对应的左子树和右子树都同构返回真，其他返回假
* */
public static boolean isSameRec(TreeNode r1, TreeNode r2) {
// both are null.
if (r1 == null && r2 == null) {
return true;
}
// one is null.
if (r1 == null || r2 == null) {
return false;
}
// 1. the value of the root should be the same;
// 2. the left tree should be the same.
// 3. the right tree should be the same.
return r1.val == r2.val &&
isSameRec(r1.left, r2.left) && isSameRec(r1.right, r2.right);
}
/*
* 8. 判断两棵二叉树是否相同的树。
* 迭代解法
* 我们直接用中序遍历来比较就好啦
* */
public static boolean isSame(TreeNode r1, TreeNode r2) {
// both are null.
if (r1 == null && r2 == null) {
return true;
}
// one is null.
if (r1 == null || r2 == null) {
return false;
}
Stack s1 = new Stack();
Stack s2 = new Stack();
TreeNode cur1 = r1;
TreeNode cur2 = r2;
while (true) {
while (cur1 != null && cur2 != null) {
s1.push(cur1);
s2.push(cur2);
cur1 = cur1.left;
cur2 = cur2.left;
}
if (cur1 != null || cur2 != null) {
return false;
}
if (s1.isEmpty() && s2.isEmpty()) {
break;
}
cur1 = s1.pop();
cur2 = s2.pop();
if (cur1.val != cur2.val) {
return false;
}
cur1 = cur1.right;
cur2 = cur2.right;
}
return true;
}
/*
*
* 9. 判断二叉树是不是平衡二叉树：isAVLRec
* 1. 左子树，右子树的高度差不能超过1
* 2. 左子树，右子树都是平衡二叉树。
*
*/
public static boolean isAVLRec(TreeNode root) {
if (root == null) {
return true;
}
// 左子树，右子树都必须是平衡二叉树。
if (!isAVLRec(root.left) || !isAVLRec(root.right)) {
return false;
}
int dif = Math.abs(getDepthRec(root.left) - getDepthRec(root.right));
if (dif > 1) {
return false;
}
return true;
}
/**
* 10. 求二叉树的镜像递归解法：
*
* (1) 破坏原来的树
*
* 1 1
* / \
* 2 -----> 2
* \ /
* 3 3
* */
public static TreeNode mirrorRec(TreeNode root) {
if (root == null) {
return null;
}
// 先把左右子树分别镜像,并且交换它们
TreeNode tmp = root.right;
root.right = mirrorRec(root.left);
root.left = mirrorRec(tmp);
return root;
}
/**
* 10. 求二叉树的镜像 Iterator解法：
*
* (1) 破坏原来的树
*
* 1 1
* / \
* 2 -----> 2
* \ /
* 3 3
*
* 应该可以使用任何一种Traversal 方法。
* 我们现在可以试看看使用最简单的前序遍历。
* */
public static TreeNode mirror(TreeNode root) {
if (root == null) {
return null;
}
Stack s = new Stack();
s.push(root);
while (!s.isEmpty()) {
TreeNode cur = s.pop();
// 交换当前节点的左右节点
TreeNode tmp = cur.left;
cur.left = cur.right;
cur.right = tmp;
// traversal 左节点，右节点。
if (cur.right != null) {
s.push(cur.right);
}
if (cur.left != null) {
s.push(cur.left);
}
}
return root;
}
/**
* 10. 求二叉树的镜像 Iterator解法：
*
* (2) 创建一个新的树
*
* 1 1
* / \
* 2 -----> 2
* \ /
* 3 3
*
* 应该可以使用任何一种Traversal 方法。
* 我们现在可以试看看使用最简单的前序遍历。
* 前序遍历我们可以立刻把新建好的左右节点创建出来，比较方便
* */
public static TreeNode mirrorCopy(TreeNode root) {
if (root == null) {
return null;
}
Stack s = new Stack();
Stack sCopy = new Stack();
s.push(root);
TreeNode rootCopy = new TreeNode(root.val);
sCopy.push(rootCopy);
while (!s.isEmpty()) {
TreeNode cur = s.pop();
TreeNode curCopy = sCopy.pop();
// traversal 左节点，右节点。
if (cur.right != null) {
// copy 在这里做比较好，因为我们可以容易地找到它的父节点
TreeNode leftCopy = new TreeNode(cur.right.val);
curCopy.left = leftCopy;
s.push(cur.right);
sCopy.push(curCopy.left);
}
if (cur.left != null) {
// copy 在这里做比较好，因为我们可以容易地找到它的父节点
TreeNode rightCopy = new TreeNode(cur.left.val);
curCopy.right = rightCopy;
s.push(cur.left);
sCopy.push(curCopy.right);
}
}
return rootCopy;
}
/**
* 10. 求二叉树的镜像递归解法：
*
* (1) 不破坏原来的树，新建一个树
*
* 1 1
* / \
* 2 -----> 2
* \ /
* 3 3
* */
public static TreeNode mirrorCopyRec(TreeNode root) {
if (root == null) {
return null;
}
// 先把左右子树分别镜像,并且把它们连接到新建的root节点。
TreeNode rootCopy = new TreeNode(root.val);
rootCopy.left = mirrorCopyRec(root.right);
rootCopy.right = mirrorCopyRec(root.left);
return rootCopy;
}
/*
* 10.1. 判断两个树是否互相镜像
* (1) 根必须同时为空，或是同时不为空
*
* 如果根不为空:
* (1).根的值一样
* (2).r1的左树是r2的右树的镜像
* (3).r1的右树是r2的左树的镜像
* */
public static boolean isMirrorRec(TreeNode r1, TreeNode r2){
// 如果2个树都是空树
if (r1 == null && r2 == null) {
return true;
}
// 如果其中一个为空，则返回false.
if (r1 == null || r2 == null) {
return false;
}
// If both are not null, they should be:
// 1. have same value for root.
// 2. R1's left tree is the mirror of R2's right tree;
// 3. R2's right tree is the mirror of R1's left tree;
return r1.val == r2.val
&& isMirrorRec(r1.left, r2.right)
&& isMirrorRec(r1.right, r2.left);
}
/*
* 10.1. 判断两个树是否互相镜像 Iterator 做法
* (1) 根必须同时为空，或是同时不为空
*
* 如果根不为空:
* traversal 整个树，判断它们是不是镜像，每次都按照反向来traversal
* (1). 当前节点的值相等
* (2). 当前节点的左右节点要镜像，
* 无论是左节点，还是右节点，对应另外一棵树的镜像位置，可以同时为空，或是同时不为空，但是不可以一个为空，一个不为空。
* */
public static boolean isMirror(TreeNode r1, TreeNode r2){
// 如果2个树都是空树
if (r1 == null && r2 == null) {
return true;
}
// 如果其中一个为空，则返回false.
if (r1 == null || r2 == null) {
return false;
}
Stack s1 = new Stack();
Stack s2 = new Stack();
s1.push(r1);
s2.push(r2);
while (!s1.isEmpty() && !s2.isEmpty()) {
TreeNode cur1 = s1.pop();
TreeNode cur2 = s2.pop();
// 弹出的节点的值必须相等
if (cur1.val != cur2.val) {
return false;
}
// tree1的左节点，tree2的右节点，可以同时不为空，也可以同时为空，否则返回false.
TreeNode left1 = cur1.left;
TreeNode right1 = cur1.right;
TreeNode left2 = cur2.left;
TreeNode right2 = cur2.right;
if (left1 != null && right2 != null) {
s1.push(left1);
s2.push(right2);
} else if (!(left1 == null && right2 == null)) {
return false;
}
// tree1的左节点，tree2的右节点，可以同时不为空，也可以同时为空，否则返回false.
if (right1 != null && left2 != null) {
s1.push(right1);
s2.push(left2);
} else if (!(right1 == null && left2 == null)) {
return false;
}
}
return true;
}
/*
* 11. 求二叉树中两个节点的最低公共祖先节点：
* Recursion Version:
* LACRec
* 1. If found in the left tree, return the Ancestor.
* 2. If found in the right tree, return the Ancestor.
* 3. If Didn't find any of the node, return null.
* 4. If found both in the left and the right tree, return the root.
* */
public static TreeNode LACRec(TreeNode root, TreeNode node1, TreeNode node2) {
if (root == null || node1 == null || node2 == null) {
return null;
}
// If any of the node is the root, just return the root.
if (root == node1 || root == node2) {
return root;
}
// if no node is in the node, just recursively find it in LEFT and RIGHT tree.
TreeNode left = LACRec(root.left, node1, node2);
TreeNode right = LACRec(root.right, node1, node2);
if (left == null) { // If didn't found in the left tree, then just return it from right.
return right;
} else if (right == null) { // Or if didn't found in the right tree, then just return it from the left side.
return left;
}
// if both right and right found a node, just return the root as the Common Ancestor.
return root;
}
/*
* 11. 求BST中两个节点的最低公共祖先节点：
* Recursive version:
* LCABst
*
* 1. If found in the left tree, return the Ancestor.
* 2. If found in the right tree, return the Ancestor.
* 3. If Didn't find any of the node, return null.
* 4. If found both in the left and the right tree, return the root.
* */
public static TreeNode LCABstRec(TreeNode root, TreeNode node1, TreeNode node2) {
if (root == null || node1 == null || node2 == null) {
return null;
}
// If any of the node is the root, just return the root.
if (root == node1 || root == node2) {
return root;
}
int min = Math.min(node1.val, node2.val);
int max = Math.max(node1.val, node2.val);
// if the values are smaller than the root value, just search them in the left tree.
if (root.val > max) {
return LCABstRec(root.left, node1, node2);
} else if (root.val < min) {
// if the values are larger than the root value, just search them in the right tree.
return LCABstRec(root.right, node1, node2);
}
// if root is in the middle, just return the root.
return root;
}
/*
* 解法1. 记录下path,并且比较之:
* LAC
* http://www.geeksforgeeks.org/lowest-common-ancestor-binary-tree-set-1/
* */
public static TreeNode LCA(TreeNode root, TreeNode r1, TreeNode r2) {
// If the nodes have one in the root, just return the root.
if (root == null || r1 == null || r2 == null) {
return null;
}
ArrayList list1 = new ArrayList();
ArrayList list2 = new ArrayList();
boolean find1 = LCAPath(root, r1, list1);
boolean find2 = LCAPath(root, r2, list2);
// If didn't find any of the node, just return a null.
if (!find1 || !find2) {
return null;
}
// 注意: 使用Iterator 对于linkedlist可以提高性能。
// 所以统一使用Iterator 来进行操作。
Iterator iter1 = list1.iterator();
Iterator iter2 = list2.iterator();
TreeNode last = null;
while (iter1.hasNext() && iter2.hasNext()) {
TreeNode tmp1 = iter1.next();
TreeNode tmp2 = iter2.next();
if (tmp1 != tmp2) {
return last;
}
last = tmp1;
}
// If never find any node which is different, means Node 1 and Node 2 are the same one.
// so just return the last one.
return last;
}
public static boolean LCAPath(TreeNode root, TreeNode node, ArrayList path) {
// if didn't find, we should return a empty path.
if (root == null || node == null) {
return false;
}
// First add the root node.
path.add(root);
// if the node is in the left side.
if (root != node
&& !LCAPath(root.left, node, path)
&& !LCAPath(root.right, node, path)
) {
// Didn't find the node. should remove the node added before.
path.remove(root);
return false;
}
// found
return true;
}
/*
* * 12. 求二叉树中节点的最大距离：getMaxDistanceRec
*
* 首先我们来定义这个距离：
* 距离定义为：两个节点间边的数目.
* 如：
* 1
* / \
* 2 3
* \
* 4
* 这里最大距离定义为2，4的距离，为3.
* 求二叉树中节点的最大距离即二叉树中相距最远的两个节点之间的距离。 (distance / diameter)
* 递归解法：
* 返回值设计：
* 返回1. 深度， 2. 当前树的最长距离
* (1) 计算左子树的深度，右子树深度，左子树独立的链条长度，右子树独立的链条长度
* (2) 最大长度为三者之最：
* a. 通过根节点的链，为左右深度+2
* b. 左子树独立链
* c. 右子树独立链。
*
* (3)递归初始条件：
* 当root == null, depth = -1.maxDistance = -1;
*
*/
public static int getMaxDistanceRec(TreeNode root) {
return getMaxDistanceRecHelp(root).maxDistance;
}
public static Result getMaxDistanceRecHelp(TreeNode root) {
Result ret = new Result(-1, -1);
if (root == null) {
return ret;
}
Result left = getMaxDistanceRecHelp(root.left);
Result right = getMaxDistanceRecHelp(root.right);
// 深度应加1， the depth from the subtree to the root.
ret.depth = Math.max(left.depth, right.depth) + 1;
// 左子树，右子树与根的距离都要加1，所以通过根节点的路径为两边深度+2
int crossLen = left.depth + right.depth + 2;
// 求出cross根的路径，及左右子树的独立路径，这三者路径的最大值。
ret.maxDistance = Math.max(left.maxDistance, right.maxDistance);
ret.maxDistance = Math.max(ret.maxDistance, crossLen);
return ret;
}
private static class Result {
int depth;
int maxDistance;
public Result(int depth, int maxDistance) {
this.depth = depth;
this.maxDistance = maxDistance;
}
}
/*
* 13. 由前序遍历序列和中序遍历序列重建二叉树：rebuildBinaryTreeRec
* We assume that there is no duplicate in the trees.
* For example:
* 1
* / \
* 2 3
* /\ \
* 4 5 6
* /\
* 7 8
*
* PreOrder should be: 1 2 4 5 3 6 7 8
* 根左子树右子树
* InOrder should be: 4 2 5 1 3 7 6 8
* 左子树根右子树
* */
public static TreeNode rebuildBinaryTreeRec(List preOrder, List inOrder) {
if (preOrder == null || inOrder == null) {
return null;
}
// If the traversal is empty, just return a NULL.
if (preOrder.size() == 0 || inOrder.size() == 0) {
return null;
}
// we can get the root from the preOrder.
// Because the first one is the root.
// So we just create the root node here.
TreeNode root = new TreeNode(preOrder.get(0));
List preOrderLeft;
List preOrderRight;
List inOrderLeft;
List inOrderRight;
// 获得在 inOrder中，根的位置
int rootInIndex = inOrder.indexOf(preOrder.get(0));
preOrderLeft = preOrder.subList(1, rootInIndex + 1);
preOrderRight = preOrder.subList(rootInIndex + 1, preOrder.size());
// 得到inOrder左边的左子树
inOrderLeft = inOrder.subList(0, rootInIndex);
inOrderRight = inOrder.subList(rootInIndex + 1, inOrder.size());
// 通过 Rec 来调用生成左右子树。
root.left = rebuildBinaryTreeRec(preOrderLeft, inOrderLeft);
root.right = rebuildBinaryTreeRec(preOrderRight, inOrderRight);
return root;
}
/*
* 14. 判断二叉树是不是完全二叉树：isCompleteBinaryTree, isCompleteBinaryTreeRec
* 进行level traversal, 一旦遇到一个节点的左节点为空，后面的节点的子节点都必须为空。而且不应该有下一行，其实就是队列中所有的
* 元素都不应该再有子元素。
* */
public static boolean isCompleteBinaryTree(TreeNode root) {
if (root == null) {
return false;
}
TreeNode dummyNode = new TreeNode(0);
Queue q = new LinkedList();
q.offer(root);
q.offer(dummyNode);
// if this is true, no node should have any child.
boolean noChild = false;
while (!q.isEmpty()) {
TreeNode cur = q.poll();
if (cur == dummyNode) {
if (!q.isEmpty()) {
q.offer(dummyNode);
}
// Dummy node不需要处理。
continue;
}
if (cur.left != null) {
// 如果标记被设置，则Queue中任何元素不应再有子元素。
if (noChild) {
return false;
}
q.offer(cur.left);
} else {
// 一旦某元素没有左节点或是右节点，则之后所有的元素都不应有子元素。
// 并且该元素不可以有右节点.
noChild = true;
}
if (cur.right != null) {
// 如果标记被设置，则Queue中任何元素不应再有子元素。
if (noChild) {
return false;
}
q.offer(cur.right);
} else {
// 一旦某元素没有左节点或是右节点，则之后所有的元素都不应有子元素。
noChild = true;
}
}
return true;
}
/*
* 14. 判断二叉树是不是完全二叉树：isCompleteBinaryTreeRec
*
*
* 我们可以分解为：
* CompleteBinary Tree 的条件是：
* 1. 左右子树均为Perfect binary tree, 并且两者Height相同
* 2. 左子树为CompleteBinaryTree, 右子树为Perfect binary tree，并且两者Height差1
* 3. 左子树为Perfect Binary Tree,右子树为CompleteBinaryTree, 并且Height 相同
*
* Base 条件：
* (1) root = null: 为perfect & complete BinaryTree, Height -1;
*
* 而 Perfect Binary Tree的条件：
* 左右子树均为Perfect Binary Tree,并且Height 相同。
* */
public static boolean isCompleteBinaryTreeRec(TreeNode root) {
return isCompleteBinaryTreeRecHelp(root).isCompleteBT;
}
private static class ReturnBinaryTree {
boolean isCompleteBT;
boolean isPerfectBT;
int height;
ReturnBinaryTree(boolean isCompleteBT, boolean isPerfectBT, int height) {
this.isCompleteBT = isCompleteBT;
this.isPerfectBT = isPerfectBT;
this.height = height;
}
}
/*
* 我们可以分解为：
* CompleteBinary Tree 的条件是：
* 1. 左右子树均为Perfect binary tree, 并且两者Height相同
* 2. 左子树为CompleteBinaryTree, 右子树为Perfect binary tree，并且两者Height差1
* 3. 左子树为Perfect Binary Tree,右子树为CompleteBinaryTree, 并且Height 相同
*
* Base 条件：
* (1) root = null: 为perfect & complete BinaryTree, Height -1;
*
* 而 Perfect Binary Tree的条件：
* 左右子树均为Perfect Binary Tree,并且Height 相同。
* */
public static ReturnBinaryTree isCompleteBinaryTreeRecHelp(TreeNode root) {
ReturnBinaryTree ret = new ReturnBinaryTree(true, true, -1);
if (root == null) {
return ret;
}
ReturnBinaryTree left = isCompleteBinaryTreeRecHelp(root.left);
ReturnBinaryTree right = isCompleteBinaryTreeRecHelp(root.right);
// 树的高度为左树高度，右树高度的最大值+1
ret.height = 1 + Math.max(left.height, right.height);
// set the isPerfectBT
ret.isPerfectBT = false;
if (left.isPerfectBT && right.isPerfectBT && left.height == right.height) {
ret.isPerfectBT = true;
}
// set the isCompleteBT.
/*
* CompleteBinary Tree 的条件是：
* 1. 左右子树均为Perfect binary tree, 并且两者Height相同(其实就是本树是perfect tree)
* 2. 左子树为CompleteBinaryTree, 右子树为Perfect binary tree，并且两者Height差1
* 3. 左子树为Perfect Binary Tree,右子树为CompleteBinaryTree, 并且Height 相同
* */
ret.isCompleteBT = ret.isPerfectBT
|| (left.isCompleteBT && right.isPerfectBT && left.height == right.height + 1)
|| (left.isPerfectBT && right.isCompleteBT && left.height == right.height);
return ret;
}
/*
* 15. findLongest
* 第一种解法：
* 返回左边最长，右边最长，及左子树最长，右子树最长。
* */
public static int findLongest(TreeNode root) {
if (root == null) {
return -1;
}
TreeNode l = root;
int cntL = 0;
while (l.left != null) {
cntL++;
l = l.left;
}
TreeNode r = root;
int cntR = 0;
while (r.right != null) {
cntR++;
r = r.right;
}
int lmax = findLongest(root.left);
int rmax = findLongest(root.right);
int max = Math.max(lmax, rmax);
max = Math.max(max, cntR);
max = Math.max(max, cntL);
return max;
}
/* 1
* 2 3
* 3 4
* 6 1
* 7
* 9
* 11
* 2
* 14
* */
public static int findLongest2(TreeNode root) {
int [] maxVal = new int[1];
maxVal[0] = -1;
findLongest2Help(root, maxVal);
return maxVal[0];
}
// ret:
// 0: the left side longest,
// 1: the right side longest.
static int maxLen = -1;
static int[] findLongest2Help(TreeNode root, int[] maxVal) {
int[] ret = new int[2];
if (root == null) {
ret[0] = -1;
ret[1] = -1;
return ret;
}
ret[0] = findLongest2Help(root.left, maxVal)[0] + 1;
ret[1] = findLongest2Help(root.right, maxVal)[1] + 1;
//maxLen = Math.max(maxLen, ret[0]);
//maxLen = Math.max(maxLen, ret[1]);
maxVal[0] = Math.max(maxVal[0], ret[0]);
maxVal[0] = Math.max(maxVal[0], ret[1]);
return ret;
}
}

package Algorithms.tree;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;


/**
 * REFS:  
 * http://blog.csdn.net/fightforyourdream/article/details/16843303 面试大总结之二：Java搞定面试中的二叉树题目
 * http://blog.csdn.net/luckyxiaoqiang/article/details/7518888          轻松搞定面试中的二叉树题目 
 * http://www.cnblogs.com/Jax/archive/2009/12/28/1633691.html           算法大全（3） 二叉树 
 *  
 * 1. 求二叉树中的节点个数: getNodeNumRec（递归），getNodeNum（迭代） 
 * 2. 求二叉树的深度: getDepthRec（递归），getDepth  
 * 3. 前序遍历，中序遍历，后序遍历: preorderTraversalRec, preorderTraversal, inorderTraversalRec, postorderTraversalRec 
 * (https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_2) 
 * 4.分层遍历二叉树（按层次从上往下，从左往右）: levelTraversal, levelTraversalRec（递归解法） 
 * 5. 将二叉查找树变为有序的双向链表: convertBST2DLLRec, convertBST2DLL 
 * 6. 求二叉树第K层的节点个数：getNodeNumKthLevelRec, getNodeNumKthLevel
 * 7. 求二叉树中叶子节点的个数：getNodeNumLeafRec, getNodeNumLeaf 
 * 8. 判断两棵二叉树是否相同的树：isSameRec, isSame
 * 9. 判断二叉树是不是平衡二叉树：isAVLRec 
 * 10. 求二叉树的镜像（破坏和不破坏原来的树两种情况）：
 *     mirrorRec, mirrorCopyRec
 *     mirror, mirrorCopy 
 * 10.1 判断两个树是否互相镜像：isMirrorRec isMirror
 * 11. 求二叉树中两个节点的最低公共祖先节点：
 *      LAC        求解最小公共祖先, 使用list来存储path.
 *      LCABstRec  递归求解BST树.
 *      LCARec     递归算法 .
 * 12. 求二叉树中节点的最大距离：getMaxDistanceRec 
 * 13. 由前序遍历序列和中序遍历序列重建二叉树：rebuildBinaryTreeRec
 * 14. 判断二叉树是不是完全二叉树：isCompleteBinaryTree, isCompleteBinaryTreeRec
 * 15. 找出二叉树中最长连续子串(即全部往左的连续节点，或是全部往右的连续节点）findLongest
 */  

public class TreeDemo {
    /* 
            1  
           / \  
          2   3  
         / \   \  
        4   5   6      
    */  
    public static void main(String[] args) {
        TreeNode r1 = new TreeNode(1);
        TreeNode r2 = new TreeNode(2);
        TreeNode r3 = new TreeNode(3);
        TreeNode r4 = new TreeNode(4);
        TreeNode r5 = new TreeNode(5);
        TreeNode r6 = new TreeNode(6);
        
/*                    
       10  
       / \  
      6   14  
     / \   \  
    4   8   16
   /
  0        
*/ 
        /* 
        1  
       / \  
      2   3  
     / \   \  
    4   5   6      
*/  
//        TreeNode r1 = new TreeNode(10);
//        TreeNode r2 = new TreeNode(6);
//        TreeNode r3 = new TreeNode(14);
//        TreeNode r4 = new TreeNode(4);
//        TreeNode r5 = new TreeNode(8);
//        TreeNode r6 = new TreeNode(16);
        
        TreeNode r7 = new TreeNode(0);
        
        r1.left = r2;
        r1.right = r3;
        r2.left = r4;
        r2.right = r5;
        r3.right = r6;
        
        r4.left = r7;

        TreeNode t1 = new TreeNode(10);
        TreeNode t2 = new TreeNode(6);
        TreeNode t3 = new TreeNode(14);
        TreeNode t4 = new TreeNode(4);
        TreeNode t5 = new TreeNode(8);
        TreeNode t6 = new TreeNode(16);
        
        TreeNode t7 = new TreeNode(0);
        
        TreeNode t8 = new TreeNode(0);
        TreeNode t9 = new TreeNode(0);
        TreeNode t10 = new TreeNode(0);
        TreeNode t11 = new TreeNode(0);
        
        
        t1.left = t2;
        t1.right = t3;
        t2.left = t4;
        t2.right = t5;
        t3.left = t6;
        t3.right = t7;
        
        t4.left = t8;
        //t4.right = t9;
        t5.right = t9;
        
        
        // test distance
//        t5.right = t8;
//        t8.right = t9;
//        t9.right = t10;
//        t10.right = t11;
        
        /* 
        10  
        / \  
       6   14  
      / \   \  
     4   8   16
    /
   0        
 */ 
//        System.out.println(LCABstRec(t1, t2, t4).val);
//        System.out.println(LCABstRec(t1, t2, t6).val);
//        System.out.println(LCABstRec(t1, t4, t6).val);
//        System.out.println(LCABstRec(t1, t4, t7).val);
//        System.out.println(LCABstRec(t1, t3, t6).val);
//        
//        System.out.println(LCA(t1, t2, t4).val);
//        System.out.println(LCA(t1, t2, t6).val);
//        System.out.println(LCA(t1, t4, t6).val);
//        System.out.println(LCA(t1, t4, t7).val);
//        System.out.println(LCA(t1, t3, t6).val);
//        System.out.println(LCA(t1, t6, t6).val);
        
        //System.out.println(getMaxDistanceRec(t1));
        
        //System.out.println(isSame(r1, t1));
        
//        System.out.println(isAVLRec(r1));
//        
//        preorderTraversalRec(r1);
//        //mirrorRec(r1);
//        //TreeNode r1Mirror = mirror(r1);
//        
//        TreeNode r1MirrorCopy = mirrorCopy(r1);
//        System.out.println();
//        //preorderTraversalRec(r1Mirror);
//        preorderTraversalRec(r1MirrorCopy);
//        
//        System.out.println();
//        
//        System.out.println(isMirrorRec(r1, r1MirrorCopy));
//        System.out.println(isMirror(r1, r1MirrorCopy));
        
        
        //System.out.println(getNodeNumKthLevelRec(r1, 5));
        
        //System.out.println(getNodeNumLeaf(r1));
        
//      System.out.println(getNodeNumRec(null));
//      System.out.println(getNodeNum(r1));
        //System.out.println(getDepthRec(null));
//        System.out.println(getDepth(r1));
//        
//        preorderTraversalRec(r1);
//        System.out.println();
//        preorderTraversal(r1);
//        System.out.println();
//        inorderTraversalRec(r1);
//        
//        System.out.println();
//          inorderTraversal(r1);
//        postorderTraversalRec(r1);
//        System.out.println();
//        postorderTraversal(r1);
//        System.out.println();
//        levelTraversal(r1);
//        
//        System.out.println();
//        levelTraversalRec(r1);
        
//        TreeNode ret = convertBST2DLLRec(r1);
//        while (ret != null) {
//            System.out.print(ret.val + " ");
//            ret = ret.right;
//        }
        
//        TreeNode ret2 = convertBST2DLL(r1);
//        while (ret2.right != null) {
//            ret2 = ret2.right;
//        }
//        
//        while (ret2 != null) {
//            System.out.print(ret2.val + " ");
//            ret2 = ret2.left;
//        }
//        
//        TreeNode ret = convertBST2DLL(r1);
//        while (ret != null) {
//            System.out.print(ret.val + " ");
//            ret = ret.right;
//        }
        
//        System.out.println();
//        System.out.println(findLongest(r1));
//        System.out.println();
//        System.out.println(findLongest2(r1));
        
        // test the rebuildBinaryTreeRec.
        //test_rebuildBinaryTreeRec();
        
        System.out.println(isCompleteBinaryTreeRec(t1));
        System.out.println(isCompleteBinaryTree(t1));
    }
    
    public static void test_rebuildBinaryTreeRec() {
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(4);
        list1.add(5);
        list1.add(3);
        list1.add(6);
        list1.add(7);
        list1.add(8);
        
        ArrayList list2 = new ArrayList();
        list2.add(4);
        list2.add(2);
        list2.add(5);
        list2.add(1);
        list2.add(3);
        list2.add(7);
        list2.add(6);
        list2.add(8);
        
        TreeNode root = rebuildBinaryTreeRec(list1, list2);
        preorderTraversalRec(root);
        System.out.println();
        postorderTraversalRec(root);
    }
    
    private static class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;
        public TreeNode(int val){
            this.val = val;
            left = null;
            right = null;                    
        }
    }
    
    /*
     * null返回0，然后把左右子树的size加上即可。
     * */
    public static int getNodeNumRec(TreeNode root) {
        if (root == null) {
            return 0;
        }
                
        return getNodeNumRec(root.left) + getNodeNumRec(root.right) + 1;
    }

    /** 
     *  求二叉树中的节点个数迭代解法O(n)：基本思想同LevelOrderTraversal， 
     *  即用一个Queue，在Java里面可以用LinkedList来模拟  
     */  
    public static int getNodeNum(TreeNode root) {
        if (root == null) {
            return 0;
        }
        
        Queue q = new LinkedList(); 
        q.offer(root);
        
        int cnt = 0;
        while (!q.isEmpty()) {
            TreeNode node = q.poll();
            if (node.left != null) {
                q.offer(node.left);
            }
            
            if (node.right != null) {
                q.offer(node.right);
            }
            
            cnt++;
        }
        
        return cnt;
    }
    
    public static int getDepthRec(TreeNode root) {
        if (root == null) {
            return -1;
        }
        
        return Math.max(getDepthRec(root.left), getDepthRec(root.right)) + 1;
    }
    
    /*
     * 可以用 level LevelOrderTraversal 来实现，我们用一个dummyNode来分隔不同的层，这样即可计算出实际的depth.
     *      1  
           / \  
          2   3  
         / \   \  
        4   5   6
     * 
     * 在队列中如此排列： 1, dummy, 2, 3, dummy, 4, 5, 5, dummy  
     * 
    */  
    public static int getDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        
        TreeNode dummy = new TreeNode(0);
        Queue q = new LinkedList();
        q.offer(root);
        q.offer(dummy);
        
        int depth = -1;
        while (!q.isEmpty()) {
            TreeNode curr = q.poll();
            if (curr == dummy) {
                depth++;
                if (!q.isEmpty()) {  // 使用DummyNode来区分不同的层， 如果下一层不是为空，则应该在尾部加DummyNode.
                    q.offer(dummy);
                }
            }
            
            if (curr.left != null) {
                q.offer(curr.left);
            }
            if (curr.right != null) {
                q.offer(curr.right);
            }
        }
        
        return depth;
    }
    
    /*
     * 3. 前序遍历，中序遍历，后序遍历: preorderTraversalRec, preorderTraversal, inorderTraversalRec, postorderTraversalRec 
     * (https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_2)
     * */
    public static void preorderTraversalRec(TreeNode root) {
        if (root == null) {
            return;
        }
        
        System.out.print(root.val + " ");
        preorderTraversalRec(root.left);
        preorderTraversalRec(root.right);
    }
    
    /*
     * 前序遍历，Iteration 算法. 把根节点存在stack中。
     * */
    public static void preorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        
        Stack s = new Stack();
        s.push(root);
        
        while (!s.isEmpty()) {
            TreeNode node = s.pop();
            System.out.print(node.val + " ");
            if (node.right != null) { //
                s.push(node.right);
            }
            
            // 我们需要先压入右节点，再压入左节点，这样就可以先弹出左节点。 
            if (node.left != null) {
                s.push(node.left);
            }                       
        }
    }
    
    /*
     * 中序遍历
     * */
    public static void inorderTraversalRec(TreeNode root) {
        if (root == null) {
            return;
        }
        
        inorderTraversalRec(root.left);
        System.out.print(root.val + " ");
        inorderTraversalRec(root.right);
    }
    
    /** 
     * 中序遍历迭代解法 ，用栈先把根节点的所有左孩子都添加到栈内， 
     * 然后输出栈顶元素，再处理栈顶元素的右子树 
     * http://www.youtube.com/watch?v=50v1sJkjxoc 
     *  
     * 还有一种方法能不用递归和栈，基于线索二叉树的方法，较麻烦以后补上 
     * http://www.geeksforgeeks.org/inorder-tree-traversal-without-recursion-and-without-stack/ 
     */  
    public static void inorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        
        Stack s = new Stack();
        
        TreeNode cur = root;
        
        while(true) {
            // 把当前节点的左节点都push到栈中.
            while (cur != null) {
                s.push(cur);
                cur = cur.left;
            }
            
            if (s.isEmpty()) {
                break;
            }
            
            // 因为此时已经没有左孩子了，所以输出栈顶元素 
            cur = s.pop();
            System.out.print(cur.val + " ");
            
            // 准备处理右子树  
            cur = cur.right;            
        }
    }
    
    // 后序遍历
    /*
     *      1  
           / \  
          2   3  
         / \   \  
        4   5   6
        
        if put into the stack directly, then it should be:
        1, 2, 4, 5, 3, 6 in the stack.
        when pop, it should be: 6, 3, 5, 4, 2, 1
        
        if I 
     * */
    
    public static void postorderTraversalRec(TreeNode root) {
        if (root == null) {
            return;
        }
        
        postorderTraversalRec(root.left);
        postorderTraversalRec(root.right);
        System.out.print(root.val + " ");
    }
    
    /** 
     *  后序遍历迭代解法 
     *  http://www.youtube.com/watch?v=hv-mJUs5mvU 
     *  http://blog.csdn.net/tang_jin2015/article/details/8545457
     *  从左到右的后序 与从右到左的前序的逆序是一样的，所以就简单喽！ 哈哈
     *  用另外一个栈进行翻转即可喽 
     */ 
    public static void postorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        
        Stack s = new Stack();
        Stack out = new Stack();
        
        s.push(root);
        while(!s.isEmpty()) {
            TreeNode cur = s.pop();
            out.push(cur);
            
            if (cur.left != null) {
                s.push(cur.left);
            }
            if (cur.right != null) {
                s.push(cur.right);
            }
        }
        
        while(!out.isEmpty()) {
            System.out.print(out.pop().val + " ");
        }
    }
    
    /*
     * 分层遍历二叉树（按层次从上往下，从左往右）迭代 
     * 其实就是广度优先搜索，使用队列实现。队列初始化，将根节点压入队列。当队列不为空，进行如下操作：弹出一个节点 
     * ，访问，若左子节点或右子节点不为空，将其压入队列 
     * */
    public static void levelTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        
        Queue q = new LinkedList();
        q.offer(root);
        
        while (!q.isEmpty()) {
            TreeNode cur = q.poll();
            
            System.out.print(cur.val + " ");
            if (cur.left != null) {
                q.offer(cur.left);
            }
            if (cur.right != null) {
                q.offer(cur.right);
            }
        }
    }
    
    public static void levelTraversalRec(TreeNode root) {
        ArrayList> ret = new ArrayList>();
        levelTraversalVisit(root, 0, ret);
        System.out.println(ret);
    }
    
    /** 
     *  分层遍历二叉树（递归） 
     *  很少有人会用递归去做level traversal 
     *  基本思想是用一个大的ArrayList，里面包含了每一层的ArrayList。 
     *  大的ArrayList的size和level有关系 
     *   
     *  http://discuss.leetcode.com/questions/49/binary-tree-level-order-traversal#answer-container-2543 
     */  
    public static void levelTraversalVisit(TreeNode root, int level, ArrayList> ret) {
        if (root == null) {
            return;
        }
        
        // 如果ArrayList的层数不够用， 则新添加一层
        // when size = 3, level: 0, 1, 2
        if (level >= ret.size()) {
            ret.add(new ArrayList());
        }
        
        // visit 当前节点
        ret.get(level).add(root.val);
        
        // 将左子树， 右子树添加到对应的层。
        levelTraversalVisit(root.left, level + 1, ret);
        levelTraversalVisit(root.right, level + 1, ret);
    }
    
    /*
     * 题目要求：将二叉查找树转换成排序的双向链表，不能创建新节点，只调整指针。
       查找树的结点定义如下：
       既然是树，其定义本身就是递归的，自然用递归算法处理就很容易。将根结点的左子树和右子树转换为有序的双向链表，
       然后根节点的left指针指向左子树结果的最后一个结点，同时左子树最后一个结点的right指针指向根节点；
       根节点的right指针指向右子树结果的第一个结点，
       同时右子树第一个结点的left指针指向根节点。
     * */
    public static TreeNode convertBST2DLLRec(TreeNode root) {
        return convertBST2DLLRecHelp(root)[0];
    }
    
    /*
     * ret[0] 代表左指针
     * ret[1] 代表右指针
     * */
    public static TreeNode[] convertBST2DLLRecHelp(TreeNode root) {
        TreeNode[] ret = new TreeNode[2];
        ret[0] = null;
        ret[1] = null;
                
        if (root == null) {
            return ret;
        }
        
        if (root.left != null) {
            TreeNode left[] = convertBST2DLLRecHelp(root.left);
            left[1].right = root;  // 将左子树的尾节点连接到根
            root.left = left[1];
            
            ret[0] = left[0];
        } else {
            ret[0] = root;   // 左节点返回root.
        }
        
        if (root.right != null) {
            TreeNode right[] = convertBST2DLLRecHelp(root.right);
            right[0].left = root;  // 将右子树的头节点连接到根
            root.right = right[0];
            
            ret[1] = right[1];
        } else {
            ret[1] = root;  // 右节点返回root.
        }
        
        return ret;
    }
    
    /** 
     * 将二叉查找树变为有序的双向链表 迭代解法 
     * 类似inOrder traversal的做法 
     */  
    public static TreeNode convertBST2DLL(TreeNode root) {
        while (root == null) {
            return null;
        }
        
        TreeNode pre = null;
        Stack s = new Stack();
        TreeNode cur = root;
        TreeNode head = null;       // 链表头
        
        while (true) {
            while (cur != null) {
                s.push(cur);
                cur = cur.left;
            }
            
            // if stack is empty, just break;
            if (s.isEmpty()) {
                break;
            }
            
            cur = s.pop(); 
            if (head == null) {
                head = cur;
            }

            // link pre and cur.
            cur.left = pre;
            if (pre != null) {
                pre.right = cur;
            }
            
            // 左节点已经处理完了，处理右节点
            cur = cur.right;
            pre = cur;
        }
        
        return root;
    }

/*
 *  * 6. 求二叉树第K层的节点个数：getNodeNumKthLevelRec, getNodeNumKthLevel 
 * */
    public static int getNodeNumKthLevel(TreeNode root, int k) {
        if (root == null || k <= 0) {
            return 0;
        }
        
        int level = 0;
        
        Queue q = new LinkedList();
        q.offer(root);
        
        TreeNode dummy = new TreeNode(0);
        int cnt = 0; // record the size of the level.
        
        q.offer(dummy);
        while (!q.isEmpty()) {
            TreeNode node = q.poll();
            
            if (node == dummy) {
                level++;
                if (level == k) {
                    return cnt;
                }
                cnt = 0; // reset the cnt;
                if (q.isEmpty()) {
                    break;
                }
                q.offer(dummy);
                continue;
            }
            
            cnt++;
            if (node.left != null) {
                q.offer(node.left);
            }
            
            if (node.right != null) {
                q.offer(node.right);
            }
        }
        
        return 0;
    }
    
    /*
     *  * 6. 求二叉树第K层的节点个数：getNodeNumKthLevelRec, getNodeNumKthLevel 
     * */
    public static int getNodeNumKthLevelRec(TreeNode root, int k) {
        if (root == null || k <= 0) {
            return 0;
        }
        
        if (k == 1) {
            return 1;
        }
        
        // 将左子树及右子树在K层的节点个数相加.
        return getNodeNumKthLevelRec(root.left, k - 1) + getNodeNumKthLevelRec(root.right, k - 1);
    }
    
    /*
     * 7. getNodeNumLeafRec  把左子树和右子树的叶子节点加在一起即可
     * */
    public static int getNodeNumLeafRec(TreeNode root) {
        if (root == null) {
            return 0;
        }
        
        if (root.left == null && root.right == null) {
            return 1;
        }
        
        return getNodeNumLeafRec(root.left) + getNodeNumLeafRec(root.right);
    }
    
    /* 7. getNodeNumLeaf
     * 随便使用一种遍历方法都可以，比如，中序遍历。
     * inorderTraversal，判断是不是叶子节点。
     * */
    public static int getNodeNumLeaf(TreeNode root) {
        if (root == null) {
            return 0;
        }
        
        int cnt = 0;
        
        // we can use inorderTraversal travesal to do it.
        Stack s = new Stack();
        TreeNode cur = root;
        
        while (true) {
            while (cur != null) {
                s.push(cur);
                cur = cur.left;
            }
            
            if (s.isEmpty()) {
                break;
            }
            
            // all the left child has been put into the stack, let's deal with the 
            // current node.
            cur = s.pop();
            if (cur.left == null && cur.right == null) {
                cnt++;
            }
            cur = cur.right;
        }
        
        return cnt;
    }
    
    /*
     * 8. 判断两棵二叉树是否相同的树。 
     * 递归解法：  
     * （1）如果两棵二叉树都为空，返回真 
     * （2）如果两棵二叉树一棵为空，另一棵不为空，返回假  
     * （3）如果两棵二叉树都不为空，如果对应的左子树和右子树都同构返回真，其他返回假 
     * */
    public static boolean isSameRec(TreeNode r1, TreeNode r2) {
        // both are null.
        if (r1 == null && r2 == null) {
            return true;
        }
        
        // one is null.
        if (r1 == null || r2 == null) {
            return false;
        }
        
        // 1. the value of the root should be the same;
        // 2. the left tree should be the same.
        // 3. the right tree should be the same.
        return r1.val == r2.val && 
                isSameRec(r1.left, r2.left) && isSameRec(r1.right, r2.right);
    }
    
    /*
     * 8. 判断两棵二叉树是否相同的树。
     * 迭代解法 
     * 我们直接用中序遍历来比较就好啦 
     * */
    public static boolean isSame(TreeNode r1, TreeNode r2) {
        // both are null.
        if (r1 == null && r2 == null) {
            return true;
        }
        
        // one is null.
        if (r1 == null || r2 == null) {
            return false;
        }
        
        Stack s1 = new Stack();
        Stack s2 = new Stack();
        
        TreeNode cur1 = r1;
        TreeNode cur2 = r2;
        
        while (true) {
            while (cur1 != null && cur2 != null) {
                s1.push(cur1);
                s2.push(cur2);
                cur1 = cur1.left;
                cur2 = cur2.left;
            }
            
            if (cur1 != null || cur2 != null) {
                return false;
            }
            
            if (s1.isEmpty() && s2.isEmpty()) {
                break;
            }
            
            cur1 = s1.pop();
            cur2 = s2.pop();
            if (cur1.val != cur2.val) {
                return false;
            }
            
            cur1 = cur1.right;
            cur2 = cur2.right;
        }
        
        return true;
    }
    
/*
 * 
 *  9. 判断二叉树是不是平衡二叉树：isAVLRec
 *     1. 左子树，右子树的高度差不能超过1
 *     2. 左子树，右子树都是平衡二叉树。 
 *      
 */
    public static boolean isAVLRec(TreeNode root) {
        if (root == null) {
            return true;
        }
        
        // 左子树，右子树都必须是平衡二叉树。 
        if (!isAVLRec(root.left) || !isAVLRec(root.right)) {
            return false;
        }
        
        int dif = Math.abs(getDepthRec(root.left) - getDepthRec(root.right));
        if (dif > 1) {
            return false;
        }
        
        return true;
    }
    
    /** 
     * 10. 求二叉树的镜像 递归解法：
     * 
     *   (1) 破坏原来的树
     *   
     *      1               1
     *     /                 \
     *    2     ----->        2
     *     \                 /
     *      3               3
     * */  
    public static TreeNode mirrorRec(TreeNode root) {  
        if (root == null) {
            return null;
        }
        
        // 先把左右子树分别镜像,并且交换它们
        TreeNode tmp = root.right;
        root.right = mirrorRec(root.left);
        root.left = mirrorRec(tmp);
        
        return root;
    }  
    
    /** 
     * 10. 求二叉树的镜像 Iterator解法：
     * 
     *   (1) 破坏原来的树
     *   
     *      1               1
     *     /                 \
     *    2     ----->        2
     *     \                 /
     *      3               3
     *      
     *  应该可以使用任何一种Traversal 方法。 
     *  我们现在可以试看看使用最简单的前序遍历。
     * */  
    public static TreeNode mirror(TreeNode root) {  
        if (root == null) {
            return null;
        }
        
        Stack s = new Stack();
        s.push(root);
        
        while (!s.isEmpty()) {
            TreeNode cur = s.pop();
            
            // 交换当前节点的左右节点
            TreeNode tmp = cur.left;
            cur.left = cur.right;
            cur.right = tmp;
            
            // traversal 左节点，右节点。
            if (cur.right != null) {
                s.push(cur.right);
            }
            
            if (cur.left != null) {
                s.push(cur.left);
            }
        }
        
        return root;
    }  
    
    /** 
     * 10. 求二叉树的镜像 Iterator解法：
     * 
     *   (2) 创建一个新的树
     *   
     *      1               1
     *     /                 \
     *    2     ----->        2
     *     \                 /
     *      3               3
     *      
     *  应该可以使用任何一种Traversal 方法。 
     *  我们现在可以试看看使用最简单的前序遍历。
     *  前序遍历我们可以立刻把新建好的左右节点创建出来，比较方便 
     * */  
    public static TreeNode mirrorCopy(TreeNode root) {  
        if (root == null) {
            return null;
        }
        
        Stack s = new Stack();
        Stack sCopy = new Stack();
        s.push(root);
        
        TreeNode rootCopy = new TreeNode(root.val);
        sCopy.push(rootCopy);
        
        while (!s.isEmpty()) {
            TreeNode cur = s.pop();
            TreeNode curCopy = sCopy.pop();
            
            // traversal 左节点，右节点。
            if (cur.right != null) {
                
                // copy 在这里做比较好，因为我们可以容易地找到它的父节点
                TreeNode leftCopy = new TreeNode(cur.right.val);
                curCopy.left = leftCopy;
                s.push(cur.right);
                sCopy.push(curCopy.left);
            }
            
            if (cur.left != null) {
                // copy 在这里做比较好，因为我们可以容易地找到它的父节点
                TreeNode rightCopy = new TreeNode(cur.left.val);
                curCopy.right = rightCopy;
                s.push(cur.left);
                sCopy.push(curCopy.right);
            }
        }
        
        return rootCopy;
    }  
    
    /** 
     * 10. 求二叉树的镜像 递归解法：
     * 
     *   (1) 不破坏原来的树，新建一个树 
     *   
     *      1               1
     *     /                 \
     *    2     ----->        2
     *     \                 /
     *      3               3
     * */  
    public static TreeNode mirrorCopyRec(TreeNode root) {  
        if (root == null) {
            return null;
        }
        
        // 先把左右子树分别镜像,并且把它们连接到新建的root节点。
        TreeNode rootCopy = new TreeNode(root.val);
        rootCopy.left = mirrorCopyRec(root.right);
        rootCopy.right = mirrorCopyRec(root.left);
        
        return rootCopy;
    }  
    
    /*
     * 10.1. 判断两个树是否互相镜像
     *  (1) 根必须同时为空，或是同时不为空
     * 
     * 如果根不为空:
     *  (1).根的值一样
     *  (2).r1的左树是r2的右树的镜像
     *  (3).r1的右树是r2的左树的镜像  
     * */
    public static boolean isMirrorRec(TreeNode r1, TreeNode r2){  
        // 如果2个树都是空树
        if (r1 == null && r2 == null) {
            return true;
        }
        
        // 如果其中一个为空，则返回false.
        if (r1 == null || r2 == null) {
            return false;
        }
        
        // If both are not null, they should be:
        // 1. have same value for root.
        // 2. R1's left tree is the mirror of R2's right tree;
        // 3. R2's right tree is the mirror of R1's left tree;
        return r1.val == r2.val 
                && isMirrorRec(r1.left, r2.right)
                && isMirrorRec(r1.right, r2.left);
    }
    
    /*
     * 10.1. 判断两个树是否互相镜像 Iterator 做法
     *  (1) 根必须同时为空，或是同时不为空
     * 
     * 如果根不为空:
     * traversal 整个树，判断它们是不是镜像，每次都按照反向来traversal  
     * (1). 当前节点的值相等
     * (2). 当前节点的左右节点要镜像，
     *    无论是左节点，还是右节点，对应另外一棵树的镜像位置，可以同时为空，或是同时不为空，但是不可以一个为空，一个不为空。      
     * */
    public static boolean isMirror(TreeNode r1, TreeNode r2){  
        // 如果2个树都是空树
        if (r1 == null && r2 == null) {
            return true;
        }
        
        // 如果其中一个为空，则返回false.
        if (r1 == null || r2 == null) {
            return false;
        }
        
        Stack s1 = new Stack();
        Stack s2 = new Stack();
        
        s1.push(r1);
        s2.push(r2);
        
        while (!s1.isEmpty() && !s2.isEmpty()) {
            TreeNode cur1 = s1.pop();
            TreeNode cur2 = s2.pop();
            
            // 弹出的节点的值必须相等 
            if (cur1.val != cur2.val) {
                return false;
            }
            
            // tree1的左节点，tree2的右节点，可以同时不为空，也可以同时为空，否则返回false.
            TreeNode left1 = cur1.left;
            TreeNode right1 = cur1.right;
            TreeNode left2 = cur2.left;
            TreeNode right2 = cur2.right;
            
            if (left1 != null && right2 != null) {
                s1.push(left1);
                s2.push(right2);
            } else if (!(left1 == null && right2 == null)) {
                return false;
            }
            
            // tree1的左节点，tree2的右节点，可以同时不为空，也可以同时为空，否则返回false.
            if (right1 != null && left2 != null) {
                s1.push(right1);
                s2.push(left2);
            } else if (!(right1 == null && left2 == null)) {
                return false;
            }
        }
        
        return true;
    }  
    
    /*
     * 11. 求二叉树中两个节点的最低公共祖先节点：
     * Recursion Version:
     * LACRec 
     * 1. If found in the left tree, return the Ancestor.
     * 2. If found in the right tree, return the Ancestor.
     * 3. If Didn't find any of the node, return null.
     * 4. If found both in the left and the right tree, return the root.
     * */
    public static TreeNode LACRec(TreeNode root, TreeNode node1, TreeNode node2) {
        if (root == null || node1 == null || node2 == null) {
            return null;
        }
        
        // If any of the node is the root, just return the root.
        if (root == node1 || root == node2) {
            return root;
        }
        
        // if no node is in the node, just recursively find it in LEFT and RIGHT tree.
        TreeNode left = LACRec(root.left, node1, node2);
        TreeNode right = LACRec(root.right, node1, node2);
        
        if (left == null) {  // If didn't found in the left tree, then just return it from right.
            return right;
        } else if (right == null) { // Or if didn't found in the right tree, then just return it from the left side.
            return left;
        } 
        
        // if both right and right found a node, just return the root as the Common Ancestor.
        return root;
    }
    
    /*
     * 11. 求BST中两个节点的最低公共祖先节点：
     * Recursive version:
     * LCABst 
     * 
     * 1. If found in the left tree, return the Ancestor.
     * 2. If found in the right tree, return the Ancestor.
     * 3. If Didn't find any of the node, return null.
     * 4. If found both in the left and the right tree, return the root.
     * */
    public static TreeNode LCABstRec(TreeNode root, TreeNode node1, TreeNode node2) {
        if (root == null || node1 == null || node2 == null) {
            return null;
        }
        
        // If any of the node is the root, just return the root.
        if (root == node1 || root == node2) {
            return root;
        }
        
        int min = Math.min(node1.val, node2.val);
        int max = Math.max(node1.val, node2.val);
        
        // if the values are smaller than the root value, just search them in the left tree.
        if (root.val > max) {
            return LCABstRec(root.left, node1, node2);
        } else if (root.val < min) {
        // if the values are larger than the root value, just search them in the right tree.    
            return LCABstRec(root.right, node1, node2);
        }
        
        // if root is in the middle, just return the root.
        return root;
    }
    
    /*
     * 解法1. 记录下path,并且比较之:
     * LAC
     * http://www.geeksforgeeks.org/lowest-common-ancestor-binary-tree-set-1/
     * */
    public static TreeNode LCA(TreeNode root, TreeNode r1, TreeNode r2) {
        // If the nodes have one in the root, just return the root.
        if (root == null || r1 == null || r2 == null) {
            return null;
        }
        
        ArrayList list1 = new ArrayList();
        ArrayList list2 = new ArrayList();
        
        boolean find1 = LCAPath(root, r1, list1);
        boolean find2 = LCAPath(root, r2, list2);
        
        // If didn't find any of the node, just return a null.
        if (!find1 || !find2) {
            return null;
        }
        
        // 注意: 使用Iterator 对于linkedlist可以提高性能。
        // 所以 统一使用Iterator 来进行操作。
        Iterator iter1 = list1.iterator();
        Iterator iter2 = list2.iterator();
        
        TreeNode last = null;
        while (iter1.hasNext() && iter2.hasNext()) {
            TreeNode tmp1 = iter1.next();
            TreeNode tmp2 = iter2.next();
            
            if (tmp1 != tmp2) {
                return last;
            }
            
            last = tmp1;
        }
        
        // If never find any node which is different, means Node 1 and Node 2 are the same one.
        // so just return the last one.
        return last;
    }
    
    public static boolean LCAPath(TreeNode root, TreeNode node, ArrayList path) {
        // if didn't find, we should return a empty path.
        if (root == null || node == null) {
            return false;
        }
        
        // First add the root node.
        path.add(root);
        
        // if the node is in the left side.
        if (root != node 
                && !LCAPath(root.left, node, path)
                && !LCAPath(root.right, node, path)
                ) {
            // Didn't find the node. should remove the node added before.
            path.remove(root);
            return false;
        }
        
        // found
        return true;
    }
    
    /*
     *  * 12. 求二叉树中节点的最大距离：getMaxDistanceRec
     *  
     *  首先我们来定义这个距离：
     *  距离定义为：两个节点间边的数目.
     *  如：
     *     1
     *    / \
     *   2   3
     *        \
     *         4
     *   这里最大距离定义为2，4的距离，为3.      
     * 求二叉树中节点的最大距离 即二叉树中相距最远的两个节点之间的距离。 (distance / diameter) 
     * 递归解法：
     * 返回值设计：
     * 返回1. 深度， 2. 当前树的最长距离  
     * (1) 计算左子树的深度，右子树深度，左子树独立的链条长度，右子树独立的链条长度
     * (2) 最大长度为三者之最：
     *    a. 通过根节点的链，为左右深度+2
     *    b. 左子树独立链
     *    c. 右子树独立链。
     * 
     * (3)递归初始条件：
     *   当root == null, depth = -1.maxDistance = -1;
     *   
     */  
    public static int getMaxDistanceRec(TreeNode root) {
        return getMaxDistanceRecHelp(root).maxDistance;
    }
    
    public static Result getMaxDistanceRecHelp(TreeNode root) {
        Result ret = new Result(-1, -1);
        
        if (root == null) {
            return ret;
        }
        
        Result left = getMaxDistanceRecHelp(root.left);
        Result right = getMaxDistanceRecHelp(root.right);
        
        // 深度应加1， the depth from the subtree to the root.
        ret.depth = Math.max(left.depth, right.depth) + 1;
        
        // 左子树，右子树与根的距离都要加1，所以通过根节点的路径为两边深度+2
        int crossLen = left.depth + right.depth + 2;
        
        // 求出cross根的路径，及左右子树的独立路径，这三者路径的最大值。
        ret.maxDistance = Math.max(left.maxDistance, right.maxDistance);
        ret.maxDistance = Math.max(ret.maxDistance, crossLen);
        
        return ret;
    }

    
    private static class Result {
        int depth;
        int maxDistance;
        public Result(int depth, int maxDistance) {
            this.depth = depth;
            this.maxDistance = maxDistance;
        }
    }
    
    /*
     *  13. 由前序遍历序列和中序遍历序列重建二叉树：rebuildBinaryTreeRec 
     *  We assume that there is no duplicate in the trees.
     *  For example:
     *          1
     *         / \
     *        2   3
     *       /\    \
     *      4  5    6
     *              /\
     *             7  8  
     *             
     *  PreOrder should be: 1   2 4 5   3 6 7 8
     *                      根   左子树    右子树  
     *  InOrder should be:  4 2 5   1   3 7 6 8
     *                       左子树  根  右子树
     * */                   
    public static TreeNode rebuildBinaryTreeRec(List preOrder, List inOrder) {
        if (preOrder == null || inOrder == null) {
            return null;
        }
        
        // If the traversal is empty, just return a NULL.
        if (preOrder.size() == 0 || inOrder.size() == 0) {
            return null;
        }
        
        // we can get the root from the preOrder. 
        // Because the first one is the root.
        // So we just create the root node here.
        TreeNode root = new TreeNode(preOrder.get(0));
        
        List preOrderLeft;
        List preOrderRight;
        List inOrderLeft;
        List inOrderRight;
        
        // 获得在 inOrder中，根的位置
        int rootInIndex = inOrder.indexOf(preOrder.get(0));
        preOrderLeft = preOrder.subList(1, rootInIndex + 1);
        preOrderRight = preOrder.subList(rootInIndex + 1, preOrder.size());
        
        // 得到inOrder左边的左子树
        inOrderLeft = inOrder.subList(0, rootInIndex);
        inOrderRight = inOrder.subList(rootInIndex + 1, inOrder.size());

        // 通过 Rec 来调用生成左右子树。
        root.left = rebuildBinaryTreeRec(preOrderLeft, inOrderLeft);
        root.right = rebuildBinaryTreeRec(preOrderRight, inOrderRight);
        
        return root;        
    }
    
    /*
     * 14. 判断二叉树是不是完全二叉树：isCompleteBinaryTree, isCompleteBinaryTreeRec
     * 进行level traversal, 一旦遇到一个节点的左节点为空，后面的节点的子节点都必须为空。而且不应该有下一行，其实就是队列中所有的
     * 元素都不应该再有子元素。
     * */
    
    public static boolean isCompleteBinaryTree(TreeNode root) {
        if (root == null) {
            return false;
        }
        
        TreeNode dummyNode = new TreeNode(0);
        Queue q = new LinkedList();
        
        q.offer(root);
        q.offer(dummyNode);
        
        // if this is true, no node should have any child.
        boolean noChild = false;
        
        while (!q.isEmpty()) {
            TreeNode cur = q.poll();
            if (cur == dummyNode) {
                if (!q.isEmpty()) {
                    q.offer(dummyNode);
                }
                // Dummy node不需要处理。 
                continue;
            }
            
            if (cur.left != null) {
                // 如果标记被设置，则Queue中任何元素不应再有子元素。
                if (noChild) {
                    return false;
                }
                q.offer(cur.left);
            } else {
                // 一旦某元素没有左节点或是右节点，则之后所有的元素都不应有子元素。
                // 并且该元素不可以有右节点.
                noChild = true;
            }
            
            if (cur.right != null) {
                // 如果标记被设置，则Queue中任何元素不应再有子元素。
                if (noChild) {
                    return false;
                }
                q.offer(cur.right);
            } else {
                // 一旦某元素没有左节点或是右节点，则之后所有的元素都不应有子元素。
                noChild = true;
            }
        }
        
        return true;
    }
    
    /*
     * 14. 判断二叉树是不是完全二叉树：isCompleteBinaryTreeRec
     * 
     * 
     *    我们可以分解为：
     *    CompleteBinary Tree 的条件是：
     *    1. 左右子树均为Perfect binary tree, 并且两者Height相同
     *    2. 左子树为CompleteBinaryTree, 右子树为Perfect binary tree，并且两者Height差1
     *    3. 左子树为Perfect Binary Tree,右子树为CompleteBinaryTree, 并且Height 相同
     *    
     *    Base 条件：
     *    (1) root = null: 为perfect & complete BinaryTree, Height -1;
     *    
     *    而 Perfect Binary Tree的条件：
     *    左右子树均为Perfect Binary Tree,并且Height 相同。
     * */
    
    public static boolean isCompleteBinaryTreeRec(TreeNode root) {
        return isCompleteBinaryTreeRecHelp(root).isCompleteBT;
    }
    
    private static class ReturnBinaryTree {
        boolean isCompleteBT;
        boolean isPerfectBT;
        int height;
        
        ReturnBinaryTree(boolean isCompleteBT, boolean isPerfectBT, int height) {
            this.isCompleteBT = isCompleteBT;
            this.isPerfectBT = isPerfectBT;
            this.height = height;
        }
    }
    
    /*
     * 我们可以分解为：
     *    CompleteBinary Tree 的条件是：
     *    1. 左右子树均为Perfect binary tree, 并且两者Height相同
     *    2. 左子树为CompleteBinaryTree, 右子树为Perfect binary tree，并且两者Height差1
     *    3. 左子树为Perfect Binary Tree,右子树为CompleteBinaryTree, 并且Height 相同
     *    
     *    Base 条件：
     *    (1) root = null: 为perfect & complete BinaryTree, Height -1;
     *    
     *    而 Perfect Binary Tree的条件：
     *    左右子树均为Perfect Binary Tree,并且Height 相同。
     * */
    public static ReturnBinaryTree isCompleteBinaryTreeRecHelp(TreeNode root) {
        ReturnBinaryTree ret = new ReturnBinaryTree(true, true, -1);
        
        if (root == null) {
            return ret;
        }
        
        ReturnBinaryTree left = isCompleteBinaryTreeRecHelp(root.left);
        ReturnBinaryTree right = isCompleteBinaryTreeRecHelp(root.right);
        
        // 树的高度为左树高度，右树高度的最大值+1
        ret.height = 1 + Math.max(left.height, right.height);
        
        // set the isPerfectBT
        ret.isPerfectBT = false;
        if (left.isPerfectBT && right.isPerfectBT && left.height == right.height) {
            ret.isPerfectBT = true;
        }
        
        // set the isCompleteBT.
        /*
         * CompleteBinary Tree 的条件是：
         *    1. 左右子树均为Perfect binary tree, 并且两者Height相同(其实就是本树是perfect tree)
         *    2. 左子树为CompleteBinaryTree, 右子树为Perfect binary tree，并且两者Height差1
         *    3. 左子树为Perfect Binary Tree,右子树为CompleteBinaryTree, 并且Height 相同
         * */
        ret.isCompleteBT = ret.isPerfectBT 
                || (left.isCompleteBT && right.isPerfectBT && left.height == right.height + 1)
                || (left.isPerfectBT && right.isCompleteBT && left.height == right.height);
        
        return ret;
    }

    /*
     * 15. findLongest
     * 第一种解法：
     * 返回左边最长，右边最长，及左子树最长，右子树最长。
     * */
    public static int findLongest(TreeNode root) {
        if (root == null) {
            return -1;
        }
        
        TreeNode l = root;
        int cntL = 0;
        while (l.left != null) {
            cntL++;
            l = l.left;
        }
        
        TreeNode r = root;
        int cntR = 0;
        while (r.right != null) {
            cntR++;
            r = r.right;
        }
        
        int lmax = findLongest(root.left);
        int rmax = findLongest(root.right);
        
        int max = Math.max(lmax, rmax);
        max = Math.max(max, cntR);
        max = Math.max(max, cntL);
        
        return max;
    }
    
    /*      1
     *    2   3
     *  3       4
     *         6  1
     *        7
     *       9
     *     11
     *    2
     *  14      
     * */
    public static int findLongest2(TreeNode root) {
        int [] maxVal = new int[1];
        maxVal[0] = -1;
        findLongest2Help(root, maxVal);
        return maxVal[0];
    }
    
    // ret:
    // 0: the left side longest,
    // 1: the right side longest.
    static int maxLen = -1;
    static int[] findLongest2Help(TreeNode root, int[] maxVal) {
        int[] ret = new int[2];
        if (root == null) {
            ret[0] = -1;
            ret[1] = -1;
            return ret;
        }
        
        ret[0] = findLongest2Help(root.left, maxVal)[0] + 1;
        ret[1] = findLongest2Help(root.right, maxVal)[1] + 1;
        //maxLen = Math.max(maxLen, ret[0]);
        //maxLen = Math.max(maxLen, ret[1]);
        maxVal[0] = Math.max(maxVal[0], ret[0]);
        maxVal[0] = Math.max(maxVal[0], ret[1]);

        return ret;
    }
}

转 http://blog.sina.com.cn/s/blog_eb52001d0102v1si.html

顶: 0

踩: 0

我的同类文章

数据结构（6） 算法（18）

http://blog.csdn.net

•二叉树的常见问题及其解决程序2014-09-29阅读775
•list和vector有什么区别？2014-08-07阅读445
•教你透彻了解红黑树2014-08-02阅读564

•hash_set哈希集合容器2014-08-11阅读510
•经典面试题:设计包含min函数的栈,O(1)空间实现方法2014-08-07阅读416
•找工作知识储备(3)---从头说12种排序算法：原理、图解、动画视频演示、代码以及笔试面试题目中的应用2014-07-27阅读3186

你可能感兴趣的:(算法和数据结构)

Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
【ShuQiHere】深入浅出栈（Stack）数据结构：从基本操作到实现 ShuQiHere 数据结构 java 算法
【ShuQiHere】引言在计算机科学中，栈（Stack）是一种极为常见的抽象数据类型（AbstractDataType,ADT），它在表达式求值、递归调用、内存管理等领域得到了广泛应用。栈是一种遵循**后进先出（LastInFirstOut,LIFO）**原则的数据结构，这意味着最后进入栈的元素会最先被取出。理解栈的工作原理，是学习更多复杂算法和数据结构的基础。这就好比你在往一个箱子里放东西，最
【译】Swift算法俱乐部-布隆过滤器 Andy_Ron
Swift算法俱乐部本文是对SwiftAlgorithmClub翻译的一篇文章。SwiftAlgorithmClub是raywenderlich.com网站出品的用Swift实现算法和数据结构的开源项目，目前在GitHub上有18000+⭐️，我初略统计了一下，大概有一百左右个的算法和数据结构，基本上常见的都包含了，是iOSer学习算法和数据结构不错的资源。andyRon/swift-algori
C语言编程学习中，全局变量与局部变量同名时，如何判断小辰带你看世界
C语言是面向过程的，而C＋＋是面向对象的C和C++的区别：C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制）。C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。所以C与C++的最大区别在于它们的用于解决
自学数据结构的网站花开盛夏^.^ 数据结构数据结构
自学数据结构的网站有很多，以下是一些推荐的高质量和受欢迎的网站：LeetCode描述：LeetCode是一个知名的在线编程训练平台，特别适合算法和数据结构的学习与练习。它提供了大量的编程题目，涵盖了从简单到困难的各个难度级别，帮助用户逐步掌握算法和数据结构。网址：https://leetcode.com/（英文）或LeetCode中文版visualgo描述：visualgo是一个由新加坡国立大学开
C语言/C++程序员大神打造炫酷的黑客帝国数字雨小辰带你看世界
C语言是面向过程的，而C＋＋是面向对象的C和C++的区别：C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制）。C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。所以C与C++的最大区别在于它们的用于解决
C++ STL JianminZheng C++学习笔记 c++开发语言
C++的STL（StandardTemplateLibrary，标准模板库）是一套由模板类和模板函数组成的库，它提供了通用的、可重用的算法和数据结构。STL是C++标准库的一部分，它在C++程序设计中扮演着重要的角色，因为它提供了一种高效、一致且类型安全的方式来处理数据集合。在C++的标准模板库（STL）中，通常提到以下六大组件，它们共同构成了STL的核心功能容器（Containers）：用于存储
C语言算法：求逆序对数量 Farrol 算法 c语言数据结构
一、关于逆序对：逆序对是一个数学术语，如果在一个有n个数字的有序集(n＞1)中，存在正整数i,j使得1≤iA[j]，则这个有序对就称为A的一个逆序对，也被称作逆序数。简单理解一下：假如本来这个数列是单调递增的，突然出来了一对不和谐的，它非要皮一下，两个数调换一下位置。那么这个不和谐的数对就叫做逆序对。在计算机科学中，特别是在算法和数据结构领域，逆序对的概念被广泛应用。例如，在归并排序过程中，如果出
算法的学习笔记—数组中出现次数超过一半的数字(牛客JZ39) 尘觉 #算法分析算法学习笔记数据库数据结构
前言在算法和数据结构领域，找到数组中出现次数超过一半的数字是一个经典问题。这种问题在实际应用中也有广泛的使用场景，例如投票系统、数据分析等。今天，我们将探讨一种高效的解决方法——Boyer-Moore多数投票算法。个人主页：尘觉主页文章目录数组中出现次数超过一半的数字问题描述约束条件示例示例1示例2示例3解题思路Boyer-Moore多数投票算法算法的正确性分析代码实现代码注释解释总结数组中出现次
c++的时间复杂度文宇炽筱 c++教程 c++算法数据结构
前言Hello,大家好我是文宇.最近没怎么写文章了,写个教程吧.正文C++是一种高级编程语言，用于开发各种类型的应用程序，包括计算机科学中的算法和数据结构。在编写代码时，了解算法和数据结构的时间复杂度非常重要，因为它可以帮助我们估计程序的执行效率和资源利用情况。在本文中，我们将详细解释C++中常用算法和数据结构的时间复杂度。时间复杂度是用来衡量算法执行时间与输入规模之间关系的指标。它通常用大O符号
【算法基础实验】排序-最小索引优先队列IndexMinPQ Greyplayground 算法
回顾最小优先队列MinPQ理论知识概述在算法和数据结构中，优先队列是一种特殊的队列数据结构，每个元素都有一个优先级。当你从优先队列中删除元素时，通常会删除具有最高（或最低）优先级的元素。在最小优先队列中，优先级最低的元素最先被删除。索引最小优先队列是优先队列的一种变体，允许你通过索引（或键）快速地更新、插入、删除和访问最小元素。它的典型应用包括网络流、图算法（如Dijkstra最短路径算法）等。基
模板（函数模板）---C++ 木子.李347 c++开发语言 visual studio
模板目录模板1.模板概念２.泛型编程1.函数模板1.1函数模板语法1.2函数模板注意事项1.3普通函数与函数模板的区别1.4普通函数与函数模板的调用规则1.5模板的局限性1.6函数模板案例模板1.模板概念模板就是建立通用的模具，大大提高复用性。模板的特点：模板不可以直接使用，它只是一个框架;模板的通用并不是万能的.２.泛型编程泛型编程是一种编程风格，它允许算法和数据结构在不被具体类型限制的情况下编
单片机编程的艺术：如何优化代码提升性能迷璃学妹单片机嵌入式硬件
单片机编程是一门艺术，通过优化代码可以提升性能，提高系统的效率和响应速度。以下是关于如何优化代码以提升性能的几个小点：1.选择合适的算法和数据结构：在编程时，选择合适的算法和数据结构是非常重要的。合适的算法可以减少计算量，提高代码的执行效率。例如，对于需要频繁查找和插入操作的情况，选择合适的数据结构（如哈希表、二叉搜索树）可以提高性能。2.减少内存占用：单片机的内存资源有限，因此在编程时需要尽量减
ACM/NOI/CSP比赛经验分享琛哥的程序学习方法
ACM/NOI/CSP比赛经验分享一、引言在信息学竞赛的舞台上，ACM/ICPC、NOI和CSP是众多学子梦寐以求的赛事。这些比赛不仅考验了参赛者的算法和数据结构知识，更是对团队协作、时间管理和心理素质的全面挑战。作为一名曾经参与过这些比赛的选手，我深感其中的酸甜苦辣，也积累了一些宝贵的经验。在此，我愿与大家分享这些经验，希望能对后来的学子有所帮助。二、准备阶段知识储备：在准备阶段，我们需要系统地
软件工程大学规划码农一指软件工程
大学四年规划是一个重要的步骤，以确保你在本科结束时具备强大的专业能力和职业竞争力。是一个较为完整的四年规划框架：第一年：1.核心课程：完成软件工程专业的基础核心课程，建立坚实的理论基础。2.项目参与：参与校内项目或实践课程，锻炼实际问题解决能力。3.技术掌握：学习一门编程语言深入，例如Java、Python等，掌握基本的算法和数据结构。4.网络：构建人脉，加入校内技术社团，参与相关活动。第二年：1
程序猿们这段C语言代码你觉得怎么样？小辰带你看世界
C语言是面向过程的，而C＋＋是面向对象的C和C++的区别：C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制）。C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。所以C与C++的最大区别在于它们的用于解决
力扣刷题之旅：高级篇（六）—— 网络流算法：Edmonds-Karp 算法与实际应用 GT开发算法工程师算法 leetcode 职场和发展 python 数据结构 bfs
力扣（LeetCode）是一个在线编程平台，主要用于帮助程序员提升算法和数据结构方面的能力。以下是一些力扣上的入门题目，以及它们的解题代码。--点击进入刷题地址引言在算法的世界中，网络流算法是一种非常强大且实用的工具，它能够帮助我们解决许多复杂的问题，如资源分配、路径优化等。Edmonds-Karp算法是其中的一种，它基于增广路径的概念来寻找网络中的最大流。一、Edmonds-Karp算法简介Ed
力扣刷题之旅：高阶篇（五）—— 网络流算法：最大流与最小割 GT开发算法工程师 leetcode 算法职场和发展开发语言 python bfs
力扣（LeetCode）是一个在线编程平台，主要用于帮助程序员提升算法和数据结构方面的能力。以下是一些力扣上的入门题目，以及它们的解题代码。--点击进入刷题地址引言在算法领域中，网络流算法是一个重要且实用的工具，尤其在处理资源分配、运输优化等问题上表现出色。最大流和最小割是网络流算法中的两个核心概念，它们在很多实际应用中都有着广泛的使用。一、最大流与最小割的基本概念在一个有向图中，如果存在一个源点
C语言编程新手入门基础学习：使用函数必须知道的3点注意事项小辰带你看世界
C语言是面向过程的，而C＋＋是面向对象的C和C++的区别：C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制）。C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。所以C与C++的最大区别在于它们的用于解决
C语言编程新手入门基础学习字符串操作总结超精细快收藏小辰带你看世界
C语言是面向过程的，而C＋＋是面向对象的C和C++的区别：C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制）。C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。所以C与C++的最大区别在于它们的用于解决
力扣刷题之旅：高阶篇（四）—— 最小生成树算法 GT开发算法工程师算法 leetcode 图论 python 数据结构职场和发展
力扣（LeetCode）是一个在线编程平台，主要用于帮助程序员提升算法和数据结构方面的能力。以下是一些力扣上的入门题目，以及它们的解题代码。引言：在算法领域中，图论是一个重要且有趣的分支，而最小生成树问题则是图论中的一个经典问题。最小生成树算法用于在一个连通的加权无向图中找到一棵边权值之和最小的生成树。在实际应用中，最小生成树算法常用于网络设计、电路设计等领域。一、最小生成树算法简介最小生成树算法
力扣刷题之旅：高阶篇（一）—— 并查集的应用 GT开发算法工程师 leetcode 算法职场和发展数据结构 python 动态规划
力扣（LeetCode）是一个在线编程平台，主要用于帮助程序员提升算法和数据结构方面的能力。以下是一些力扣上的入门题目，以及它们的解题代码。--点击进入刷题地址引言在算法的世界中，并查集是一种非常高效且实用的数据结构，常用于处理一些具有连通性质的问题。在力扣（LeetCode）上，并查集的题目往往涉及到图的连通性、朋友关系的传递性等问题。今天，我们将一起探讨一道关于并查集的高阶题目：“账户合并”。
力扣刷题之旅：高阶篇（三）—— 图算法的挑战 GT开发算法工程师 leetcode python 哈希算法 dfs 算法
力扣（LeetCode）是一个在线编程平台，主要用于帮助程序员提升算法和数据结构方面的能力。以下是一些力扣上的入门题目，以及它们的解题代码。--点击进入刷题地址引言在算法世界的深处，图算法犹如一座高峰，等待着勇者的攀登。在力扣（LeetCode）平台上，图算法题目以其独特的复杂性和挑战性，吸引了无数算法爱好者的目光。今天，我们将一起探讨图算法的魅力，并通过一道题目来体验其深度。一、图算法简介图算法
力扣刷题之旅：高阶篇（二）—— 动态规划的艺术：背包问题 GT开发算法工程师 leetcode 动态规划算法 python 数据结构职场和发展
力扣（LeetCode）是一个在线编程平台，主要用于帮助程序员提升算法和数据结构方面的能力。以下是一些力扣上的入门题目，以及它们的解题代码。--点击进入刷题地址引言---在算法设计的殿堂中，动态规划无疑是一颗璀璨的明珠。它用巧妙的状态转移思想解决了许多看似棘手的问题。而在力扣（LeetCode）这样的在线刷题平台上，背包问题作为动态规划的经典题型，更是吸引了无数算法爱好者的目光。一、0/1背包问题
前端面试题——二叉树遍历 _Minato_ 算法
前言二叉树遍历在各种算法和数据结构问题中都有广泛的应用，如二叉搜索树、表达式的树形表示、堆的实现等。同时也是前端面试中的常客，掌握好二叉树遍历算法对于一名合格的前端工程师来说至关重要。概念二叉树遍历（BinaryTreeTraversal）是指按照某种规则访问二叉树中所有节点的过程。由于二叉树是一个递归的数据结构，因此遍历操作通常也是递归进行的。二叉树的遍历主要有四种方式：前序遍历（Pre-ord
【算法与数据结构】算法与数据结构知识点晚安66 算法算法
文章目录一、算法和数据结构和LeetCode介绍二、算法和数据结构入门2.1时间复杂度2.2空间复杂度2.3基础排序算法2.3.1选择排序算法2.3.2冒泡排序算法三、数组3.1二分法查找法3.2双指针法四、链表理论五、哈希表理论五、栈和队列理论5.1单调栈六、二叉树理论6.1树的定义6.2二叉树的存储方式6.3二叉树的遍历方式6.4高度和深度七、回溯算法八、贪心算法九、动态规划9.1背包问题9.
【算法与数据结构】42、LeetCode接雨水晚安66 算法算法
文章目录一、题目二、解法三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、题目二、解法思路分析：程序如下：复杂度分析：时间复杂度：O()O()O()。空间复杂度：O()O()O()。三、完整代码end
【算法与数据结构】496、503、LeetCode下一个更大元素I II 晚安66 算法算法
文章目录一、496、下一个更大元素I二、503、下一个更大元素II三、完整代码所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。一、496、下一个更大元素I 思路分析：本题思路和【算法与数据结构】739、LeetCode每日温度类似。如果用暴力破解法时间复杂度需要O(m∗n)O(m*n)O(m∗n)，其中mmm和nnn分别是两个数组的长度。单调栈只需要O(
Java蓝桥杯备考---4.算法基础(二) 不要再睡蓝桥杯算法职场和发展
1.离散化把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。离散化是一种将数组的值域压缩，从而更加关注元素的大小关系的算法。当原数组中的数字很大、负数、小数时(大多数情况下是数字很大)，难以将“元素值”表示为“数组下标”，一些依靠下标实现的算法和数据结构无法实现时，我们就可以考虑将其离散化。例如原数组的范围是[1，le9]，而数组大小仅为le5，那么说明元素值的“种类数”最多也就
力扣刷题之旅：进阶篇（六）—— 图论与最短路径问题 GT开发算法工程师 leetcode 图论算法数据结构 python 深度学习
力扣（LeetCode）是一个在线编程平台，主要用于帮助程序员提升算法和数据结构方面的能力。以下是一些力扣上的入门题目，以及它们的解题代码。--点击进入刷题地址引言在算法的广阔天地中，图论是一个非常重要的领域。图论问题常常涉及到节点之间的连接关系和路径问题，而最短路径问题则是其中的经典之一。今天，我们就来一起探索一道关于图论与最短路径的经典题目：“单源最短路径问题”。题目描述：给定一个带权有向图，
eclipse maven IXHONG eclipse
eclipse中使用maven插件的时候，运行run as maven build的时候报错 -Dmaven.multiModuleProjectDirectory system propery is not set. Check $M2_HOME environment variable and mvn script match. 可以设一个环境变量M2_HOME指
timer cancel方法的一个小实例 alleni123 多线程 timer
package com.lj.timer; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class MyTimer extends TimerTask { private int a; private Timer timer; pub
MySQL数据库在Linux下的安装 ducklsl mysql
1.建好一个专门放置MySQL的目录 /mysql/db数据库目录 /mysql/data数据库数据文件目录 2.配置用户，添加专门的MySQL管理用户 >groupadd mysql ----添加用户组 >useradd -g mysql mysql ----在mysql用户组中添加一个mysql用户 3.配置，生成并安装MySQL >cmake -D
spring------>>cvc-elt.1: Cannot find the declaration of element Array_06 spring bean
将-------- <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3
maven发布第三方jar的一些问题 cugfy maven
maven中发布第三方jar到nexus仓库使用的是 deploy:deploy-file命令有许多参数，具体可查看 http://maven.apache.org/plugins/maven-deploy-plugin/deploy-file-mojo.html 以下是一个例子： mvn deploy:deploy-file -DgroupId=xpp3
MYSQL下载及安装 357029540 mysql
好久没有去安装过MYSQL，今天自己在安装完MYSQL过后用navicat for mysql去厕测试链接的时候出现了10061的问题，因为的的MYSQL是最新版本为5.6.24，所以下载的文件夹里没有my.ini文件，所以在网上找了很多方法还是没有找到怎么解决问题，最后看到了一篇百度经验里有这个的介绍，按照其步骤也完成了安装，在这里给大家分享下这个链接的地址
ios TableView cell的布局张亚雄 tableview
cell.imageView.image = [UIImage imageNamed:[imageArray objectAtIndex:[indexPath row]]]; CGSize itemSize = CGSizeMake(60, 50); &nbs
Java编码转义 adminjun java 编码转义
import java.io.UnsupportedEncodingException; /** * 转换字符串的编码 */ public class ChangeCharset { /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */ public static final Strin
Tomcat 配置和spring aijuans spring
简介 Tomcat启动时，先找系统变量CATALINA_BASE，如果没有，则找CATALINA_HOME。然后找这个变量所指的目录下的conf文件夹，从中读取配置文件。最重要的配置文件：server.xml 。要配置tomcat，基本上了解server.xml，context.xml和web.xml。 Server.xml -- tomcat主
Java打印当前目录下的所有子目录和文件 ayaoxinchao 递归 File
其实这个没啥技术含量，大湿们不要操笑哦，只是做一个简单的记录，简单用了一下递归算法。 import java.io.File; /** * @author Perlin * @date 2014-6-30 */ public class PrintDirectory { public static void printDirectory(File f
linux安装mysql出现libs报冲突解决 BigBird2012 linux
linux安装mysql出现libs报冲突解决安装mysql出现 file /usr/share/mysql/ukrainian/errmsg.sys from install of MySQL-server-5.5.33-1.linux2.6.i386 conflicts with file from package mysql-libs-5.1.61-4.el6.i686
jedis连接池使用实例 bijian1013 redis jedis连接池 jedis
实例代码： package com.bijian.study; import java.util.ArrayList; import java.util.List; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoo
关于朋友 bingyingao 朋友兴趣爱好维持
成为朋友的必要条件：志相同，道不合，可以成为朋友。譬如马云、周星驰一个是商人，一个是影星，可谓道不同，但都很有梦想，都要在各自领域里做到最好，当他们遇到一起，互相欣赏，可以畅谈两个小时。志不同，道相合，也可以成为朋友。譬如有时候看到两个一个成绩很好每次考试争做第一，一个成绩很差的同学是好朋友。他们志向不相同，但他
【Spark七十九】Spark RDD API一 bit1129 spark
aggregate package spark.examples.rddapi import org.apache.spark.{SparkConf, SparkContext} //测试RDD的aggregate方法 object AggregateTest { def main(args: Array[String]) { val conf = new Spar
ktap 0.1 released bookjovi kernel tracing
Dear, I'm pleased to announce that ktap release v0.1, this is the first official release of ktap project, it is expected that this release is not fully functional or very stable and we welcome bu
能保存Properties文件注释的Properties工具类 BrokenDreams properties
今天遇到一个小需求：由于java.util.Properties读取属性文件时会忽略注释，当写回去的时候，注释都没了。恰好一个项目中的配置文件会在部署后被某个Java程序修改一下，但修改了之后注释全没了，可能会给以后的参数调整带来困难。所以要解决这个问题。 &nb
读《研磨设计模式》-代码笔记-外观模式-Facade bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* * 百度百科的定义： * Facade（外观）模式为子系统中的各类（或结构与方法）提供一个简明一致的界面， * 隐藏子系统的复杂性，使子系统更加容易使用。他是为子系统中的一组接口所提供的一个一致的界面 * * 可简单地
After Effects教程收集 cherishLC After Effects
1、中文入门 http://study.163.com/course/courseMain.htm?courseId=730009 2、videocopilot英文入门教程（中文字幕） http://www.youku.com/playlist_show/id_17893193.html 英文原址： http://www.videocopilot.net/basic/ 素
Linux Apache 安装过程 crabdave apache
Linux Apache 安装过程下载新版本： apr-1.4.2.tar.gz（下载网站：http://apr.apache.org/download.cgi） apr-util-1.3.9.tar.gz（下载网站：http://apr.apache.org/download.cgi） httpd-2.2.15.tar.gz（下载网站：http://httpd.apac
Shell学习之变量赋值和引用 daizj shell 变量引用赋值
本文转自：http://www.cnblogs.com/papam/articles/1548679.html Shell编程中，使用变量无需事先声明，同时变量名的命名须遵循如下规则：首个字符必须为字母（a-z，A-Z）中间不能有空格，可以使用下划线（_）不能使用标点符号不能使用bash里的关键字（可用help命令查看保留关键字）需要给变量赋值时，可以这么写：
Java SE 第一讲（Java SE入门、JDK的下载与安装、第一个Java程序、Java程序的编译与执行） dcj3sjt126com java jdk
Java SE 第一讲： Java SE：Java Standard Edition Java ME: Java Mobile Edition Java EE：Java Enterprise Edition Java是由Sun公司推出的（今年初被Oracle公司收购）。收购价格：74亿美金 J2SE、J2ME、J2EE JDK：Java Development
YII给用户登录加上验证码 dcj3sjt126com yii
1、在SiteController中添加如下代码： /** * Declares class-based actions. */ public function actions() { return array( // captcha action renders the CAPTCHA image displ
Lucene使用说明 dyy_gusi Lucene search 分词器
Lucene使用说明 1、lucene简介 1.1、什么是lucene Lucene是一个全文搜索框架，而不是应用产品。因此它并不像baidu或者googleDesktop那种拿来就能用，它只是提供了一种工具让你能实现这些产品和功能。 1.2、lucene能做什么要回答这个问题，先要了解lucene的本质。实际
学习编程并不难,做到以下几点即可! gcq511120594 数据结构编程算法
不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发各种神奇的软件啦。 1、确定目标学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
Java面试十问之三：Java与C++内存回收机制的差别 HNUlanwei java C++finalize()堆栈内存回收
大家知道， Java 除了那 8 种基本类型以外，其他都是对象类型（又称为引用类型）的数据。 JVM 会把程序创建的对象存放在堆空间中，那什么又是堆空间呢？其实，堆（ Heap）是一个运行时的数据存储区，从它可以分配大小各异的空间。一般，运行时的数据存储区有堆（ Heap）和堆栈（ Stack），所以要先看它们里面可以分配哪些类型的对象实体，然后才知道如何均衡使用这两种存储区。一般来说，栈中存放的
第二章 Nginx+Lua开发入门 jinnianshilongnian nginx lua
Nginx入门本文目的是学习Nginx+Lua开发，对于Nginx基本知识可以参考如下文章： nginx启动、关闭、重启 http://www.cnblogs.com/derekchen/archive/2011/02/17/1957209.html agentzh 的 Nginx 教程 http://openresty.org/download/agentzh-nginx-tutor
MongoDB windows安装基本命令 liyonghui160com
windows安装安装目录： D:\MongoDB\ 新建目录 D:\MongoDB\data\db 4.启动进城： cd D:\MongoDB\bin mongod -dbpath D:\MongoDB\data\db &n
Linux下通过源码编译安装程序 pda158 linux
一、程序的组成部分　　Linux下程序大都是由以下几部分组成：　　二进制文件：也就是可以运行的程序文件　　库文件：就是通常我们见到的lib目录下的文件　　配置文件：这个不必多说，都知道　　帮助文档：通常是我们在linux下用man命令查看的命令的文档　　二、linux下程序的存放目录　　linux程序的存放目录大致有三个地方：　　/etc, /b
WEB开发编程的职业生涯４个阶段 shw3588 编程 Web 工作生活
觉得自己什么都会 2007年从学校毕业，凭借自己原创的ASP毕业设计，以为自己很厉害似的，信心满满去东莞找工作，找面试成功率确实很高，只是工资不高，但依旧无法磨灭那过分的自信，那时候什么考勤系统、什么OA系统、什么ERP，什么都觉得有信心，这样的生涯大概持续了约一年。根本不是自己想的那样 2008年开始接触很多工作相关的东西，发现太多东西自己根本不会，都需要去学，不管是asp还是js，
遭遇jsonp同域下变作post请求的坑 vb2005xu jsonp 同域post
今天迁移一个站点时遇到一个坑爹问题,同一个jsonp接口在跨域时都能调用成功,但是在同域下调用虽然成功,但是数据却有问题. 此处贴出我的后端代码片段 $mi_id = htmlspecialchars(trim($_GET['mi_id '])); $mi_cv = htmlspecialchars(trim($_GET['mi_cv '])); 贴出我前端代码片段: $.aj