LeetCode ACM模式——二叉树篇（一）

已于 2023-08-15 21:29:24 修改
阅读量749 收藏 2
点赞数 1
分类专栏： 做题总结 文章标签： leetcode 算法 BinaryTree java
于 2023-08-14 13:22:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zssxcj/article/details/132263798
版权

刷题顺序及思路来源于代码随想录，网站地址：https://programmercarl.com 

目录

定义二叉树

创建二叉树

利用前序遍历创建二叉树

利用数组创建二叉树

打印二叉树

144. 二叉树的前序遍历

递归遍历

迭代遍历（利用栈）

145. 二叉树的后序遍历

​编辑递归遍历

迭代遍历（利用栈）

94. 二叉树的中序遍历 

递归遍历

迭代遍历（利用栈）

定义二叉树

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

	public TreeNode() {
	}

	public TreeNode(int val){
		this.val=val;
	}
	public TreeNode(int val,TreeNode left,TreeNode right){
		this.val=val;
		this.left=left;
		this.right=right;
	}


}

创建二叉树

利用前序遍历创建二叉树

/**
 * @author light
 * @Description 基于前序遍历创建二叉树
 * @create 2023-08-13 20:24
 */
public class BinaryTree {
	TreeNode root; //根节点
	int size;  //树的长度
	int index=0;

    //Integer[] data:数值数组
	public BinaryTree(Integer[] data) {
		this.size=getSize(data);
		root=createTree(data);
	}

	private int getSize(Integer[] data) {
		int size=0;
		for(Integer i:data){
			if(i!=null){
				size++;
			}
		}
		return size;
	}

	public TreeNode createTree(Integer[] data){//递归生成二叉树
		Integer val=data[index++];
		if(val==null){
			return null;
		}
		TreeNode node=new TreeNode(val);
		node.left=createTree(data);
		node.right=createTree(data);
		return node;
	}
}

利用数组创建二叉树

/**
 * @author light
 * @Description 利用数组创建二叉树
 * @create 2023-08-14 12:38
 */
public class BinaryTree2 {
	TreeNode root; //根节点
	int size;  //树的长度
	Integer[] data;

	public BinaryTree2(Integer[] data) {
		this.data=data;
		this.size=getSize(data);
		root=createTree(0);
	}

	private int getSize(Integer[] data) {
		int size=0;
		for(Integer i:data){
			if(i!=null){
				size++;
			}
		}
		return size;
	}
	private TreeNode createTree(int index) {
		if(index>=data.length){
			return null;
		}
		if(data[index]==null){
			return null;
		}
		TreeNode node=new TreeNode(data[index]);
		node.left=createTree(2*index+1);
		node.right=createTree(2*index+2);
		return node;

	}

}

打印二叉树

/**
 * @author light
 * @Description 打印二叉树
 * @create 2023-08-14 13:06
 */
public class BinaryTreePrinter {
	public static void printTree(TreeNode root) {
		printTree(root, 0);
	}

	private static void printTree(TreeNode node, int level) {
		if (node == null) {
			return;
		}
		System.out.print(node.val+"\t");
		printTree(node.left, level + 1);
		printTree(node.right, level + 1);
	}

	public static void main(String[] args) {
		// 创建一个二叉树
		TreeNode root = new TreeNode(1);
		root.left = new TreeNode(2);
		root.right = new TreeNode(3);
		root.left.left = new TreeNode(4);
		root.left.right = new TreeNode(5);
		root.right.left = new TreeNode(6);
		root.right.right = new TreeNode(7);

		// 打印二叉树
		printTree(root);
	}

}

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

递归遍历



import java.util.ArrayList;
import java.util.List;

/**
 * @author light
 * @Description 二叉树的前序遍历
 * @create 2023-08-13 19:43
 */
public class PreorderTraversalTest {
	public static void main(String[] args) {
		Integer[] data={1, 2, 4, null, null, 5, null, null, 3, null, null };

		BinaryTree tree=new BinaryTree(data);
		System.out.println("递归前序遍历：");
		List<Integer> res1=preorderTraversal_Recursion(tree.root);
		System.out.println(res1);

	}

	//递归遍历
	public static List<Integer> preorderTraversal_Recursion(TreeNode root) {
		List<Integer> res=new ArrayList<>();
		traversal(root,res);
		return res;
	}
	public static void traversal(TreeNode root,List<Integer> res){
		if(root==null){
			return ;
		}
		res.add(root.val); //中
		traversal(root.left,res); //左
		traversal(root.right,res); //右

	}
	
}

