找出一棵树某一深度所有节点

方法一：

• 思路：  

运用左右子树依次递归，根据深度值 k 每次递归k值减去 1 。直到 k 值为1时把此节点加入到结果队列，最后返回结果输出。

• 伪代码：

main（）{

    创建一棵测试树；

    创建一个结果队列 （接收返回值） = outPutNode(根节点，深度值)；

    打印结果；

}

outPutNode（根节点，深度值）{

    如果根节点为空或者深度值小于等于0 返回空

    创建结果队列resultQueue；

    方法Get递归操作（根节点，深度值，结果队列）；

}

Get（根节点，深度值，结果队列）{

    如果根节点为空或者深度值k小于等于0 return；

    如果深度值k等于1 则把此节点加入到结果队列；再return；

    如果根节点的左子树不为空 { Get（根节点的左子树，k-1 ，结果队列）}

    如果根节点的右子树不为空 { Get（根节点的右子树，k-1 ，结果队列）}

}

• 源码

•     public static void main(String[] args) {
  		TreeNode root = new TreeNode(4);
  		TreeNode l = new TreeNode(2);
  		TreeNode r = new TreeNode(6);
  		TreeNode ll = new TreeNode(1);
  		TreeNode lr = new TreeNode(3);
  		TreeNode rl = new TreeNode(5);
  		TreeNode rr = new TreeNode(7);
  		
  		l.left = ll;
  		l.right = lr;
  		
  		r.left = rl;
  		r.right = rr;
  		
  		root.left = l;
  		root.right = r;
  		//测试 获取第二层所有节点
  		Queue<TreeNode> resultQueue = outPutNode(root, 2);
  		while(!resultQueue.isEmpty()) {
  			System.out.println(resultQueue.poll().val);
  		}
  	}
  
      public static Queue<TreeNode> outPutNode(TreeNode root,int k) {
  		if(root==null || k <= 0 ) return null;
  		Queue<TreeNode> queue = new LinkedList<TreeNode>();
  		Get(root,k,queue);
  		return queue;
  	}
  	private static void Get(TreeNode root, int k, Queue<TreeNode> queue) {
  		if(root==null || k <= 0 ) return ;
  		if(k==1) {
  			queue.add(root);
  			return;
  		}
  		if(root.left!=null)
  			Get(root.left, k-1, queue);
  		if(root.right!=null)
  			Get(root.right, k-1, queue);
  	}

 

方法二：

• 思路：

    运用循环，记录当前树的深度、下层节点个数、本层还需要遍历的结点个数。

• 伪代码：

    主方法同上

    

outPutNode（根节点，深度值）{

    如果根节点为空 返回空

    创建结果队列；

    创建临时节点tempTreeNode

    将根节点添加至结果队列；

    初始化 当前深度值height = 1 ；下一层节点个数nextNum = 0；本层还需要遍历的结点个数 curNum = 1；

    while（当队列不为空）{

        如果当前深度值height等于目标深度k 则break；

        tempTreeNode = 节点出队列；

        如果tempTreeNode的左子树不为空{

             将tempTreeNode的左子树添加至队列；

             下一层节点个数nextNum+1；

        }

        如果tempTreeNode的右子树不为空{

             将tempTreeNode的右子树添加至队列；

             下一层节点个数nextNum+1；

        }

        本层的一个节点操作完毕，将本层节点数curNum - 1；

        如果本层节点值等于0{

              本层节点数curNum = 下层节点数nextNum；

               下层节点数nextNum = 0；

               深度值height + 1；

        }

    }

    返回队列   //队列内全是目标层节点；

}

• 源码

public static void main(String[] args) {
		TreeNode root = new TreeNode(4);
		TreeNode l = new TreeNode(2);
		TreeNode r = new TreeNode(6);
		TreeNode ll = new TreeNode(1);
		TreeNode lr = new TreeNode(3);
		TreeNode rl = new TreeNode(5);
		TreeNode rr = new TreeNode(7);
		
		l.left = ll;
		l.right = lr;
		
		r.left = rl;
		r.right = rr;
		
		root.left = l;
		root.right = r;
		//测试 获取第二层所有节点
		Queue<TreeNode> queue = outPutNode(root, 2);
		while(!queue.isEmpty()) {
			System.out.println(queue.poll().val);
		}
	}



	public static Queue<TreeNode> outPutNode(TreeNode root,int k) {
		if(root==null)return null;
		Queue<TreeNode> queue = new LinkedList<TreeNode>();
		queue.add(root);
		TreeNode tempTreeNode;
		int height = 1;//当前高度
		int nextNum = 0; //下一层节点个数
		int curNum = 1;//本层还需要遍历的结点个数
		while(!queue.isEmpty()) {
			if(height== k) {//判断是否是当前高度
				break;
			}
			tempTreeNode = queue.poll();
			if(tempTreeNode.left!=null) {
				queue.add(tempTreeNode.left);
				nextNum++;
			}
			if(tempTreeNode.right!=null) {
				queue.add(tempTreeNode.right);
				nextNum++;
			}
			curNum--;
			if(curNum==0) {//表示本层已遍历完毕，跳到下一层
				curNum = nextNum;//下一层节点值 赋给本层节点
				nextNum= 0 ;//下层节点初始化为0
				height++;//深度值+1
			}
		}
		return queue;//队列内全是目的层节点
	}

• 输入

      深度值为 2

                4

             /      \

          2          6

      /     \      /      \

    1       3    5       7

•  输出

  2  6