lintcode 算法-二叉树的遍历-前序遍历、中序遍历、后序遍历、层序遍历、深度遍历

最新推荐文章于 2020-09-10 09:25:26 发布
最新推荐文章于 2020-09-10 09:25:26 发布
阅读量241 收藏
点赞数
分类专栏： lintcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20667511/article/details/103684634
版权

lintcode 算法-二叉树的遍历-前序遍历、中序遍历、后序遍历、层序遍历、深度遍历

算法要求

对于二叉树的遍历的方式就不介绍了。
分别是前序遍历、中序遍历、后序遍历、层序遍历、深度遍历
其中涉及到递归实现和非递归的实现方式。

      1
    /   \
   2     3
  / \   /  \
 4  5  6    7

二叉树节点为 1,2,3,4,5,6,7
前序遍历：1 2 4 5 3 6 7 
中序遍历：4 2 5 1 6 3 7
后序遍历：4 5 2 6 7 3 1
层次遍历：1 2 3 4 5 6 7
深度优先：1 2 4 5 3 6 7

1：前序遍历

非递归的方式实现

    /** 前序遍历 ,非递归的方式实现的
     * @param root
     * @return
     */
	public static List<Integer> preorderTraversal(TreeNode root) {
		List<TreeNode> p = new ArrayList<TreeNode>();
		List<Integer> res = new ArrayList<Integer>();
		while (root != null || p.size() != 0) {
			while (root != null) {
				p.add(root);
				res.add(root.val);
				root = root.left;
			}
			root = p.get(p.size() - 1);
			p.remove(p.size() - 1);
			root = root.right;
		}
		return res;
	}

递归实现方式1


	/** 前序遍历 ,递归的方式实现的
	 * @param root
	 * @return
	 */
	public static List<Integer> preorderTraversal2(TreeNode root) {
		if(root != null){
			resultList.add(root.val);
		}
		TreeNode left = root.left;
		if(left != null){
			preorderTraversal2(left);
		}
		TreeNode right = root.right;
		if(right != null){
			preorderTraversal2(right);
		}
		return resultList;
	}

递归实现方式2

	/**
	 * 前序遍历，递归的方式实现的
	 * @param root
	 * @return
	 */
	public static List<Integer> preorderTraversal3(TreeNode root) {
		if (root != null) {
			resultList.add(root.val);
			preorderTraversal3(root.left);
			preorderTraversal3(root.right);
		}
		return resultList;
	}

2：中序遍历

非递归实现方式

/** 中序遍历 ，非递归调用
	 * @param root
	 * @return
	 */
	public static List<Integer> inorderTraversal(TreeNode root) {
		List<TreeNode> p = new ArrayList<TreeNode>();
		List<Integer> res = new ArrayList<Integer>();
		while (root != null || p.size() != 0) {
			while (root != null) {
				p.add(root);
				root = root.left;
			}
			root = p.get(p.size() - 1);
			p.remove(p.size() - 1);
			res.add(root.val);
			root = root.right;
		}
		return res;
	}

递归实现方式1

/** 中序遍历 非递归调用
	 * @param root
	 * @return
	 */
	public static List<Integer> inorderTraversal2(TreeNode root) {
		TreeNode left = root.left;
		if(left != null){
			inorderTraversal2(left);
		}
		if(root!=null){
			resultList.add(root.val);
		}
		TreeNode right = root.right;
		if(right != null){
			inorderTraversal2(right);
		}
		return resultList;
	}

递归实现方式2

/**
	 * 中序遍历，递归的方式实现的
	 * @param root
	 * @return
	 */
	public static List<Integer> inorderTraversal3(TreeNode root) {
		if (root != null) {
			inorderTraversal3(root.left);
			resultList.add(root.val);
			inorderTraversal3(root.right);
		}
		return resultList;
	}

3：后序遍历

非递归实现方式

	/** 后序遍历 ，非递归调用
	 * @param root
	 * @return
	 */
	public static List<Integer> postorderTraversal(TreeNode root) {
		List<TreeNode> p = new ArrayList<TreeNode>();
		List<Integer> res = new ArrayList<Integer>();
		while (root != null || p.size() != 0) {
			while (root != null) {
				p.add(root);
				root = root.left;
			}
			root = p.get(p.size() - 1);
			res.add(root.val);
			p.remove(p.size() - 1);
			root = root.right;
		}
		return res;
	}