迭代遍历（利用栈）


import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

/**
 * @author light
 * @Description 二叉树的前序遍历
 * @create 2023-08-13 19:43
 */
public class PreorderTraversalTest {
	public static void main(String[] args) {
		Integer[] data={1, 2, 4, null, null, 5, null, null, 3, null, null };

		BinaryTree tree=new BinaryTree(data);
		System.out.println("迭代前序遍历");
		List<Integer> res2=preorderTraversal_Iterate(tree.root);
		System.out.println(res2);

	}

	//迭代遍历(利用栈:前序遍历顺序：中-左-右，入栈顺序：中-右-左
	public static List<Integer> preorderTraversal_Iterate(TreeNode root) {
		List<Integer> list=new ArrayList<>();
		Deque<TreeNode> stack=new ArrayDeque<>();
		if(root==null){
			return list;
		}
		stack.push(root);
		while(!stack.isEmpty()){
			TreeNode node=stack.pop();
			list.add(node.val);
			if(node.right!=null){
				stack.push(node.right);
			}
			if(node.left!=null){
				stack.push(node.left);
			}
		}
		return list;
	}
}

145. 二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

递归遍历

import java.util.ArrayList;
import java.util.List;

/**
 * @author light
 * @Description 二叉树后序遍历
 * @create 2023-08-13 19:46
 */
public class PostorderTraversalTest {
	public static void main(String[] args) {
		Integer[] data={1, 2, 4, null, null, 5, null, null, 3, null, null };
		BinaryTree tree=new BinaryTree(data);

		System.out.println("递归后序遍历：");
		List<Integer> res1=postorderTraversal_Recursion(tree.root);
		System.out.println(res1);

	}

	//递归遍历
	public static List<Integer> postorderTraversal_Recursion(TreeNode root) {
		List<Integer> res=new ArrayList<>();
		traversal_Recursion(root,res);
		return res;
	}

	public static void traversal_Recursion(TreeNode root,List<Integer> res){
		if(root==null){
			return;
		}
		traversal_Recursion(root.left,res);//左
		traversal_Recursion(root.right,res);//右
		res.add(root.val);//中
	}
	
}

迭代遍历（利用栈）

import java.util.*;

/**
 * @author light
 * @Description 二叉树后序遍历
 * @create 2023-08-13 19:46
 */
public class PostorderTraversalTest {
	public static void main(String[] args) {
		Integer[] data={1, 2, 4, null, null, 5, null, null, 3, null, null };
		BinaryTree tree=new BinaryTree(data);

		System.out.println("迭代后续遍历");
		List<Integer> res2=postorderTraversal_Iterate(tree.root);
		System.out.println(res2);

	}
	//迭代遍历(利用栈:后序遍历顺序：左-右-中，入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
	public static List<Integer> postorderTraversal_Iterate(TreeNode root) {
		List<Integer> list=new ArrayList<>();
		Deque<TreeNode> stack=new ArrayDeque<>();
		if(root==null){
			return list;
		}
		stack.push(root);
		while(!stack.isEmpty()){
			TreeNode node=stack.pop();
			list.add(node.val);
			if(node.left!=null){
				stack.push(node.left);
			}
			if(node.right!=null){
				stack.push(node.right);
			}
		}
		Collections.reverse(list);
		return list;
	}
}

94. 二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

递归遍历

import java.util.ArrayList;
import java.util.List;

/**
 * @author light
 * @Description 二叉树中序遍历
 * @create 2023-08-13 19:48
 */
public class InorderTraversalTest {
	public static void main(String[] args) {
		Integer[] data={1, 2, 4, null, null, 5, null, null, 3, null, null };
		BinaryTree tree=new BinaryTree(data);
		System.out.println("递归中序遍历");
		List<Integer> res=inorderTraversal_Recursion(tree.root);
		System.out.println(res);
	}

	//递归遍历
	public static List<Integer> inorderTraversal_Recursion(TreeNode root) {
		List<Integer> res=new ArrayList<>();
		traversal_Recursion(root,res);
		return res;
	}

