二叉树的三种遍历 Java

二叉树的三种遍历 Java

1.前序遍历

递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
		    public List<Integer> preorderTraversal(TreeNode root) {
		    	List<Integer> list = new ArrayList<Integer>();
		    	accessTree2(list, root);
		    	return list;
		    }
		    
		    public void accessTree2(List<Integer> list,TreeNode root) {
		    	while(root == null) {
		    		return;
		    	}
		    	
		    	list.add(root.val);
		    	accessTree2(list, root.left);
		    	accessTree2(list, root.right);
		    }
}

栈

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        		    	List<Integer> list = new ArrayList<Integer>();
		    	LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
		    	
		    	while(root != null || !stack.isEmpty()) {
		    		while(root != null) {
		    			list.add(root.val);
		    			stack.push(root);
		    			root = root.left;
		    		}		    		
		    		root = stack.pop();
		    		root = root.right;		    		
		    	}
		    	return list;
    }
}

2.中序遍历

递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
		    	List<Integer> list = new ArrayList<Integer>();
		    	accessTree(list,root);
		    	return list;
		    }
		    
		    public void accessTree(List<Integer> list,TreeNode root) {
		    	if (root == null) {
					return;
				}
		    	
		    	accessTree(list, root.left);
		    	list.add(root.val);
		    	accessTree(list, root.right);
		    }
}

栈

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
		    	List<Integer> list = new ArrayList<Integer>();
		    	LinkedList<TreeNode> stack = new LinkedList<>();
		    	
		    	while(root != null || !stack.isEmpty()) {
		    		while(root != null) {
			    		stack.push(root);
			    		root = root.left;	
		    		}
		    		root = stack.pop();
			    	list.add(root.val);
			    	root = root.right;	
		    	}
		    	return list;
    }
}

3.后序遍历

递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    		    public List<Integer> postorderTraversal(TreeNode root) {
		    	List<Integer> list = new ArrayList<Integer>();
		    	accessTree3(list, root);
		    	return list;
		    }
		    
		    public void accessTree3(List<Integer> list,TreeNode root) {
		    	while(root == null) {
		    		return;
		    	}
		    	
		    	accessTree3(list, root.left);
		    	accessTree3(list, root.right);
		    	list.add(root.val);
		    }
}

栈

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    		    public List<Integer> postorderTraversal(TreeNode root) {
		    			    	List<Integer> list = new ArrayList<Integer>();
		    	LinkedList<TreeNode> stack = new LinkedList<TreeNode>();
		    	TreeNode preAccess = null;
		    	while(root != null || !stack.isEmpty()) {
		    		while(root != null) {
		    			stack.push(root);
		    			root = root.left;
		    		}
		    		root = stack.pop();
		    		
		    		if (root.right == null || root.right == preAccess) {
						list.add(root.val);
						preAccess = root;
						root = null;
					}else {
						stack.push(root);
						root = root.right;
					}
		    		
		    	}
		    	return list;
		    }
}