Java二叉树问题集合

最新推荐文章于 2022-11-14 21:26:17 发布
最新推荐文章于 2022-11-14 21:26:17 发布
阅读量387 收藏
点赞数
分类专栏： Java总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_26888717/article/details/48998021
版权


1、递归将二叉树转换为有向链表

2、递归分层遍历二叉树

迭代分层遍历二叉树

3、递归前序遍历

迭代前序遍历

4、递归中序遍历

迭代中序遍历

5、递归后序遍历

迭代后序遍历

6、递归求二叉树深度

迭代求二叉树深度

7、递归求某一节点的深度

迭代求某一节点深度

8、递归求二叉树节点个数

迭代求二叉树节点个数

9、递归求二叉树最大路径和




import java.util.*;

public class BinaryTreeSet {
	public static void main(String[] args){
		Node root=new Node(3);
		root.left=new Node(5);
		root.right=new Node(4);
		root.left.left=new Node(1);
		root.left.left.right=new Node(10);
		root.left.right=new Node(2);
		root.right.left=new Node(7);
		root.right.right=new Node(8);
		root.right.left.left=new Node(6);
		root.right.left.right=new Node(9);
		BinTree bt=new BinTree();
		int totaln=bt.nodeNum2(root);
		System.out.println("总节点数为："+totaln);
		int maxn=bt.maxPathSum(root);
		System.out.println("最大路径和为："+maxn);
		int value1=2;
		System.out.println(value1+"在第"+bt.getLayor(root, value1,1)+"层");
		System.out.println(value1+"在第"+bt.getLayor2(root, value1)+"层");
		int dep1=bt.getDepth(root);
		int dep2=bt.getDepth2(root);
		System.out.println("总深度为："+dep1+"和"+dep2);
		System.out.print("前序遍历结果:");
		bt.preOrderTravel(root);
		System.out.println();
		System.out.print("前序遍历结果:");
		bt.preOrderTravel2(root);
		System.out.println();
		System.out.print("中序遍历结果:");
		bt.inOrderTravel(root);
		System.out.println();
		System.out.print("中序遍历结果:");
		bt.inOrderTravel2(root);
		System.out.println();
		System.out.print("后序遍历结果:");
		bt.postOrderTravel(root);
		System.out.println();
		System.out.print("后序遍历结果:");
		bt.postOrderTravel2(root);
		System.out.println();
		System.out.print("分层遍历二叉树：");
		bt.levelTraversal(root);
		System.out.println();
		System.out.print("分层遍历二叉树：");
		bt.levelTraversal2(root);
		System.out.println();
		System.out.print("转换为双向链表：");
		Node node2=bt.convertBST2DLLRec(root);
		bt.printList(node2);
		System.out.println();
		
		System.out.println();
		
	}
}


class BinTree{
	public BinTree(){
		
	}
	 
	
	//打印链表
	public void printList(Node root){
		while(root!=null){
			System.out.print(root.val+" ");
			root=root.right;
		}
	}
	
	//将二叉树变为有序的双向链表
	public Node convertBST2DLLRec(Node root) {  
        root = convertBST2DLLSubRec(root);         
        // root会在链表的中间位置，因此要手动把root移到链表头  
        while(root.left != null){  
            root = root.left;  
        }  
        return root;  
    }
	// 递归转换BST为双向链表(DLL)
    public Node convertBST2DLLSubRec(Node root){  
        if(root==null || (root.left==null && root.right==null)){  
            return root;
        }
        Node tmp = null;  
        if(root.left != null){          // 处理左子树  
            tmp = convertBST2DLLSubRec(root.left);  
            while(tmp.right != null){   // 寻找最右节点  
                tmp = tmp.right;  
            }
            tmp.right = root;       // 把左子树处理后结果和root连接  
            root.left = tmp;  
        }
        if(root.right != null){     // 处理右子树  
            tmp = convertBST2DLLSubRec(root.right);  
            while(tmp.left != null){    // 寻找最左节点  
                tmp = tmp.left;  
            }  
            tmp.left = root;        // 把右子树处理后结果和root连接  
            root.right = tmp;  
        }  
        return root;  
    } 
	