非递归实现方式2

    public static List<Integer> postorderTraversal1(TreeNode root){
        LinkedList<TreeNode> statck = new LinkedList<>();
        LinkedList<Integer> res = new LinkedList<>();
        if(root == null){
            return res;
        }
        statck.add(root);
        while (!statck.isEmpty()){
            TreeNode node = statck.pollLast(); // TODO 精髓的两句操作
            res.addFirst(node.val); // TODO res.add(node.val)   链表顺序是反着遍历的
            if(node.left != null){
                statck.add(node.left);
            }
            if(node.right != null){
                statck.add(node.right);
            }
        }
        return res;
    }

非递归实现方式3

    public static List<Integer> postorderTraversal2(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        LinkedList<Integer> res = new LinkedList<>();
        while (!stack.isEmpty() || root != null) {
            if (root != null) {
                stack.push(root);
                res.addFirst(root.val);
                root = root.right;
            } else {
                root = stack.pop();
                root = root.left;
            }
        }
        return res;
    }

递归实现方式1

/** 后序遍历 递归调用
	 * @param root
	 * @return
	 */
	public static List<Integer> postorderTraversal1(TreeNode root) {
		TreeNode left = root.left;
		if(left != null){
			postorderTraversal(left);
		}
		TreeNode right = root.right;
		if(right != null){
			postorderTraversal(right);
		}
		if(root!=null){
			resultList.add(root.val);
		}
		return resultList;
	}

递归实现方式2

/**
	 * 后序遍历，递归的方式实现的
	 * @param root
	 * @return
	 */
	public static List<Integer> postorderTraversal2(TreeNode root) {
		if (root != null) {
			postorderTraversal2(root.left);
			postorderTraversal2(root.right);
			resultList.add(root.val);
		}
		return resultList;
	}

4： 层序遍历

/**
	 * 层次遍历
	 */
	public static List<Integer> levelTraverse(TreeNode root){
		if(root == null){
			return null;
		}
		LinkedList<TreeNode> queue = new LinkedList<>();
		queue.offer(root);
		while(!queue.isEmpty()){
			TreeNode node = queue.poll();
			resultList.add(node.val);
			if(node.left != null){
				queue.offer(node.left);
			}
			if(node.right != null){
				queue.offer(node.right);
			}
		}
		return resultList;
	}

5：深度遍历

/**
	 * 深度优先遍历方式
	 * @param root
	 * @return
	 */
	public static List<Integer> depthTraversal(TreeNode root){
		if(root == null){
			return null;
		}
		Stack<TreeNode> stack = new Stack<TreeNode>();
		stack.push(root);
		while(!stack.isEmpty()){
			TreeNode node = stack.pop();
			resultList.add(node.val);
			if(node.right!=null){
				stack.push(node.right);
			}
			if(node.left != null){
				stack.push(node.left);
			}
		}
		return resultList;
	}

6：所有的代码和测试案例

package com.lintcode.easy;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

import com.lintcode.node.TreeNode;

/**  
 * 66. 二叉树的前序遍历
给出一棵二叉树，返回其节点值的前序遍历。

样例
Example 1:

Input：{1,2,3}
Output：[1,2,3]
解释：
前序遍历
Example 2:

Input：{1,#,2,3}
Output：[1,2,3]
解释：
前序遍历
挑战
你能使用非递归实现么？

注意事项
首个数据为根节点，后面接着是其左儿子和右儿子节点值，"#"表示不存在该子节点。
节点数量不超过20

      1
    /   \
   2     3
  / \   /  \
 4  5  6    7

二叉树节点为 1,2,3,4,5,6,7
前序遍历：1 2 4 5 3 6 7 
中序遍历：4 2 5 1 6 3 7
后序遍历：4 5 2 6 7 3 1
层次遍历：1 2 3 4 5 6 7
深度优先：1 2 4 5 3 6 7
 * @author zhouwenchen@021.com  
 * @date 2019年3月27日上午11:43:56   
 */
public class PreorderTraversal {
	
	private static List<Integer> resultList = new ArrayList<Integer>();
	private static List<List<Integer>> resultList1 = new ArrayList<>();
	
