二叉树相关

有一棵二叉树，请设计一个算法，按照层次打印这棵二叉树。

给定二叉树的根结点root，请返回打印结果，结果按照每一层一个数组进行储存，所有数组的顺序按照层数从上往下，且每一层的数组内元素按照从左往右排列。保证结点数小于等于500。

public class TreeNode {
	int val = 0;
	TreeNode left = null;
	TreeNode right = null;
	public TreeNode(int val){
		this.val = val;
	}
}
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class TreePrinter {
	public static int[][] printTree(TreeNode root){
		TreeNode last;			//指向当前节点
		TreeNode nlast;			//指向当前节点下一行的最后一个节点
		last = root;
		nlast = last;
		Queue<TreeNode> que = new LinkedList<TreeNode>();
		que.offer(root);
	
		ArrayList<ArrayList<Integer>> store = new ArrayList<ArrayList<Integer>>();
		store.add(new ArrayList<Integer>());
		int hight = 0;
		while(!que.isEmpty()){
			TreeNode out = que.poll();
			//System.out.print(out.val+" ");
			store.get(hight).add(out.val);
			
			
			if(out.left!=null){
				que.offer(out.left);
				nlast = out.left;
			}
			
			if(out.right!=null){
				que.offer(out.right);
				nlast = out.right;
			}
			
			if(out==last){
				//System.out.println();
				last = nlast;
				hight++;
				store.add(new ArrayList<Integer>());
			}
		}
		int[][] show = new int[hight][];
		for(int i = 0;i < store.size()-1; i++){
			ArrayList<Integer> temp = store.get(i);
			System.out.println("size: "+temp.size());
			show[i] = new int[temp.size()];
			for(int j = 0;j < temp.size(); j++){
				show[i][j] = temp.get(j);
				System.out.print(temp.get(j)+" ");
			}
			System.out.println();
		}
		return show;
	}
	public static void main(String[] args) {
		TreeNode root = new TreeNode(1);
		root.left = new TreeNode(2);
		root.left.right = new TreeNode(3);
		root.left.right.left = new TreeNode(4);
		root.left.right.right = new TreeNode(5);
		
		int[][] result = printTree(root);
		
	}
}

　　

请用递归方式实现二叉树的先序、中序和后序的遍历打印。

给定一个二叉树的根结点root，请依次返回二叉树的先序，中序和后续遍历(二维数组的形式)。

	public void FirstSearch(TreeNode cur,ArrayList list){
		if(cur==null)
			return ;
		list.add(cur.val);
		FirstSearch(cur.left,list);
		FirstSearch(cur.right,list);
	}
	public void MiddleSearch(TreeNode cur,ArrayList list){
		if(cur==null)
			return ;
		MiddleSearch(cur.left,list);
		list.add(cur.val);
		MiddleSearch(cur.right,list);
	}
	public void LastSearch(TreeNode cur,ArrayList list){
		if(cur==null)
			return ;
		LastSearch(cur.left,list);
		LastSearch(cur.right,list);
		list.add(cur.val);
	}
	public int[][] convert(TreeNode root) {
        // write code here
		ArrayList<Integer> nodeList = new ArrayList<Integer>();
		FirstSearch(root,nodeList);
		int[][] result = new int[3][nodeList.size()];
		for(int i = 0;i < nodeList.size(); i++)
			result[0][i] = nodeList.get(i);
		nodeList.clear();
		
		MiddleSearch(root,nodeList);
		for(int i = 0;i < nodeList.size(); i++)
			result[1][i] = nodeList.get(i);
		nodeList.clear();
		
		LastSearch(root,nodeList);
		for(int i = 0;i < nodeList.size(); i++)
			result[2][i] = nodeList.get(i);
		nodeList.clear();
		
		return result;
	}

　　

首先我们介绍二叉树先序序列化的方式，假设序列化的结果字符串为str，初始时str等于空字符串。先序遍历二叉树，如果遇到空节点，就在str的末尾加上“#!”，“#”表示这个节点为空，节点值不存在，当然你也可以用其他的特殊字符，“!”表示一个值的结束。如果遇到不为空的节点，假设节点值为3，就在str的末尾加上“3!”。现在请你实现树的先序序列化。