	//分层遍历二叉树
	//递归
	public void levelTraversal(Node root){
		ArrayList<ArrayList<Integer>> ret=new ArrayList<ArrayList<Integer>>();
		dfs(root,0,ret);
		for(int i=0;i<ret.size();i++){
			for(int j=0;j<ret.get(i).size();j++){
				System.out.print(ret.get(i).get(j)+" ");
			}
		}
	}
	public void dfs(Node root,int level,ArrayList<ArrayList<Integer>> ret){
		if(root==null)
			return;
		if(level>=ret.size()){
			ret.add(new ArrayList<Integer>());
		}
		ret.get(level).add(root.val);
		dfs(root.left,level+1,ret);
		dfs(root.right,level+1,ret);
	}
	
	//迭代
	public void levelTraversal2(Node root){
		if(root==null)
			return;
		LinkedList<Node> queue=new LinkedList<Node>();
		queue.add(root);
		while(!queue.isEmpty()){
			Node cur=queue.removeFirst();
			System.out.print(cur.val+" ");
			if(cur.left!=null){
				queue.add(cur.left);
			}
			if(cur.right!=null){
				queue.add(cur.right);
			}
		}
	}
	
	
	//======前序遍历======================================
	//递归
	public void preOrderTravel(Node root){
		if(root==null)
			return;
		System.out.print(root.val+" ");
		preOrderTravel(root.left);
		preOrderTravel(root.right);
	}
	//迭代
	public void preOrderTravel2(Node root){
		if(root==null)
			return;
		Stack<Node> stack=new Stack<Node>();
		stack.push(root);
		while(!stack.isEmpty()){
			Node cur=stack.pop();
			System.out.print(cur.val+" ");
			if(cur.right!=null){
				stack.push(cur.right);
			}
			if(cur.left!=null){
				stack.push(cur.left);
			}
		}
	}
	
	//中序遍历
	//递归
	public void inOrderTravel(Node root){
		if(root==null){
			return;
		}
		inOrderTravel(root.left);
		System.out.print(root.val+" ");
		inOrderTravel(root.right);
	}
	//中序遍历迭代解法 ，用栈先把根节点的所有左孩子都添加到栈内， 
    // 然后输出栈顶元素，再处理栈顶元素的右子树 
	//迭代
	public void inOrderTravel2(Node root){
		if(root==null){
			return;
		}
		Stack<Node> stack=new Stack<Node>();
		Node cur=root;
		while(true){
			while(cur!=null){
				stack.push(cur);
				cur=cur.left;
			}
			if(stack.isEmpty()){
				break;
			}
			cur=stack.pop();
			System.out.print(cur.val+" ");
			cur=cur.right;
		}		
	}	
	
	//后序遍历
	//递归
	public void postOrderTravel(Node root){
		if(root==null){
			return;
		}
		postOrderTravel(root.left);
		postOrderTravel(root.right);
		System.out.print(root.val+" ");
	}
	//迭代
	//第二个stack用来翻转第一个stack
	public void postOrderTravel2(Node root){
		if(root==null){
			return;
		}
		Stack<Node> stack=new Stack<Node>();
		Stack<Node> outStack=new Stack<Node>();
		stack.push(root);
		while(!stack.isEmpty()){
			Node cur=stack.pop();
			outStack.push(cur);
			if(cur.left!=null){
				stack.push(cur.left);
			}
			if(cur.right!=null){
				stack.push(cur.right);
			}
		}
		while(!outStack.isEmpty()){
			System.out.print(outStack.pop().val+" ");
		}
	}
	