    /** 前序遍历 ,非递归的方式实现的
     * @param root
     * @return
     */
	public static List<Integer> preorderTraversal(TreeNode root) {
		List<TreeNode> p = new ArrayList<TreeNode>();
		List<Integer> res = new ArrayList<Integer>();
		while (root != null || p.size() != 0) {
			while (root != null) {
				p.add(root);
				res.add(root.val);
				root = root.left;
			}
			root = p.get(p.size() - 1);
			p.remove(p.size() - 1);
			root = root.right;
		}
		return res;
	}
	
	/** 前序遍历 ,递归的方式实现的
	 * @param root
	 * @return
	 */
	public static List<Integer> preorderTraversal2(TreeNode root) {
		if(root != null){
			resultList.add(root.val);
		}
		TreeNode left = root.left;
		if(left != null){
			preorderTraversal2(left);
		}
		TreeNode right = root.right;
		if(right != null){
			preorderTraversal2(right);
		}
		return resultList;
	}
	
	/**
	 * 前序遍历，递归的方式实现的
	 * @param root
	 * @return
	 */
	public static List<Integer> preorderTraversal3(TreeNode root) {
		if (root != null) {
			resultList.add(root.val);
			preorderTraversal3(root.left);
			preorderTraversal3(root.right);
		}
		return resultList;
	}
	
	// TODO ===========================
	/** 中序遍历 ，非递归调用
	 * @param root
	 * @return
	 */
	public static List<Integer> inorderTraversal(TreeNode root) {
		List<TreeNode> p = new ArrayList<TreeNode>();
		List<Integer> res = new ArrayList<Integer>();
		while (root != null || p.size() != 0) {
			while (root != null) {
				p.add(root);
				root = root.left;
			}
			root = p.get(p.size() - 1);
			p.remove(p.size() - 1);
			res.add(root.val);
			root = root.right;
		}
		return res;
	}
	
	/** 中序遍历 非递归调用
	 * @param root
	 * @return
	 */
	public static List<Integer> inorderTraversal2(TreeNode root) {
		TreeNode left = root.left;
		if(left != null){
			inorderTraversal2(left);
		}
		if(root!=null){
			resultList.add(root.val);
		}
		TreeNode right = root.right;
		if(right != null){
			inorderTraversal2(right);
		}
		return resultList;
	}
	
	/**
	 * 中序遍历，递归的方式实现的
	 * @param root
	 * @return
	 */
	public static List<Integer> inorderTraversal3(TreeNode root) {
		if (root != null) {
			inorderTraversal3(root.left);
			resultList.add(root.val);
			inorderTraversal3(root.right);
		}
		return resultList;
	}
	
	// TODO ===========================
	
	/** 后序遍历 ，非递归调用
	 * @param root
	 * @return
	 */
	public static List<Integer> postorderTraversal(TreeNode root) {
		List<TreeNode> p = new ArrayList<TreeNode>();
		List<Integer> res = new ArrayList<Integer>();
		while (root != null || p.size() != 0) {
			while (root != null) {
				p.add(root);
				root = root.left;
			}
			root = p.get(p.size() - 1);
			res.add(root.val);
			p.remove(p.size() - 1);
			root = root.right;
		}
		return res;
	}
	
	/** 后序遍历 递归调用
	 * @param root
	 * @return
	 */
	public static List<Integer> postorderTraversal1(TreeNode root) {
		TreeNode left = root.left;
		if(left != null){
			postorderTraversal(left);
		}
		TreeNode right = root.right;
		if(right != null){
			postorderTraversal(right);
		}
		if(root!=null){
			resultList.add(root.val);
		}
		return resultList;
	}
	
	/**
	 * 后序遍历，递归的方式实现的
	 * @param root
	 * @return
	 */
	public static List<Integer> postorderTraversal2(TreeNode root) {
		if (root != null) {
			postorderTraversal2(root.left);
			postorderTraversal2(root.right);
			resultList.add(root.val);
		}
		return resultList;
	}
	
	// TODO ===========================
	
	/**
	 * 层次遍历
	 */
	public static List<Integer> levelTraverse(TreeNode root){
		if(root == null){
			return null;
		}
		LinkedList<TreeNode> queue = new LinkedList<>();
		queue.offer(root);
		while(!queue.isEmpty()){
			TreeNode node = queue.poll();
			resultList.add(node.val);
			if(node.left != null){
				queue.offer(node.left);
			}
			if(node.right != null){
				queue.offer(node.right);
			}
		}
		return resultList;
	}
 
