二叉树的遍历（递归，非递归，层次）

非递归中序遍历：

// 对于结点root;
// 1)若其结点不为空，则将root入栈并将root的左孩子置为当前的root,然后对当前结点root再进行相同的处理；
// 2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该节点，然后将当前的root置为栈顶结点的右孩子
// 3)直到p为null并且栈为空则遍历结束
// iterative
public void inorderTraversal2(TreeNode root){
Stack<TreeNode> stack = new Stack<>();
List<Integer> list = new ArrayList<>();
while(root!=null || !stack.isEmpty()){
while( root!= null){
stack.push( root);
root = root. left;
}
if (! stack.isEmpty()) {
TreeNode topNode = stack.peek();
System. out.println( " "+ topNode. key);
stack.pop();

if ( null != topNode. right) {
root= topNode. right;
}
}
}
}

// 非递归中序遍历----这种不容易记忆和编写
public void inorder_iterative_tree_walk(TreeNode root){
Stack<TreeNode> stack = new Stack<>();
while( root!= null || ! stack.isEmpty()){
if ( root != null) {
stack.push( root);
root = root. left;
} else{
TreeNode top = stack.peek();
System. out.print( top. key+ " ");
stack.pop();
root = top. right; //访问右子树
}
}
}

// 中序遍历---递归
public void inorder_tree_walk( TreeNode x){
if ( x!= null) {
inorder_tree_walk( x. left);
System. out.print( x. key + " ");
inorder_tree_walk( x. right);
}
}

// 前序遍历---递归
public void preorder_tree_walk( TreeNode x){
if ( x!= null) {
System. out.print( x. key + " ");
preorder_tree_walk( x. left);
preorder_tree_walk( x. right);
}
}

// 前序遍历---非递归
public void preorder_iterative_tree_walk(TreeNode x){
Stack<TreeNode > stack = new Stack<>();
stack.push( x);
while(! stack.isEmpty()){
TreeNode top = stack.peek();
System. out.print( top. key+ " ");
stack.pop();

if( top. right!= null){
stack.push( top. right);
}

if ( top. left!= null) {
stack.push( top. left);
}
}
}

// 后序遍历---递归版
public void postorder_tree_walk(TreeNode x){
if ( x!= null) {
postorder_tree_walk( x. left);
postorder_tree_walk( x. right);
System. out.print( x. key+ " ");
}
}

// 后序遍历非递归
// 1.push根结点到第一个栈s中
// 2.从第一个栈s中弹出一个结点，并将其push到第二个output中
// 3.然后push结点的左孩子和右孩子到第一个栈s中
// 4.重复2，3过程直到栈s为空
public void postorder_iterative_tree_walk(TreeNode x){
if ( x== null) return ;
Stack<TreeNode> stack = new Stack<>();
Stack<TreeNode> output = new Stack<>();
stack.push( x);
while(! stack.isEmpty()){
TreeNode top = stack.peek();
output.push( top);
stack.pop();

if ( top. left!= null) {
stack.push( top. left);
}
if ( top. right != null) {
stack.push( top. right);
}
}

while(! output.isEmpty()){
System. out.print( output.peek(). key+ " ");
output.pop();
}
}

// 层次遍历
public void level_order_tree_walk(TreeNode x){
if ( x== null) return ;
//java中队列的调用方法和c++的不一样
LinkedBlockingQueue<TreeNode> queue = new LinkedBlockingQueue();
queue.add( x);
while(! queue.isEmpty()){
TreeNode top = queue.peek();
System. out.print( top. key+ " ");
queue.poll(); //移除元素
if ( top. left != null) {
queue.offer( top. left);
}
if ( top. right != null) {
queue.offer( top. right);
}
}
}