	public static void traversal_Recursion(TreeNode root,List<Integer> res){
		if(root==null){
			return;
		}
		traversal_Recursion(root.left,res);//左
		res.add(root.val);//中
		traversal_Recursion(root.right,res); //右

	}
	
}

迭代遍历（利用栈）



import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

/**
 * @author light
 * @Description 二叉树中序遍历
 * @create 2023-08-13 19:48
 */
public class InorderTraversalTest {
	public static void main(String[] args) {
		Integer[] data={1, 2, 4, null, null, 5, null, null, 3, null, null };
		BinaryTree tree=new BinaryTree(data);
		System.out.println("迭代中序遍历");
		List<Integer> res2=inorderTraversal_Iterate(tree.root);
		System.out.println(res2);
	}

	//迭代遍历
	public static List<Integer> inorderTraversal_Iterate(TreeNode root) {
		List<Integer> list=new ArrayList<>();
		TreeNode cur=root;//用来遍历二叉树
		Deque<TreeNode> stack=new ArrayDeque<>(); //用来存放遍历过的结点
		if(cur==null){
			return list;
		}
		while(cur!=null||!stack.isEmpty()){
			if(cur!=null){
				stack.push(cur);
				cur=cur.left;
			}else {
				cur=stack.pop();
				list.add(cur.val);
				cur=cur.right;
			}
		}
		return list;
	}
}