	// TODO =======================================
	/**
	 * 深度优先遍历方式
	 * @param root
	 * @return
	 */
	public static List<Integer> depthTraversal(TreeNode root){
		if(root == null){
			return null;
		}
		Stack<TreeNode> stack = new Stack<TreeNode>();
		stack.push(root);
		while(!stack.isEmpty()){
			TreeNode node = stack.pop();
			resultList.add(node.val);
			if(node.right!=null){
				stack.push(node.right);
			}
			if(node.left != null){
				stack.push(node.left);
			}
		}
		return resultList;
	}
	
	/**
	 * 深度优先遍历，递归方式实现
	 * @param root
	 * @return
	 */
	public static List<Integer> depthTraversal1(TreeNode root){
		if(root == null){
			return null;
		}
		resultList.add(root.val);
		depthTraversal1(root.left);
		depthTraversal1(root.right);
		return resultList;
	}
	
	
    public static void main(String[] args) {
    	TreeNode node1 = new TreeNode(1);
		TreeNode node2 = new TreeNode(2);
		TreeNode node3 = new TreeNode(3);
		TreeNode node4 = new TreeNode(4);
		TreeNode node5 = new TreeNode(5);
		TreeNode node6 = new TreeNode(6);
		TreeNode node7 = new TreeNode(7);
		
//		TreeNode node8 = new TreeNode(8);

		node1.left = node2;
		node1.right = node3;
		node2.left = node4;
		node2.right = node5;
		node3.left = node6;
		node3.right = node7;
		
//		node7.right = node8;
//		List<Integer> list = inorderTraversal(node1);
//		List<Integer> list = inorderTraversal(node1);
// 		List<Integer> list = preorderTraversal3(node1);
// 		List<Integer> list = postorderTraversal(node1);
// 		List<Integer> list = levelTraverse(node1);
 		List<Integer> list = depthTraversal(node1);
		for (Integer integer : list) {
			System.out.print(integer + " ");
		}
	}
}

public class TreeNode {
	public int val;
	public TreeNode left, right;