给定树的根结点root，请返回二叉树序列化后的字符串。

	public void FristSearch(TreeNode cur,StringBuffer sb){
		if(cur==null){
			sb.append("#!");
			return ;
		}
		sb.append(cur.val+"!");
		FristSearch(cur.left,sb);
		FristSearch(cur.right,sb);
	}
	public String toString(TreeNode root) {
	        // write code here
		StringBuffer sb = new StringBuffer();
		FristSearch(root,sb);
		return sb.toString();
	}

　　

有一棵二叉树，请设计一个算法判断这棵二叉树是否为平衡二叉树。

给定二叉树的根结点root，请返回一个bool值，代表这棵树是否为平衡二叉树。

class TreeNode {
	int val = 0;
	TreeNode left = null;
	TreeNode right = null;
	public TreeNode(int val) {
		this.val = val;
	}
}

  
 public int Search(TreeNode cur,int level,boolean[] result){
    	if(cur==null)
    		return level;
    	if(!result[0])
    		return level;
    	int lH = Search(cur.left,level+1,result);
    	if(!result[0])
    		return level;
    	int rH = Search(cur.right,level+1,result);
    	
    	if(Math.abs(lH-rH)>1)
    		result[0] = false;
    	return Math.max(lH, rH);
    }
    public boolean check(TreeNode root) {
        // write code here
    	boolean[] result = new boolean[1];
    	result[0] = true;
    	Search(root,1,result);
    	return result[0];
    }

　　解法2

import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class CheckBalance {
     public static boolean check(TreeNode root){
        return chk(root)>=0;
    }

    private static int chk(TreeNode root) {
        if (root==null) return 0;
        int l=chk(root.left),r=chk(root.right);//左右两边深度
        if (l<0||r<0) return -1;
        if ((Math.abs(r-l)>1))return -1;//当左右两边深度差超过1时 返回-1
        return r>l?r+1:l+1;
    }
}

　　

一棵二叉树原本是搜索二叉树，但是其中有两个节点调换了位置，使得这棵二叉树不再是搜索二叉树，请找到这两个错误节点并返回他们的值。保证二叉树中结点的值各不相同。

给定一棵树的根结点，请返回两个调换了位置的值，其中小的值在前。

核心代码：

public int[] findError(TreeNode root) {
        // write code here
        int res[]=new int[2];
        TreeNode err[]=new TreeNode[2];
        Stack<TreeNode> st=new Stack<TreeNode>();
        TreeNode pre=null;
      while(!st.isEmpty()||root!=null){
          if(root!=null){
              st.push(root);
              root=root.left;
          }else{
              root=st.pop();
              if(pre!=null&&pre.val>root.val){
                  err[0]=err[0]==null?pre:err[0];
                  err[1]=root;
              }
              pre=root;
              root=root.right;
          }
           
      }
        res[1]=err[0].val;
        res[0]=err[1].val;
        return res;
    }

解法二:

public class FindErrorNode {
     public int[] findError(TreeNode root) {
        // write code here
    	ArrayList<Integer> list = new ArrayList<Integer>();
    	int[] result = new int[2];
    	LastSearch(root,list);
    	int count = 0;
    	for(int i = 0;i < list.size()-1; i++)
    		if(list.get(i)>list.get(i+1)){
    				result[1] = list.get(i+1);
    			if(count==0){
    				result[0] = list.get(i);
    				//result[1] = list.get(i+1)
    			}
            	count++;
    		}
    		result[0] = result[0]^result[1];
    		result[1] = result[0]^result[1];
    		result[0] = result[0]^result[1];

    	return result;
    }
    private void LastSearch(TreeNode cur,List list){
    	if(cur==null){
    		return ;
    	}
    	LastSearch(cur.left,list);
    	list.add(cur.val);
        LastSearch(cur.right,list);
    }
}

　　

请用非递归方式实现二叉树的先序、中序和后序的遍历打印。

给定一个二叉树的根结点root，请依次返回二叉树的先序，中序和后续遍历(二维数组的形式)。

package com.oj;

import java.util.ArrayList;
import java.util.Stack;

