链表算法

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;
    }
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
}