给定一个二叉树和任意一个节点，求该该节点的下一层的第一个节点

 

     问题：给定一个二叉树和任意一个节点，求该该节点的下一层的第一个节点，该二叉树为孩子表示法

   分析：要想得到下一层的第一个节点，那我们可以通过得到上一层的每个节点，然后遍历上一层的节点来得到第一个节点。关键是求出上一次节点。考虑到二叉树的特点，如果我们将这个二叉树转化为完全二叉树，那么我们可以通过层次遍历的方式得到这个遍历序列，因为给定了某个节点，如果我们将这个序列存入到数组中，不难想到二叉树的父节点和子节点下标关系（父节点编号为n,子节点在数组中下标为2n+1,2n+2）,通过判断给定节点的下标，就可以算出该层节点在数组中下标的起始范围（假设给定的节点在第K层，K层的节点的下标范围为 2^(k-1)-1,2^k-2）。

     

      Java实现：

             

<span style="font-size:18px;">import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;


//--------------------- Change Logs----------------------
// <p>@author weiwei.han Initial Created at 2015-9-25<p>
//-------------------------------------------------------
public class FindTreeNode {

    
    private  Node root;
    private  Node e; 
    private final static int MAX_LENGTH=1024;
    
    public FindTreeNode(){
        this.e = createTree();
    }
    
    public Node findFirst(Node e) {
        if(root == null) {
            return new Node(null, null, null);
        }
        
        List<Node> list = new ArrayList<FindTreeNode.Node>();
        BlockingQueue<Node> queue = new LinkedBlockingQueue<FindTreeNode.Node>();
        
        int p = -1, q=0, r=MAX_LENGTH-1;
        queue.offer(root);
        while(p<r) {
            Node node = queue.poll();
            if(node == null || node.value == null) {
                queue.offer(returnNode(null));
                queue.offer(returnNode(null));
            }else {
                queue.offer(returnNode(node.left));
                queue.offer(returnNode(node.right));
            }
            list.add(node);
            p++;
            if(e == node) {
                int k = getHeight(p);
                q = (int)Math.pow(2, (k-1))-1;
                r = (int)Math.pow(2, k)-2;
            }
        }
        
        for(int i=q; i< r+1; i++) {
            Node node = list.get(i);
            if(node.left != null) {
                return node.left;
            }
            else if(node.right != null){
                return node.right;
            }
        }
        
        return null;
    }
    
    private int getHeight(int p) {
        return (int)(Math.log(p+1)/Math.log(2))+1;
    }
    
    private Node returnNode(Node value) {
        if(value == null)
            return new Node(null, null, null);
        return value;
    }
    
    static class Node {
        private Object value;
        private Node left = null;
        private Node right = null;
        
        public Node(Object value, Node left, Node right) {
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }
    
    private  Node createTree() {
        Node node9 = new Node(9, null, null);
        Node node8 = new Node(8, null, node9);
        Node node6 = new Node(6, node8, null);
        Node node3 = new Node(3, null, node6);
        Node node7 = new Node(7, null, null);
        Node node5 = new Node(5, null, node7);
        Node node4 = new Node(4, null, null);
        Node node2 = new Node(2, node4, node5);
        Node node1 = new Node(1, node2, node3);
        root = node1;
        return node8;
    }
    
    public static void main(String[] args) {
        FindTreeNode node = new FindTreeNode();
        System.out.println(node.findFirst(node.e).value);
    }
   
    
}
</span>