class TreeNode {
	int val = 0;
	TreeNode left = null;
	TreeNode right = null;
	public TreeNode(int val) {
		this.val = val;
	}
}
public class TreeSearch {
	public void PreSearch(TreeNode root,ArrayList<Integer> list){
		Stack stack = new Stack();
		stack.push(root);
		while(!stack.isEmpty()){
			TreeNode temp = (TreeNode) stack.pop();
			list.add(temp.val);
			if(temp.right!=null)
				stack.push(temp.right);
			if(temp.left!=null)
				stack.push(temp.left);
		}
	}
	public void MidSearch(TreeNode root,ArrayList<Integer> list){
		Stack stack = new Stack();
		TreeNode cur = root;
		stack.push(cur);
		cur = cur.left;
		while(!stack.isEmpty()||cur!=null){
			if(cur!=null){
				stack.push(cur);
				cur = cur.left;
			}else{
				cur = (TreeNode) stack.pop();
				list.add(cur.val);
				cur = cur.right;
			}
		}
	}
	
	public void LastSearch(TreeNode root,ArrayList<Integer> list){
		Stack s1 = new Stack();
		Stack s2 = new Stack();
		TreeNode cur = root;
		s1.push(cur);
		while(!s1.isEmpty()){
			cur = (TreeNode) s1.pop();
			s2.push(cur);
			if(cur.left!=null){
				s1.push(cur.left);
			}
			if(cur.right!=null){
				s1.push(cur.right);
			}
		}
		while(!s2.isEmpty()){
			TreeNode temp = (TreeNode) s2.pop();
			list.add(temp.val);
		}
	}
	
	public int[][] convert(TreeNode root) {
	        // write code here
		int[][] result = new int[3][];
		ArrayList<Integer> list = new ArrayList<Integer>();
		PreSearch(root,list);
		result[0] = new int[list.size()];
		for(int i = 0;i < list.size(); i++){
			result[0][i] = list.get(i);
		}
		list.clear();
		
		MidSearch(root,list);
		result[1] = new int[list.size()];
		for(int i = 0;i < list.size(); i++){
			result[1][i] = list.get(i);
		}
		list.clear();
		
		LastSearch(root,list);
		result[2] = new int[list.size()];
		for(int i = 0;i < list.size(); i++){
			result[2][i] = list.get(i);
		}
		
		return result;
    }
	
}

　　

从二叉树的节点A出发，可以向上或者向下走，但沿途的节点只能经过一次，当到达节点B时，路径上的节点数叫作A到B的距离。对于给定的一棵二叉树，求整棵树上节点间的最大距离。

给定一个二叉树的头结点root，请返回最大距离。保证点数大于等于2小于等于500.

import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}*/
public class LongestDistance {
    public int findLongest(TreeNode root) {
  			int[]record=new int[1];
        	return process(root,record);
         }
    public int process(TreeNode root,int[]record){
        if(root==null){
            record[0]=0;
            return 0;
        }
        int lmax=process(root.left,record);
        int maxfromleft=record[0];
        int rmax=process(root.right,record);
        int maxfromright=record[0];
        int cur=maxfromleft+maxfromright+1;
        
        record[0]=Math.max(maxfromleft,maxfromright)+1;
                
        return Math.max(Math.max(lmax,rmax),cur);      
    }
}

　　

题目描述：重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
	public TreeNode ConstructTree(int[] pre,int[] in,int prestart,int preend,int instart,int inend) throws Exception
	{
		int rootvalue = pre[prestart];
		TreeNode root = new TreeNode(rootvalue);
		root.left = null;
		root.right = null;
		
		if(prestart==preend){
			if(instart==inend&&pre[prestart]==in[instart])
				return root;
			else
				throw new Exception("wrong");
		}
		
		int posinorder = instart;
		while(posinorder<=inend&&in[posinorder]!=rootvalue)
			++posinorder;
		
		if(posinorder==inend&&in[posinorder]!=rootvalue)
			throw new Exception("wrong");
		
		int leftLength = posinorder-instart;
		int leftPreend = prestart+leftLength;
		if(leftLength>0)
		{
			root.left = ConstructTree(pre,in,prestart+1,leftPreend,instart,posinorder-1);
		}
		if(leftLength<preend-prestart)
		{
			root.right = ConstructTree(pre,in,leftPreend+1,preend,posinorder+1,inend);
		}
		return root;
	}
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        int prestart = 0, preend = pre.length-1;
        int instart = 0, inend = in.length-1;
        if(preend==0||inend==0)
        	return null;
        try {
			return ConstructTree(pre,in,prestart,preend,instart,inend);
		} catch (Exception e) {
			//e.printStackTrace();
			return null;
		}
    }
}