	//======求二叉树深度================================================
	//递归
	public int getDepth(Node root){
		if(root==null){
			return 0;
		}
		int ldep=getDepth(root.left);
		int rdep=getDepth(root.right);
		return Math.max(ldep, rdep)+1;
	}
	//迭代
	public int getDepth2(Node root){
		if(root==null)
			return 0;
		int depth=0;
		int currentnum=1;
		int nextnum=0;
		Queue<Node> queue=new LinkedList<Node>();
		queue.add(root);
		while(!queue.isEmpty()){
			Node cur=queue.remove();
			currentnum--;
			if(cur.left!=null){
				queue.add(cur.left);
				nextnum++;
			}
			if(cur.right!=null){
				queue.add(cur.right);
				nextnum++;
			}
			if(currentnum==0){
				depth++;
				currentnum=nextnum;
				nextnum=0;
			}
		}
		return depth;
	}
	
	
	//======求某一节点的深度======================================
	//递归
	public int getLayor(Node root,int n,int l){
		if(root==null){
			return -1;
		}
		int i=-1;
		if(root.val==n){
			return l;
		}
		if((i=getLayor(root.left,n,l+1))!=-1){
			return i;
		}
		if((i=getLayor(root.right,n,l+1))!=-1){
			return i;
		}
		return i;
	}
	//迭代方法
	public int getLayor2(Node root,int n){
		int num=1;
		if(root.val==n){
			return 1;
		}
		Queue<Node> queue=new LinkedList<Node>();
		queue.add(root);
		Node cur=root;
		while(!queue.isEmpty()){
			cur=queue.remove();
			if(cur.left!=null){
				queue.add(cur.left);
				cur.left.parent=cur;
				if(cur.left.val==n)
					break;
			}
			if(cur.right!=null){
				queue.add(cur.right);
				cur.right.parent=cur;
				if(cur.right.val==n)
					break;
			}
		}
		while(cur.parent!=null){
			cur=cur.parent;
			num++;
		}
		return num+1;
	}
	
	//======求二叉树节点个数================================================
	//递归方法
	public int nodeNum(Node root){
		if(root==null){
			return 0;
		}
		else{
			return(nodeNum(root.left)+nodeNum(root.right)+1);
		}
	}
	//迭代方法
	public int nodeNum2(Node root){
		if(root==null){
			return 0;
		}
		int num=1;
		ArrayList<Node> al=new ArrayList<Node>();
		al.add(root);
		while(!al.isEmpty()){
			if(al.get(0).left!=null){
				al.add(al.get(0).left);
				num++;
			}
			if(al.get(0).right!=null){
				al.add(al.get(0).right);
				num++;
			}
			al.remove(0);
		}
		return num;
	}
	
	//======以下求二叉树最大路径和============================================
	//max为每次递归之后的最大路径和
	private int max;
	//travel函数递归执行子树并求子树的最大路径
	private int travel(Node node){
		int val=node.val;
		//lval,rval分别为左子树和右子树的最大路径值
		int lval=0,rval=0;
		//result是可以返回给上一级树的路径值
		int result=val;
		/*
		 * 每次的travel函数中max是该级子树的最大路径值（该级子树最大路径值并不一定可以返回给上一级）
		 * 只有val,val+lval,val+rval其中之一才可以返回给上一级
		 * 关键的是，max用来保存所有子树的最大路径值
		 */
		//逐级寻找应该返回到上一级的result和当前最大max
		if(node.left!=null){
			lval=travel(node.left);
			if(lval>0){
				result=val+lval;
			}
			if(max<lval){
				max=lval;
			}
		}		
		if(node.right!=null){
			rval=travel(node.right);
			if(result<val+rval){
				result=val+rval;
			}
			if(max<rval){
				max=rval;
			}
		}
		if(max<result){
			max=result;
		}
		if(max<val+lval+rval){
			max=val+lval+rval;
		}
		return result;
	}
	public int maxPathSum(Node root){
		max=Integer.MIN_VALUE;
		travel(root);
		return max;
	}
}

//节点类
class Node{
	int val;
	Node left;
	Node right;
	Node parent;
	public Node(int x){
		this.val=x;
	}
}



运行结果： 

总节点数为：9
最大路径和为：30
2在第3层
2在第3层
总深度为：4和4
前序遍历结果:3 5 1 2 4 7 6 9 8 
前序遍历结果:3 5 1 2 4 7 6 9 8 
中序遍历结果:1 5 2 3 6 7 9 4 8 
中序遍历结果:1 5 2 3 6 7 9 4 8 
后序遍历结果:1 2 5 6 9 7 8 4 3 
后序遍历结果:1 2 5 6 9 7 8 4 3 
分层遍历二叉树：3 5 4 1 2 7 8 6 9 
分层遍历二叉树：3 5 4 1 2 7 8 6 9 
转换为双向链表：1 5 2 3 6 7 9 4 8




