二叉树遍历

二叉树遍历算法

最新推荐文章于 2024-10-21 08:57:50 发布

yesIcando-bupt

最新推荐文章于 2024-10-21 08:57:50 发布

阅读量177

点赞数

CC 4.0 BY-SA版权

分类专栏：算法

本文链接：https://blog.youkuaiyun.com/qq_35124535/article/details/54341142

算法专栏收录该内容

49 篇文章

订阅专栏

本文介绍了二叉树的三种遍历方式：前序遍历、中序遍历及后序遍历，并提供了详细的Java实现代码。每种遍历方法都通过迭代而非递归的方式实现，利用栈来辅助完成遍历过程。

PRE ORDER TRAVERSE

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode p = root;
    while(!stack.isEmpty() || p != null) {
        if(p != null) {
            stack.push(p);
            result.add(p.val);  // Add before going to children
            p = p.left;
        } else {
            TreeNode node = stack.pop();
            p = node.right;   
        }
    }
    return result;
}

IN ORDER TRAVERSE

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> result = new ArrayList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode p = root;
    while(!stack.isEmpty() || p != null) {
        if(p != null) {
            stack.push(p);
            p = p.left;
        } else {
            TreeNode node = stack.pop();
            result.add(node.val);  // Add after all left children
            p = node.right;   
        }
    }
    return result;
}

POST ORDER TRAVERSE

1、

public List<Integer> postorderTraversal(TreeNode root) {
    LinkedList<Integer> result = new LinkedList<>();
    Deque<TreeNode> stack = new ArrayDeque<>();
    TreeNode p = root;
    while(!stack.isEmpty() || p != null) {
        if(p != null) {
            stack.push(p);
            result.addFirst(p.val);  // Reverse the process of preorder
            p = p.right;             // Reverse the process of preorder
        } else {
            TreeNode node = stack.pop();
            p = node.left;           // Reverse the process of preorder
        }
    }
    return result;
}

2、public List<Integer> postorderTraversal(TreeNode root) {
	List<Integer> results = new ArrayList<Integer>();
	Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
	while (!stack.isEmpty() || root != null) {
		if (root != null) {
			stack.push(root);
			results.add(root.val);
			root = root.right;
		} else {
			root = stack.pop().left;
		}
	}
	Collections.reverse(results);
	return results;
}
3、
public ArrayList<Integer> postorderTraversal(TreeNode root) {
    ArrayList<Integer> result = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode prev = null; // previously traversed node
    TreeNode curr = root;


    if (root == null) {
        return result;
    }


    stack.push(root);
    while (!stack.empty()) {
        curr = stack.peek();
        if (prev == null || prev.left == curr || prev.right == curr) { // traverse down the tree
            if (curr.left != null) {
                stack.push(curr.left);
            } else if (curr.right != null) {
                stack.push(curr.right);
            }
        } else if (curr.left == prev) { // traverse up the tree from the left
            if (curr.right != null) {
                stack.push(curr.right);
            }
        } else { // traverse up the tree from the right
            result.add(curr.val);
            stack.pop();
        }
        prev = curr;
    }


    return result;
}