二叉树 先、中、后序递归和非递归遍历

今天自己写了下 二叉树的遍历， 练练手哈哈.  

Java代码如下:

package Tree;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BTreeTraverse {
	public static void main(String[] args) {
		binaryTree tree = new binaryTree();
		tree.insertNode(4);
		tree.insertNode(3);
		tree.insertNode(2);
		tree.insertNode(1);
		tree.insertNode(3);
		tree.insertNode(5);
		tree.insertNode(7);
		tree.insertNode(6);
		Node<Integer> root = tree.getRoot();
		System.out.println("breadth");
		tree.breadthFirstTraverse(tree.getRoot());
		System.out.println();
		System.out.println("preOrder");
		tree.preOrderTraverse(tree.getRoot());
		System.out.println();
		System.out.println("preOderNocursor");
		tree.preOrderTraverseNoRecursion(tree.getRoot());
		System.out.println();
		System.out.println("midOrder");		
		tree.midOrderTraverse(tree.getRoot());
		System.out.println();
		System.out.println("midOderNocursor");
		tree.midOrderTraverseNoRecursion(tree.getRoot());
		System.out.println();
		System.out.println("postOrder");		
		tree.postOrderTraverse(tree.getRoot());
		System.out.println();
		System.out.println("postOderNocursor");			
		tree.postOrderTraverseNoRecursion(tree.getRoot());
		System.out.println();
		System.out.println("postOderNocursor2");
		tree.postOrderTraverseNoRecursion2(tree.getRoot());
		System.out.println();		
		System.out.println("end---");	

	}
	

	static class Node<E extends Comparable<E>>{
		E value;
		Node<E> left;
		Node<E> right;
		Node(E value){
			this.value = value;
		}
	}
	
	static class binaryTree<E extends Comparable<E>>{
		private Node <E> root ;
		public binaryTree() {
			// TODO Auto-generated constructor stub
			root = null;
		}
		public Node<E> getRoot(){
			return this.root;
		}
		public void insertNode(E value){
			if(root == null){
				root = new Node<E>(value);
				return;
			}
			
			Node<E> currentNode = root;
			
			while(true){
				if(value.compareTo(currentNode.value) < 0){
					if(currentNode.left == null){
							currentNode.left = new Node<E>(value);
							return;
						}
					currentNode = currentNode.left;
				}
				else{
					if(currentNode.right == null){
						currentNode.right = new Node<E>(value);
						return;
					}
					currentNode = currentNode.right;
				}
			}
		}
		//广度优先遍历
		public void breadthFirstTraverse(Node<E> root){
			if(root == null){
				System.out.println("BTree is empty");
				return;
			}
			Queue<Node<E>> queue = new LinkedList<Node<E>>();
			Node<E> currentNode;
			queue.add(root);
			while(!queue.isEmpty()){
				currentNode = queue.poll();
				System.out.print(currentNode.value + " ");
				if(currentNode.left != null)
					queue.add(currentNode.left);
				if(currentNode.right != null)
					queue.add(currentNode.right);				
			}
		}
		//先序遍历   递归
		public void preOrderTraverse(Node<E> root) {
			System.out.print(root.value + " ");
			if (root.left != null) 
				preOrderTraverse(root.left);
			if(root.right != null)
				preOrderTraverse(root.right);
			
		}
		//先序   非递归
		public void preOrderTraverseNoRecursion(Node<E> root) {
			Stack<Node<E>> stack = new Stack<Node<E>>();
			if(root!=null)
				stack.push(root);
			Node<E> currentNode;
			while(!stack.isEmpty()){
				currentNode = stack.pop();
				System.out.print(currentNode.value+" ");
				if(currentNode.right != null)
					stack.push(currentNode.right); //右节点先入后出
				if(currentNode.left != null)
					stack.push(currentNode.left);
			}
		}
		//中序 递归
		public void midOrderTraverse(Node<E> root){
			if(root.left != null)
				midOrderTraverse(root.left);
			System.out.print(root.value+" ");
			if(root.right != null)
				midOrderTraverse(root.right);
		}
		//中序 非递归
		public void midOrderTraverseNoRecursion(Node<E> root) {
			Stack<Node<E>> stack = new Stack<Node<E>>();
			//stack.push(root);
			Node<E> currentNode = root;
			while(currentNode!=null || !stack.isEmpty()){
				//currentNode = stack.peek();
				if (currentNode != null) {
					stack.push(currentNode);
					currentNode = currentNode.left;					
				}else{
					currentNode = stack.pop();
					System.out.print(currentNode.value+" ");
					currentNode = currentNode.right;
				}
			}
			
		}
		//后序   递归
		public void postOrderTraverse(Node<E> root){
			if(root.left != null)
				postOrderTraverse(root.left);
			if(root.right != null)
				postOrderTraverse(root.right);
			System.out.print(root.value + " ");
		}
		//后序  非递归(我认为最难想的一个) 方法一
		public void postOrderTraverseNoRecursion(Node<E> root){
			Stack<Node<E>> stack = new Stack<Node<E>>();
			Stack<Node<E>> output = new Stack<Node<E>>();
			
			Node<E> currentNode = root;			
			while(currentNode !=null || !stack.isEmpty()){				
				if(currentNode != null){
					stack.push(currentNode);
					output.push(currentNode);
					currentNode = currentNode.right;
				}else{
					currentNode = stack.pop();
					currentNode = currentNode.left;
				}
			}
			while(!output.isEmpty()){
				System.out.print(output.pop().value+" ");
			}
		}
		//后序遍历  非递归  方法2
		public void postOrderTraverseNoRecursion2(Node<E> root) {
			//根->右->左  遍历，将输出保存在栈中，然后输出（可以这么理解啦  *****
			Stack<Node<E>> stack = new Stack<Node<E>>();
			Stack<Node<E>> output = new Stack<Node<E>>();
			Node<E> currentNode = root;
			if(root != null){
				stack.push(root);
			}
			while(!stack.empty()){
				currentNode = stack.pop();
				output.push(currentNode);
				if(currentNode.left!=null){
					stack.push(currentNode.left);
				}
				if(currentNode.right != null){
					stack.push(currentNode.right);
				}
			}
			while(!output.isEmpty()){
				System.out.print(output.pop().value+" ");
			}
		}	
	}
}

另外时间复杂度O(n),空间复杂度O(1)的Morris 遍历，大家可以在网上找到很多资料。