要向着光
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ACM-二叉树
小喇叭儿滴滴的吹
04-14 882
问题描述       满二叉树         如上图所示，由正整数 1, 2, 3, ...组成了一棵无限大的二叉树。从某一个结点到根结点（编号是 1 的结点）都有一条唯一的路径，比如从 10 到根结点的路径是(10, 5, 2, 1)，从 4 到根结点的路径是(4, 2, 1)，从根结点 1 到根结点的路径上只
acm-二叉树
weixin_43460331的博客
05-11 904
二叉树 二叉树（binary tree,简写成BT）是一种特殊的树型结构，它的度数为2的树。即二叉树的每个结点最多有两个子结点。每个结点的子结点分别称为左孩子、右孩子，它的两棵子树分别称为左子树、右子树。二叉树有5中基本形态： 1.空二叉树 2.仅有根结点的二叉树 3.左子树为空的二叉树 4.右子树为空的二叉树 5.左右子树均非空的二叉树 　　　　　　　　　 前面引入的...
【Java数据结构】二叉树leetcode经典题目详解，一学就会，一看就懂
2401_84558508的博客
05-12 536
面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。此外，都说“面试造火箭，工作拧螺丝”，那对于准备面试的朋友，你只需懂一个字：刷！给我刷刷刷刷，使劲儿刷刷刷刷刷！今天既是来谈面试的，那就必须得来整点面试真题，这不花了我整28天，做了份“Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”
ACM模式下的二叉树的输入
Ling_Ze的博客
08-28 1044
ACM模式下的二叉树的输入
【ACM模式】构建二叉树
qq_39539101的博客
04-22 438
虽然代码随想录处的文章，有关于ACM模式下构建二叉树的代码，但是发现要求输入的用例基本满足完全二叉树的格式输入，一部分用例输入并不能依靠他的代码构建，因为非完全二叉树父子节点间关系不满足i与2*i+1或2*i+2的关系，因此应该以层次遍历的方式构建比较合适
笔试—ACM模式构建二叉树输入输出
qq_39473176的博客
03-26 580
很多笔试都是白板（ACM模式），对于树的题目就需要自己构建二叉树。比如 题目给你一个数组，如何构建成二叉树的输入输出。
ACM金牌选手整理的【LeetCode刷题顺序】1
08-03
二叉树类题目如LeetCode 94的二叉树的中序遍历和LeetCode 104的二叉树的最大深度，这类题目涉及到递归和树的遍历方法，有助于提升对树结构的理解。 算法部分涵盖了模拟、贪心、二分查找、递归和回溯、深度优先搜索...
leetcode分类-acm:拼贴毕业后的acm练习
06-30
leetcode 分类 acm 毕业后吃饱了撑没事干写写题,缅怀以前打ACM的日子. 题目分类 单调栈 题号 题名 难度 简介 类路径 leetcode 739 每日温度 中等 单调栈 或 贪心 leetcode 1544 整理字符串 简单 1.模拟 2.栈 3.递归 ...
ACM模板和一些题目的代码实现（基于C++源代码）
最新发布
06-01
本资源包“ACM模板和一些题目的代码实现”聚焦于C++语言，为学习者提供了一系列ACM竞赛常用的算法模板和LeetCode的经典算法题解。以下是这些知识点的详细说明： 1. **动态规划**：动态规划是一种解决问题的方法，...
acm和leetcode难度-LeetcodeCN-Strategy:LeetcodeCN-策略
07-01
acm和leetcode难度 Description Guide 刷题顺序 题号带☆的为推荐刷的题目 零基础推荐从模拟题开始刷起，掌握一定的刷题能力后，可放弃这部分 刷链表和二叉树的题，这两部分的题需要一定的代码能力，而且也是面试中...
leetcode过桥问题-leetcode-practice:Leetcode题，ACM题刷题汇总
07-01
leetcode过桥问题 Leetcode Learning 主要涉及到的算法思想： 回溯 递归 TopK最大 动态规划 归并 新增 python_algorithm 实现：主要基于python实现各种数据结构，常用算法 新增 Cplus_algorithm 实现：利用C++实现...
北航ACM高人写的关于二叉树的一些操作
05-08
北航ACM高人写的关于二叉树的一些操作，实现了二叉树主要的功能
ACM-模拟-STL HDU1622二叉树程序遍历（路径）+map应用
CS_W98的博客
04-17 325
样例(11,LL) (7,LLL) (8,R) (5,) (4,L) (13,RL) (2,LLR) (1,RRR) (4,RR) () (3,L) (4,R) ()5 4 8 11 13 4 7 2 1 not complete（a,b)括号里表示路径是b的节点值为a，（）为不同的树的分隔符。 求遍历的结果，同时判断这些节点是否真的可以形成二叉树将路径作为字符串压入map里，map查找可以更快同
ACM模式如何构建二叉树
qq_51625182的博客
10-29 1435
ACM模式如何构建二叉树
ACM二叉树学习总结二
qq_43627086的博客
05-15 341
二叉树基本概念: 二叉树（binary tree,简写成BT）是一种特殊的树型结构，它的度数为2的树。即二叉树的每个结点最多有两个子结点。每个结点的子结点分别称为左孩子、右孩子，它的两棵子树分别称为左子树、右子树。 前面引入的树的术语也基本适用于二叉树，但二叉树与树也有很多不同，如：首先二叉树的每个结点至多只能有两个结点，二叉树可以为空，二叉树一定是有序的，通过它的左、右子树关系体现出...
ACM树及二叉树学习总结
qq_43627086的博客
05-11 474
树的概念: 一棵树是由n（n>0）个元素组成的有限集合，其中： （1）每个元素称为结点(node)； （2）有一个特定的结点，称为根结点或树根（root）； （3）除根结点外，其余结点能分成m（m>=0）个互不相交的有限集合T0,T1,T2,……Tm-1。其中的每个子集又都是一棵树，这些集合称为这棵树的子树。 树的存储结构:方法1：数组，称为“父亲表示法”。 　　const int m...
ACM:遍历二叉树
Wangpeiyi9979的博客
09-13 490
文章目录一、题目大意二、解题思路三、代码 一、题目大意 给出二叉树的前序与中序遍历，输出其后续遍历 二、解题思路 使用递归建树，然后递归遍历。 每次递归执行以下图示过程: 当框中为空时停止递归过程 三、代码 #include<iostream> using namespace std; const int MAX = 27; struct Node { Node* left...
UVA - 548 Tree 二叉树
弱智就要多努力
07-10 737
题目：http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=19105 题意：给定一棵二叉树的中序和后序序列，求从根节点到所有叶子节点的最短路径上的叶子节点，最短路径是指所经过节点的权值和最小，若有多个最短路径，那么取其中叶子节点的最小值 思路：首先构造二叉树。根据对于给定的后序序列，最后一个值肯定是二叉树的根节点，找到中序
ACM二叉树遍历C++
加油加油
05-16 200
3384. 二叉树遍历 - AcWing题库 3598. 二叉树遍历 - AcWing题库
苏大Python复试上机：LeetCode高频题集——英语字母顺序挑战
在苏州大学的Python复试上机环节，学生可能会被要求解决一系列来自LeetCode的编程问题，以检验他们的编程能力和对Python的理解。这些题目涵盖了多个主题，包括但不限于字符串处理、数组操作、哈希表应用、数学算法、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值