	public TreeNode(int val) {
		this.val = val;
		this.left = this.right = null;
	}
}
可爱组长
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
01-20
本文实例讲述了Python二叉树的遍历操作。分享给大家供大家参考，具体如下： # coding:utf-8 @ encoding: utf-8 @ author: lixiang @ email: lixiang_cn@foxmail.com @ python_version: 2 @ time: 2018/4/11 0:09 @...
领扣LintCode算法问题答案-69. 二叉树的层次遍历
二当家的白帽子
09-06 1204
领扣LintCode算法问题答案-69. 二叉树的层次遍历 目录69. 二叉树的层次遍历鸣谢 69. 二叉树的层次遍历 给出一棵二叉树，返回其节点值的层次遍历（逐层从左往右访问） 首个数据为根节点，后面接着是其左儿子和右儿子节点值，"#"表示不存在该子节点。 节点数量不超过20。 样例 1： 输入：{1,2,3} 输出：[[1],[2,3]] 解释： 1 / \ 2 3 它将被序列化为{1,2,3} 层次遍历 样例 2： 输入：{1,#,2,3} 输出：[[1],[2],[3]] 解释： 1 .
二叉树（前序遍历、后序遍历、中序遍历、二叉树的深度计算）
jjjstephen的博客
09-10 670
前序遍历规则： 若二叉树为空，则空操作返回，否则先访问根节点，然后前序遍历左子树，再前序遍历右子树。 中序遍历规则： 若树为空，则空操作返回，否则从根结点开始（注意并不是先访问根节点），中序遍历根节点的左子树，然后访问根节点，最后中序遍历右子树。 后序遍历： 若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问右子树，最后访问根结点。 test.hpp #ifndef TEST_H_ #define TEST_H_ #include<iostream> #include"malloc.
lintcode901 - Closest Binary Search Tree Value II - hard
weixin_30952103的博客
09-03 116
Given a non-empty binary search tree and a target value, find k values in the BST that are closest to the target. Example Given root = {1}, target = 0.000000, k = 1, return [1]. Challenge Assume...
二叉树遍历问题-二叉树遍历问题
11-12
二叉树遍历是计算机科学中的一个重要概念，主要应用于数据结构和算法领域。二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树遍历是指按照特定顺序访问二叉树的所有...
非递归前序,中序,后序遍历二叉树(优化算法).rar_nooneyh_二叉树 非递归_前序 中序 后序_树遍历算法_遍历二叉树
09-14
遍历二叉树是指按照特定的顺序访问树中的每一个节点，常见的遍历方法有三种：前序遍历、中序遍历和后序遍历。在递归实现这些遍历时，虽然直观但可能导致栈溢出问题，特别是在处理深度较大的二叉树时。因此，非递归的...
PHP实现二叉树深度优先遍历(前序、中序、后序)和广度优先遍历(层次)实例详解
10-18
二叉树遍历是访问树中所有节点的一种方法，通常分为深度优先遍历（DFS，Depth-First Search）和广度优先遍历（BFS，Breadth-First Search）。在PHP中，我们可以使用递归或非递归的方式来实现这些遍历算法。 1. 深度...
C#使用前序遍历、中序遍历和后序遍历打印二叉树的方法
09-03
遍历二叉树是访问树中所有节点的过程，通常有三种基本的遍历方法：前序遍历（Preorder Traversal）、中序遍历（Inorder Traversal）和后序遍历（Postorder Traversal）。这些遍历方法在C#编程中有着广泛的应用，如...
7.15 陇东学院云计算1班 马陆辉 20240715
07-15
练习题
090N03LS-VB QFN8(5X6）一款N-Channel沟道DFN8(5X6)的MOSFET晶体管参数介绍与应用说明
07-15
090N03LS-VB QFN8(5X6）；Package：DFN8(5X6)；Configuration：Single-N-Channel；VDS：30V；VGS：20（±V）；Vth：1.7V；RDS(ON)=9mΩ@VGS=4.5V；RDS(ON)=7mΩ@VGS=10V；ID：80A；Technology：Trench；
Hadoop和Spark多节点集群搭建：从入门到进阶0基础！！易懂！！
最新发布
07-15
详细介绍了如何从入门到进阶搭建和管理Hadoop和Spark的多节点集群。首先，文章解释了多节点集群的概念和优势，然后提供了硬件和软件环境的准备步骤，包括Java和SSH配置。接着，文章分步骤指导如何下载、安装和配置Hadoop和Spark，涵盖环境变量设置、配置文件编辑和集群启动等关键步骤。还包括如何监控和优化集群资源使用，并解决常见问题，如节点通信问题和任务失败。最后，文章提供了进一步学习和扩展的建议，帮助读者深入掌握大数据处理技术。希望通过这份指南，初学者能成功搭建高效的Hadoop和Spark集群，提升数据处理能力。Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和Spark多节点集群搭建Hadoop和
Spring Cloud Azure使用详解.pdf
07-15
Spring Cloud Azure使用详解
简约工作汇报模板
07-15
【作品名称】：简约工作汇报模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
管家婆SQL数据字典.doc
07-15
数据库
openssl自签证书
07-15
快速生成自签证书
南京师范大学考研，58个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
07-15
南京师范大学考研，58个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
昆明医科大学考研15个学院，61个专业课历年考试真题及答案汇总，备考资料题库笔记，录用名单汇总.pdf
07-15
昆明医科大学考研15个学院，61个专业课历年考试真题及答案汇总，备考资料题库笔记，录用名单汇总.pdf
C# socket 服务端时,每接受一个客户端时,调用一个类
07-15
C# socket 服务端时,每接受一个客户端时,调用一个类 在C#中，使用Socket开发网络应用时，可以在接受每个客户端连接时创建一个新的类实例来处理与该客户端的通信。以下是一个简单的示例。
数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx
07-15
辽宁省数学建模 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx 数学建模题目之PM2.5 扩散预测模型及相关问题研究.docx
数据结构编程题.doc
07-14
要求根据给定的文本表示，计算并输出前序、后序和中序遍历的结果。例如，输入的样例树的遍历结果分别为：前序ABCDEF，后序CBFEDA，中序BCAEFDABC。 第二个题目是关于二叉树的重建，具体是根据中根序列和后根序列...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值