回顾：树的几种迭代遍历方式

最新推荐文章于 2024-02-11 13:13:51 发布

boy_nihao

最新推荐文章于 2024-02-11 13:13:51 发布

阅读量2.3k

点赞数 1

CC 4.0 BY-SA版权

分类专栏：算法相关 java LeetCode leetcode算法分析

本文链接：https://blog.youkuaiyun.com/u012975705/article/details/80258664

LeetCode 同时被 3 个专栏收录

12 篇文章

订阅专栏

leetcode算法分析

12 篇文章

订阅专栏

算法相关

7 篇文章

订阅专栏

本文详细介绍了树的四种遍历方式：中序遍历、前序遍历、后序遍历和层次遍历，并提供了相应的测试代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

PS：文章最后附上完整代码

一、中序遍历

List<Integer> inOrder(BTree root) {
        List<Integer> result = new ArrayList<>();

        Stack<BTree> stack = new Stack<>();
        BTree node;
        while (null != root || !stack.empty()) {
            while (null != root) {
                stack.push(root);
                root = root.left;
            }
            node = stack.pop();
            result.add(node.val);
            if (null != node.right) {
                root = node.right;
            }
        }

        return result;
    }

二、前序遍历

List<Integer> preOrder(BTree root) {
        List<Integer> result = new ArrayList<>();

        Stack<BTree> stack = new Stack<>();
        BTree node;
        while (null != root || !stack.empty()) {
            while (null != root) {
                result.add(root.val);
                stack.push(root);
                root = root.left;
            }
            node = stack.pop();
            if (null != node.right) {
                root = node.right;
            }
        }

        return result;
    }

三、后序遍历

List<Integer> postOrder(BTree root) {
        List<Integer> result = new ArrayList<>();

        Stack<BTree> stack = new Stack<>();
        BTree node;
        while (null != root || !stack.empty()) {
            while (null != root) {
                result.add(0, root.val);
                stack.push(root);
                root = root.right;
            }
            node = stack.pop();
            if (null != node.left) {
                root = node.left;
            }
        }

        return result;
    }

四、层次遍历

List<Integer> layerOrder(BTree root) {
        List<Integer> result = new ArrayList<>();
        if (null == root) {
            return result;
        }

        Queue<BTree> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            BTree node = queue.poll();
            if (null != node.left) {
                queue.offer(node.left);
            }
            if (null != node.right) {
                queue.offer(node.right);
            }
            result.add(node.val);
        }

        return result;
    }

测试代码：

import java.util.*;

/**
 * Copyright © 2018 Chris. All rights reserved.
 *
 * @author Chris
 */

public class Solution {

    static class BTree {
        int val;
        BTree left, right;
        BTree(int v) {val = v;}

        @Override
        public String toString() {
            return val + "";
        }
    }

    /**
     * 层次遍历
     *
     * @param root 根结点
     * @return 遍历结果
     */
    List<Integer> layerOrder(BTree root) {
        List<Integer> result = new ArrayList<>();
        if (null == root) {
            return result;
        }

        Queue<BTree> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            BTree node = queue.poll();
            if (null != node.left) {
                queue.offer(node.left);
            }
            if (null != node.right) {
                queue.offer(node.right);
            }
            result.add(node.val);
        }

        return result;
    }
    /**
     * 后序遍历
     *
     * @param root 根结点
     * @return 遍历结果
     */

    List<Integer> postOrder(BTree root) {
        List<Integer> result = new ArrayList<>();

        Stack<BTree> stack = new Stack<>();
        BTree node;
        while (null != root || !stack.empty()) {
            while (null != root) {
                result.add(0, root.val);
                stack.push(root);
                root = root.right;
            }
            node = stack.pop();
            if (null != node.left) {
                root = node.left;
            }
        }

        return result;
    }

    /**
     * 前序遍历
     *
     * @param root 根结点
     * @return 遍历结果
     */
    List<Integer> preOrder(BTree root) {
        List<Integer> result = new ArrayList<>();

        Stack<BTree> stack = new Stack<>();
        BTree node;
        while (null != root || !stack.empty()) {
            while (null != root) {
                result.add(root.val);
                stack.push(root);
                root = root.left;
            }
            node = stack.pop();
            if (null != node.right) {
                root = node.right;
            }
        }

        return result;
    }

    /**
     * 中序遍历
     *
     * @param root 根结点
     * @return 遍历结果
     */
    List<Integer> inOrder(BTree root) {
        List<Integer> result = new ArrayList<>();

        Stack<BTree> stack = new Stack<>();
        BTree node;
        while (null != root || !stack.empty()) {
            while (null != root) {
                stack.push(root);
                root = root.left;
            }
            node = stack.pop();
            result.add(node.val);
            if (null != node.right) {
                root = node.right;
            }
        }

        return result;
    }

    public static void main(String args[]) {

        Solution s = new Solution();
        BTree root = new BTree(1);
        BTree left = new BTree(2);
        BTree right = new BTree(3);
        left.left = new BTree(4);
        left.right = new BTree(5);
        right.left = new BTree(6);
        right.right = new BTree(7);
        root.left = left;
        root.right  = right;
        System.out.println(s.inOrder(root));
        System.out.println(s.preOrder(root));
        System.out.println(s.postOrder(root));
        System.out.println(s.layerOrder(root));
    }
}