二叉树遍历，递归和非递归，广度优先，深度优先，求二叉树深度

二叉树是每个节点至多有两个子树，常被用来二叉查找树和二叉堆，在面试的过程中经常会被问到。

本文主要介绍二叉树的创建和遍历，其中遍历包括递归遍历和非递归遍历，广度优先遍历和深度优先遍历，

还有递归以及非递归的方法求二叉树的深度，实现的语言是java。

public class BinaryTree {

 /**
  * @param args
  */
 static class Node{
  int value;
  Node leftChild;
  Node rightChild;
  
  Node(int value) {
   this.value = value;
  }
 }
 
 
 //插入元素
 public void insert(int value, Node node) {

  if(value < node.value) {
   if(node.leftChild != null) {
    insert(value, node.leftChild);
   } else{
    node.leftChild = new Node(value);
   }
  } else if(value > node.value) {
   if(node.rightChild != null) {
    insert(value, node.rightChild);
   } else {
    node.rightChild = new Node(value);
   }
  }
  
 }
 
 
 
 //递归先序遍历
 public void preTraverse(Node node){
  System.out.print(node.value + " ");
  if(node.leftChild != null) preTraverse(node.leftChild);
  if(node.rightChild != null) preTraverse(node.rightChild);
 }
 
 //非递归先序遍历
 public void preTraverseNoRecursion(Node node){
  Stack<Node> stack = new Stack<Node>();
  if(node != null) {
   stack.push(node);
  }
  while(!stack.isEmpty()){
   node =  stack.pop();
   System.out.print(node.value + " ");
   if(node.rightChild != null) {
    stack.push(node.rightChild);
   }
   if(node.leftChild != null) {
    stack.push(node.leftChild);
   }
  } 
 }
 
 //非递归先序遍历2
 public void preTraverseNoRecursion2(Node node){
  Stack<Node> stack = new Stack<Node>();
  while(node != null || stack.size() > 0){
   while(node != null) {
    System.out.print(node.value + " ");
    stack.push(node);
    node = node.leftChild;
   }
   if(stack.size() > 0) {
    node = stack.pop();
    node = node.rightChild;
   }
  }
 }
 
 //递归中序遍历
 public void midTraverse(Node node){
  if(node.leftChild != null) midTraverse(node.leftChild);
  System.out.print(node.value + " ");
  if(node.rightChild != null) midTraverse(node.rightChild);
 }
 
 //非递归中序遍历
 public void midTraverseNoRecursion(Node node){
  Stack<Node> stack = new Stack<Node>();
  while(node != null ||stack.size()>0) {
   while(node != null) {
    stack.push(node);
    node=node.leftChild;
   }
   if(stack.size()>0) {
    node = stack.pop();
    System.out.print(node.value + " ");
    node = node.rightChild;
   }
   
  }
 }
 
 //递归后序遍历
 public void postTraverse(Node node){
  if(node.leftChild != null) postTraverse(node.leftChild);
  if(node.rightChild != null) postTraverse(node.rightChild);
  System.out.print(node.value + " ");
 }
 
 //非递归后序遍历
 public void postTraverseNoRecursion(Node node) {
  Stack<Node> stack = new Stack<Node>();
  Stack<Node> temp = new Stack<Node>();
  while(node != null || stack.size() > 0) {
   while(node != null){
    stack.push(node);
    temp.push(node);
    node = node.rightChild;
   }
   
   if(stack.size() > 0) {
    node = stack.pop();
    node = node.leftChild;
   }
  }
  
  while(temp.size() >0) {
   node = temp.pop();
   System.out.print(node.value + " ");
  }
  
 }
 
 //深度优先遍历
 public void depthTraverse(Node node) {
  Stack<Node> stack = new Stack<Node>();
  stack.push(node);
  while(!stack.isEmpty()){
   node = stack.pop();
   System.out.print(node.value + " ");
   if(node.rightChild != null) {
    stack.push(node.rightChild);
   }
   if(node.leftChild != null) {
    stack.push(node.leftChild);
   }
  }
 }
 
 //广度优先遍历
 public void breadthTraverse(Node node) {
  List<Node> list = new ArrayList<Node>();
  list.add(node);
  while(!list.isEmpty()){
   node = list.remove(0);
   System.out.print(node.value + " ");
   if(node.leftChild != null){
    list.add(node.leftChild);
   }
   if(node.rightChild != null) {
    list.add(node.rightChild);
   }
  }
  
 }
 
 //递归求深度
 public int depthRecursion(Node node){
  if(node == null) {
   return 0;
  }
  int leftChildDepth = depthRecursion(node.leftChild);
  int rightChildDepth = depthRecursion(node.rightChild);
  return leftChildDepth >= rightChildDepth ? leftChildDepth +1 : rightChildDepth +1;
  
 }
 
 //非递归求深度
 public void depthNoRecursion(Node node){
  List<Node> list1 = new ArrayList<Node>();
  list1.add(node);
  int level = 1;
  System.out.print(node.value + " ");
  while(!list1.isEmpty()) {
   List<Node> list2 = new ArrayList<Node>();
   boolean flag = false;
   while(!list1.isEmpty()) {
    list2.add(list1.remove(0));
   }
   for(int i = 0; i<list2.size(); i++) {
    Node temp = list2.get(i);
    if(temp.leftChild != null) {
     list1.add(temp.leftChild);
     System.out.print(temp.leftChild.value + " ");
     flag = true;
    }
    if(temp.rightChild != null){
     list1.add(temp.rightChild);
     System.out.print(temp.rightChild.value + " ");
     flag = true;
    }
   }
   if(flag) {
    level ++;
   } 
  }
  System.out.println("深度为：" + level);
  
 }
 
 
 
 
 public static void main(String[] args) {
   Node root = new Node(5);
   BinaryTree btree = new BinaryTree();
   btree.insert(4, root);
   btree.insert(7, root);
   btree.insert(1, root);
   btree.insert(3, root);
   btree.insert(8, root);
   btree.insert(6, root);
   btree.insert(9, root);
   
   System.out.println("递归先序遍历:");
   btree.preTraverse(root);
   System.out.println();
   System.out.println("非递归先序遍历:");
   btree.preTraverseNoRecursion(root);
   System.out.println();
   System.out.println("递归中序遍历:");
   btree.midTraverse(root);
   System.out.println();
   System.out.println("非递归中序遍历:");
   btree.midTraverseNoRecursion(root);
   System.out.println();
   System.out.println("递归后序遍历:");
   btree.postTraverse(root);
   System.out.println();
   System.out.println("非递归后序遍历:");
   btree.postTraverse(root);
   System.out.println();
   System.out.println("深度优先遍历:");
   btree.depthTraverse(root);
   System.out.println();
   System.out.println("广度优先遍历:");
   btree.breadthTraverse(root);
   System.out.println();
   System.out.println("递归求深度:");
   System.out.println(btree.depthRecursion(root));
   System.out.println("非递归求深度:");
   btree.depthNoRecursion(root); 
   
 }
 
 
 

}