http://www.jianshu.com/p/0190985635eb
package com.jiangshuai.test;
import java.util.ArrayList;
import java.util.Stack;
public class Tree {
private class TreeNode{
TreeNode left;
TreeNode right;
int value;
}
//求最大深度
private int maxDepth(TreeNode node){
if(node == null){
return 0;
}
int left = maxDepth(node.left);
int right = maxDepth(node.right);
return Math.max(left, right)+1;
}
//求二叉树最小深度
private int getMinDepth(TreeNode root){
if(root == null){
return 0;
}
if(root.left == null && root.right == null){
return 1;
}
return Math.min(getMinDepth(root.left), getMinDepth(root.right))+1;
}
//求二叉树节点个数
private int numOfNode(TreeNode root){
if(root == null){
return 0;
}
int left = numOfNode(root.left);
int right = numOfNode(root.right);
return left+right+1;
}
//求二叉第k层节点的个数
private int numOfK(TreeNode root,int k){
if(root == null || k<1){
return 0;
}
if(k == 1){
return 1;
}
int numLeft = numOfK(root.left, k-1);
int numRight = numOfK(root.right, k-1);
return numLeft + numRight;
}
//判断二叉树是否是平衡二叉树
private boolean isBalanced(TreeNode root){
return maxDepthF(root) != -1;
}
private int maxDepthF(TreeNode root){
if(root == null){
return 0;
}
int left = maxDepthF(root.left);
int right = maxDepthF(root.right);
if(left == -1 || right == -1 || Math.abs(left - right) > 0){
return -1;
}
return Math.max(left, right)+1;
}
//判断两个二叉树是否完全相同
private boolean isSame(TreeNode root1,TreeNode root2){
if(root1 == null && root2 == null){
return true;
}else if(root1 == null || root2 == null){
return false;
}
if(root1.value != root2.value){
return false;
}
return isSame(root1.left,root2.left) &&
isSame(root2.left,root2.right);
}
//是否互为镜像二叉树
private boolean isMirror(TreeNode root1,TreeNode root2){
if(root1 == null && root2 ==null){
return true;
}else if(root1 == null || root2 == null){
return false;
}
return isMirror(root1.left, root2.right) &&
isMirror(root1.right, root2.left);
}
//翻转二叉树
TreeNode mirrorTreeNode(TreeNode root){
if(root == null){
return null;
}
TreeNode left = mirrorTreeNode(root.left);
TreeNode right = mirrorTreeNode(root.right);
root.left = right;
root.right = left;
return root;
}
//二叉树的前序遍历
private ArrayList<Integer> preOrder(TreeNode root){
//新建一个栈 stack
Stack<TreeNode> stack = new Stack<TreeNode>();
//新建一个ArrayList 用来输出
ArrayList<Integer> list = new ArrayList<Integer>();
if(root == null){
return list;
}
stack.push(root);
while(!stack.empty()){
TreeNode node = stack.pop();
//根
list.add(node.value);
if(root.right != null){
//右
stack.push(root.right);
}
if(root.left != null){
//左
stack.push(root.left);
}
}
return list;
}
//前序遍历和后续遍历构造二叉树
TreeNode buildTreeNode(int[] preorder,int[] inorder){
if(preorder.length!=inorder.length){
return null;
}
return myBuildTree(inorder,0,inorder.length-1,preorder,0,preorder.length-1);
}
TreeNode myBuildTree(int[] inorder,int instart,int inend,int[] preorder,int prestart,int preend){
if(instart>inend){
return null;
}
TreeNode root = new TreeNode(preorder[prestart]);
int position = findPosition(inorder,instart,inend,preorder[start]);
root.left = myBuildTree(inorder,instart,position-1,preorder,prestart+1,prestart+position-instart);
root.right = myBuildTree(inorder,position+1,inend,preorder,position-inend+preend+1,preend);
return root;
}
int findPosition(int[] arr,int start,int end,int key){
int i;
for(i = start;i<=end;i++){
if(arr[i] == key){
return i;
}
}
return -1;
}
}