zqy0115
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构java版之二叉树（基础知识篇）
weixin_58850105的博客
01-18 878
一、树 1.相关概念 2.树的表示形式 二、二叉树 1.概念 2. 两种特殊的二叉树 3. 二叉树的性质 4.二叉树的存储 5.二叉树的基本操作 ① 前置说明 ②二叉树的遍历 （1）前中后序遍历 目录 一、树 1.相关概念 2.树的表示形式 二、二叉树 1.概念 2. 两种特殊的二叉树 3. 二叉树的性质 4.二叉树的存储 5.二叉树的基本操作 ① 前置说明 ②二叉树的遍历 （1）前中后序遍历 （2）层序遍历 一、树 1.相关概念 1.树的概念 树
Java二叉树问题
weixin_44772874的博客
10-03 91
二叉树： 链式表示法： 利用树的结点表示二叉树，类似链表 class Node{ int val; Node left; //左孩子，左子树的根 Node right; //右孩子，右子树的根 } 求叶子结点的个数： private static int leafSize = 0; private static void getLeafSize(Node root) { ...
java集合：二叉树
LandscapeMi
01-15 556
二叉树结点 // Class for storing a single node of a binary tree of intspublic class IntTreeNode { public int data; public IntTreeNode left; public IntTreeNode right; // constructs a leaf node
二叉树的java集合（遍历等）
hanjiaqun的博客
09-10 1072
package tree; import java.util.*; /**  * 二叉树的集合：遍历，打印，树的深度  *   *  */ public class BinaryTree { public static void main(String[] args) {         Node root=new Node(3);           root
java 二叉树的问题_求助关于 Java 创建二叉树的问题
weixin_33942142的博客
03-02 82
[输入形式]首先输入一个 n ( 0 到 n-1 编号)表示树中节点的个数，接下来 n-1 行每行有两个整数 a，b，表示 a 是 b 的父亲(建树统一先建左孩子后建右孩子)，最后分别输出前序，中序，后续遍历的编号(每种遍历结果占一行，每行每个编号之间有一个空格，输出的第一个编号前没有空格，输出的最后一个编号后没有空格)。例如：4 个节点，1 是 0 的左孩子，2 是 0 的右孩子，3 是 1 的...
java集合分类总结.doc
12-21
Java集合分类总结 Java集合分类总结是Java语言中的一种容器，用于存储和管理多个对象。集合可以自动扩容，部分集合允许存放不同类型的元素。集合的主要分类有List、Set、Map等。 List集合是一种有序列表，允许存放...
Java集合总结.txt
06-03
单个集合的学习路线：使用->做实验->画图->分析源码 集合：大小可变的序列，只能存放对象 集合和数组的区别： 1.集合是大小可变的序列，数组在声明后... 数据结构：二叉树 运用：自然排序 Map --- Map接口 特
java集合三种比较器（详解）
12-21
概述： 在java集合中，TreeSet集合和TreeMap集合底层数据结构都是自平衡二叉树，所以在这两个集合中添加元素的时候会实现自动排序，排序方式为中序排序(即左根右的方式进行排序，详情请见二叉树数据结构，这里不做...
数据结构java树与二叉树PPT课件.pptx
10-12
"数据结构java树与二叉树PPT课件.pptx" 本资源是关于数据结构中的树和二叉树的PPT课件，共51页。该资源对树和二叉树的定义、基本术语、类型、遍历方法等进行了详细的介绍。 树的定义： 树是由n(n≥0)个有限数据...
Java学习资料，二叉树，AVL，红黑树
最新发布
01-18
chapter-01 - git 操作命令 【 √ 】 chapter-02 - java 基础 【 △ 】 chapter-03 - 数据结构与算法 【 △ 】 chapter-14 - java 集合 【 △ 】 chapter-19 - java IO 流 【 √ 】 chapter-23 - java 反射 【 × 】
java集合二叉树_Java自学-集合框架 二叉树
weixin_28738021的博客
02-27 140
Java集合框架 二叉树示例 1 : 二叉树概念二叉树由各种节点组成二叉树特点：每个节点都可以有左子节点，右子节点每一个节点都有一个值package collection;public class Node {// 左子节点public Node leftNode;// 右子节点public Node rightNode;// 值public Object value;}示例 2 : 二叉树排序-...
java集合二叉树,Java自学-集合框架 二叉树
weixin_34264495的博客
03-16 86
Java集合框架 二叉树示例 1 : 二叉树概念二叉树由各种节点组成 二叉树特点： 每个节点都可以有左子节点，右子节点 每一个节点都有一个值 package collection;public class Node {// 左子节点public Node leftNode;// 右子节点public Node rightNode;// 值public Object value;}示例 2 : 二叉...
二叉树问题
梵高话葵
02-08 108
1.输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） 分析 /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = ...
二叉树详解（Java）
weixin_45969711的博客
11-14 1367
也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。先访问左子节点，左子节点不为空就递归中序遍历，再访问根节点，然后再访问右子节点，右子节点不为空就递归中序遍历。先访问左子节点，左子节点不为空就递归后序遍历，再访问右子节点，右子节点不为空就递归后序遍历，然后再访问根节点。先访问根节点，再访问左节点，左节点不为空就递归前序遍历，再访问右节点，右节点不为空就递归前序遍历。若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=Log2(n+1)
JAVA基础——集合&二叉树&红黑树
weixin_64310048的博客
06-20 199
1、Collection （单列集合的顶级接口）方法名说明boolean add(E e)添加元素boolean remove(Object o)从集合中移除指定的元素boolean removeIf(Object o)根据条件进行移除void clear()清空集合中的元素boolean contains(Object o)判断集合中是否存在指定的元素boolean isEmpty()判断集合是否为空int size()集合的长度，也就是集合中元素的个数方法名说明public static void so
JAVA面试之二叉树问题
欢迎来到Super腾的世界
03-26 2495
**最近刷面试题的时候发现各大公司对二叉树的算法情有独钟，所以花时间研究了一下，用JAVA实现了包括二叉树的添加节点，前序中序后序遍历，按层遍历，以及树的深度的计算。 在贴代码之前对树的原意考的基本理念复习一下。** 树是属于一种非线性的数据结构 存储分为顺序存储用数组和链式存储 树通常研究的是二叉树 二叉树又分为二叉堆和二叉查找树 二叉堆一般用顺序存储来进行存储 因为二叉堆一般都是完全二叉树
Java之TreeSet集合(二叉树实现)以及Comparable接口介绍
Daniel丶
10-22 2590
TreeSet 集合类是Set的子类 固有保持数据不重复的属性，除此之外还有一个独有的功能就是排序 当然常见的Integer，String类中java都将其比较机制写的很完善了 但对于自定义类而言 ，想要去排序就要自己去实现了 假设录入一个 Person类 (new Person(“aa”,100))其属性为姓名和年龄 假设要求我需要对集合中Person的年龄进行排序的话 我们该怎么办呢？ Tre...
Java-TreeSet集合，二叉树
MinggeQingchun的博客
02-25 1374
一、TreeSet 1、TreeSet集合底层实际上是一个TreeMap；TreeMap集合底层是一个二叉树 2、放到TreeSet集合中的元素，等同于放到TreeMap集合key部分了。 3、TreeSet集合存储元素特点：无序不可重复的，但是存储的元素可以自动按照大小顺序排序 称为：可排序集合。 无序指的是存进去的顺序和取出来的顺序不同，并且没有下标 public static void main(String[] args) { TreeSet<String&gt.
Java集合框架之二叉树
weixin_43958974的博客
11-12 300
1. 二叉树概念 二叉树由各种节点组成。 二叉树特点： 每个节点都可以有左子节点，右子节点 每一个节点都有一个值 2. 二叉树排序-插入数据 假设通过二叉树对如下10个随机数进行排序：67,7,30,73,10,0,78,81,10,74。 排序的第一个步骤是把数据插入到该二叉树中，插入基本逻辑是，小、相同的放左边，大的放右边。 67 放在根节点; 7 比 67小，放在67的左节点; ...
java中什么集合的原理是二叉树
05-31
Java中的TreeSet和TreeMap集合的原理是二叉树。 TreeSet是一种有序的、基于红黑树实现的集合，它可以确保元素按照自然顺序或者指定的比较器顺序进行排序。TreeSet中的元素必须是可比较的，因为它们需要能够按照顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值