Java面试宝典之二叉树的实现

最新推荐文章于 2022-11-19 20:05:18 发布
最新推荐文章于 2022-11-19 20:05:18 发布
阅读量729 收藏 1
点赞数
分类专栏： java 文章标签： Java 面试题 数据结构 二叉树

我们接着上一篇数据结构继续讲解。本章系数据结构之树与二叉树，从这章开始，我们就要介绍非线性结构了，这些内容理解起来比线性表稍难一些，我尽量写的通俗一些，如果读的过程中有任何问题，请按上述方式联系我！

一、树

树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。它非常类似于自然界中的树。树结构在客观世界中是大量存在的，例如家谱、行政组织机构都可用树形象地表示。树在计算机领域中也有着广泛的应用，例如在编译程序中，用树来表示源程序的语法结构；在数据库系统中，可用树来组织信息；在分析算法的行为时，可用树来描述其执行过程。本章重点讨论二叉树的存储表示及其各种运算，并研究一般树和森林与二叉树的转换关系，最后介绍树的应用实例。

二、二叉树

二叉树(BinaryTree)是n(n≥0)个结点的有限集，它或者是空集(n=0)，或者由一个根结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。关于更多概念，请大家自己上网查询，我们这里将用代码实现常见的算法。更多的概念，请访问：http://student.zjzk.cn/course_ware/data_structure/web/SHU/shu6.2.3.1.htm 。

1、二叉树的建立

首先，我们采用广义表建立二叉树（关于广义表的概念，请查看百科的介绍：http://baike.baidu.com/view/203611.htm）

我们建立一个字符串类型的广义表作为输入：

String  expression = "A(B(D(,G)),C(E,F))";与该广义表对应的二叉树为：


写代码前，我们通过观察二叉树和广义表，先得出一些结论：

  • 每当遇到字母，将要创建节点
  • 每当遇到“（”，表面要创建左孩子节点
  • 每当遇到“，”，表明要创建又孩子节点
  • 每当遇到“）”，表明要返回上一层节点
  • 广义表中“（”的数量正好是二叉树的层数

根据这些结论，我们基本就可以开始写代码了。首先建议一个节点类（这也属于一种自定义的数据结构）。

[java] view plain copy print ?
  1. package com.xtfggef.algo.tree;  
  2.   
  3. public class Node {  
  4.   
  5.     private char data;  
  6.     private Node lchild;  
  7.     private Node rchild;  
  8.   
  9.     public Node(){  
  10.           
  11.     }  
  12.     public char getData() {  
  13.         return data;  
  14.     }  
  15.   
  16.     public void setData(char data) {  
  17.         this.data = data;  
  18.     }  
  19.   
  20.     public Node getRchild() {  
  21.         return rchild;  
  22.     }  
  23.   
  24.     public void setRchild(Node rchild) {  
  25.         this.rchild = rchild;  
  26.     }  
  27.   
  28.     public Node getLchild() {  
  29.         return lchild;  
  30.     }  
  31.   
  32.     public void setLchild(Node lchild) {  
  33.         this.lchild = lchild;  
  34.     }  
  35.   
  36.     public Node(char ch, Node rchild, Node lchild) {  
  37.         this.data = ch;  
  38.         this.rchild = rchild;  
  39.         this.lchild = lchild;  
  40.     }  
  41.   
  42.     public String toString() {  
  43.         return "" + getData();  
  44.     }  
  45. }  
package com.xtfggef.algo.tree;

public class Node {

	private char data;
	private Node lchild;
	private Node rchild;

	public Node(){
		
	}
	public char getData() {
		return data;
	}

	public void setData(char data) {
		this.data = data;
	}

	public Node getRchild() {
		return rchild;
	}

	public void setRchild(Node rchild) {
		this.rchild = rchild;
	}

	public Node getLchild() {
		return lchild;
	}

	public void setLchild(Node lchild) {
		this.lchild = lchild;
	}

	public Node(char ch, Node rchild, Node lchild) {
		this.data = ch;
		this.rchild = rchild;
		this.lchild = lchild;
	}

	public String toString() {
		return "" + getData();
	}
}
根据广义表创建二叉树的代码如下：

[java] view plain copy print ?
  1. public Node createTree(String exp) {  
  2.         Node[] nodes = new Node[3];  
  3.         Node b, p = null;  
  4.         int top = -1, k = 0, j = 0;  
  5.         char[] exps = exp.toCharArray();  
  6.         char data = exps[j];  
  7.         b = null;  
  8.         while (j < exps.length - 1) {  
  9.             switch (data) {  
  10.             case '(':  
  11.                 top++;  
  12.                 nodes[top] = p;  
  13.                 k = 1;  
  14.                 break;  
  15.             case ')':  
  16.                 top--;  
  17.                 break;  
  18.             case ',':  
  19.                 k = 2;  
  20.                 break;  
  21.             default:  
  22.                 p = new Node(data, null, null);  
  23.                 if (b == null) {  
  24.                     b = p;  
  25.                 } else {  
  26.                     switch (k) {  
  27.                     case 1:  
  28.                         nodes[top].setLchild(p);  
  29.                         break;  
  30.                     case 2:  
  31.                         nodes[top].setRchild(p);  
  32.                         break;  
  33.                     }  
  34.                 }  
  35.             }  
  36.             j++;  
  37.             data = exps[j];  
  38.         }  
  39.         return b;  
  40.     }  
public Node createTree(String exp) {
		Node[] nodes = new Node[3];
		Node b, p = null;
		int top = -1, k = 0, j = 0;
		char[] exps = exp.toCharArray();
		char data = exps[j];
		b = null;
		while (j < exps.length - 1) {
			switch (data) {
			case '(':
				top++;
				nodes[top] = p;
				k = 1;
				break;
			case ')':
				top--;
				break;
			case ',':
				k = 2;
				break;
			default:
				p = new Node(data, null, null);
				if (b == null) {
					b = p;
				} else {
					switch (k) {
					case 1:
						nodes[top].setLchild(p);
						break;
					case 2:
						nodes[top].setRchild(p);
						break;
					}
				}
			}
			j++;
			data = exps[j];
		}
		return b;
	}
思路不难，结合上述的理论，自己断点走一遍程序就懂了！

2、二叉树的递归遍历

二叉树的遍历有三种：先序、中序、后序，每种又分递归和非递归。递归程序理解起来有一定的难度，但是实现起来比较简单。对于上述二叉树，其：

    a 先序遍历

            A B D G C E F

    b 中序遍历

           D G B A E C F 

    c 后序遍历

           G D B E F C A

先、中、后序递归遍历如下：

[java] view plain copy print ?
  1. /** 
  2.      * pre order recursive 
  3.      *  
  4.      * @param node 
  5.      */  
  6.     public void PreOrder(Node node) {  
  7.         if (node == null) {  
  8.             return;  
  9.         } else {  
  10.             System.out.print(node.getData() + " ");  
  11.             PreOrder(node.getLchild());  
  12.             PreOrder(node.getRchild());  
  13.   
  14.         }  
  15.     }  
  16.   
  17.     /** 
  18.      * in order recursive 
  19.      *  
  20.      * @param node 
  21.      */  
  22.     public void InOrder(Node node) {  
  23.         if (node == null) {  
  24.             return;  
  25.         } else {  
  26.             InOrder(node.getLchild());  
  27.             System.out.print(node.getData() + " ");  
  28.             InOrder(node.getRchild());  
  29.         }  
  30.     }  
  31.   
  32.     /** 
  33.      * post order recursive 
  34.      *  
  35.      * @param node 
  36.      */  
  37.     public void PostOrder(Node node) {  
  38.         if (node == null) {  
  39.             return;  
  40.         } else {  
  41.             PostOrder(node.getLchild());  
  42.             PostOrder(node.getRchild());  
  43.             System.out.print(node.getData() + " ");  
  44.         }  
  45.     }  
/**
	 * pre order recursive
	 * 
	 * @param node
	 */
	public void PreOrder(Node node) {
		if (node == null) {
			return;
		} else {
			System.out.print(node.getData() + " ");
			PreOrder(node.getLchild());
			PreOrder(node.getRchild());

		}
	}

	/**
	 * in order recursive
	 * 
	 * @param node
	 */
	public void InOrder(Node node) {
		if (node == null) {
			return;
		} else {
			InOrder(node.getLchild());
			System.out.print(node.getData() + " ");
			InOrder(node.getRchild());
		}
	}

	/**
	 * post order recursive
	 * 
	 * @param node
	 */
	public void PostOrder(Node node) {
		if (node == null) {
			return;
		} else {
			PostOrder(node.getLchild());
			PostOrder(node.getRchild());
			System.out.print(node.getData() + " ");
		}
	}
二叉树的递归遍历实现起来很简单，关键是非递归遍历有些难度，请看下面的代码：

3、二叉树的非递归遍历

先序非递归遍历：

[java] view plain copy print ?
  1. public void PreOrderNoRecursive(Node node) {  
  2.         Node nodes[] = new Node[CAPACITY];  
  3.         Node p = null;  
  4.         int top = -1;  
  5.         if (node != null) {  
  6.             top++;  
  7.             nodes[top] = node;  
  8.             while (top > -1) {  
  9.                 p = nodes[top];  
  10.                 top--;  
  11.                 System.out.print(p.getData() + " ");  
  12.                 if (p.getRchild() != null) {  
  13.                     top++;  
  14.                     nodes[top] = p.getRchild();  
  15.                 }  
  16.                 if (p.getLchild() != null) {  
  17.                     top++;  
  18.                     nodes[top] = p.getLchild();  
  19.                 }  
  20.             }  
  21.         }  
  22.     }  
public void PreOrderNoRecursive(Node node) {
		Node nodes[] = new Node[CAPACITY];
		Node p = null;
		int top = -1;
		if (node != null) {
			top++;
			nodes[top] = node;
			while (top > -1) {
				p = nodes[top];
				top--;
				System.out.print(p.getData() + " ");
				if (p.getRchild() != null) {
					top++;
					nodes[top] = p.getRchild();
				}
				if (p.getLchild() != null) {
					top++;
					nodes[top] = p.getLchild();
				}
			}
		}
	}
原理：利用一个栈，先序遍历即为根先遍历，先将根入栈，然后出栈，凡是出栈的元素都打印值，入栈之前top++，出栈之后top--，利用栈后进先出的原理，右节点先于左节点进栈，根出栈后，开始处理左子树，然后是右子树，读者朋友们可以自己走一遍程序看看，也不算难理解！

中序非递归遍历：

[java] view plain copy print ?
  1. public void InOrderNoRecursive(Node node) {  
  2.         Node nodes[] = new Node[CAPACITY];  
  3.         Node p = null;  
  4.         int top = -1;  
  5.         if (node != null)  
  6.             p = node;  
  7.         while (p != null || top > -1) {  
  8.             while (p != null) {  
  9.                 top++;  
  10.                 nodes[top] = p;  
  11.                 p = p.getLchild();  
  12.             }  
  13.             if (top > -1) {  
  14.                 p = nodes[top];  
  15.                 top--;  
  16.                 System.out.print(p.getData() + " ");  
  17.                 p = p.getRchild();  
  18.             }  
  19.         }  
  20.     }  
public void InOrderNoRecursive(Node node) {
		Node nodes[] = new Node[CAPACITY];
		Node p = null;
		int top = -1;
		if (node != null)
			p = node;
		while (p != null || top > -1) {
			while (p != null) {
				top++;
				nodes[top] = p;
				p = p.getLchild();
			}
			if (top > -1) {
				p = nodes[top];
				top--;
				System.out.print(p.getData() + " ");
				p = p.getRchild();
			}
		}
	}
原理省略。

后续非递归遍历：

[java] view plain copy print ?
  1. public void PostOrderNoRecursive(Node node) {  
  2.         Node[] nodes = new Node[CAPACITY];  
  3.         Node p = null;  
  4.         int flag = 0, top = -1;  
  5.         if (node != null) {  
  6.             do {  
  7.                 while (node != null) {  
  8.                     top++;  
  9.                     nodes[top] = node;  
  10.                     node = node.getLchild();  
  11.                 }  
  12.                 p = null;  
  13.                 flag = 1;  
  14.                 while (top != -1 && flag != 0) {  
  15.                     node = nodes[top];  
  16.                     if (node.getRchild() == p) {  
  17.                         System.out.print(node.getData() + " ");  
  18.                         top--;  
  19.                         p = node;  
  20.                     } else {  
  21.                         node = node.getRchild();  
  22.                         flag = 0;  
  23.                     }  
  24.                 }  
  25.             } while (top != -1);  
  26.         }  
  27.     }  
public void PostOrderNoRecursive(Node node) {
		Node[] nodes = new Node[CAPACITY];
		Node p = null;
		int flag = 0, top = -1;
		if (node != null) {
			do {
				while (node != null) {
					top++;
					nodes[top] = node;
					node = node.getLchild();
				}
				p = null;
				flag = 1;
				while (top != -1 && flag != 0) {
					node = nodes[top];
					if (node.getRchild() == p) {
						System.out.print(node.getData() + " ");
						top--;
						p = node;
					} else {
						node = node.getRchild();
						flag = 0;
					}
				}
			} while (top != -1);
		}
	}

三、树与二叉树的转换

本人之前总结的：



这部分概念的其他知识，请读者自己上网查看。

吾爱瑾瑾
关注
专栏目录
2023黑马面试宝典-Java面试宝典大全-java面试宝典黑马
11-16
Java面试宝典是Java程序员求职面试的重要参考资料，它涵盖了Java编程语言的核心概念、高级特性、设计模式、并发处理、框架应用、数据库交互等多个方面。以下将详细解析这些关键知识点： 1. **Java基础**：面试中，...
Java之美[从菜鸟到高手演变]之数据结构基础之树、二叉树
热门推荐
智慧演绎，无处不在
04-21 2万+
树在计算机领域中也有着广泛的应用，例如在编译程序中，用树来表示源程序的语法结构；原理：利用一个栈，先序遍历即为根先遍历，先将根入栈，然后出栈，凡是出栈的元素都打印值，入栈之前top++，出栈之后top--，利用栈后进先出的原理，右节点先于左节点进栈，根出栈后，开始处理左子树，然后是右子树，读者朋友们可以自己走一遍程序看看，也不算难理解！本章系数据结构之树与二叉树，从这章开始，我们就要介绍非线性结构了，这些内容理解起来比线性表稍难一些，我尽量写的通俗一些，如果读的过程中有任何问题，请按上述方式联系我！
Java数据结构与算法（树的进阶）
博客包含书籍、B站、其他博主博客等内容，只为了记录笔记，作业，问题，软件配置等，为了以后方便查阅，如有侵权，请联系删除
07-25 107
2-结点含有一个键(及其对应的值)和两条链，左链接指向2-3树中的键都小于该结点，右链接指向的2-3树中的键都大于该结点。3-结点含有两个键(及其对应的值)和三条链，左链接指向的2-3树中的键都小于该结点，中链接指向的2-3树中的键都位于该结点的两个键之间，右链接指向的2-3树中的键都大于该结点。红链接均为左链接；没有任何一个结点同时和两条红链接相连；该树是完美黑色平衡的，即任意空链接到根结点的路径上的黑链接数量相同；//存储键publicKeykey;...
数据结构-树
coolingxyz的博客
11-20 435
树： 树的概念 树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。它非常类似于自然界中的树。树结构在客观世界中是大量存在的，例如家谱、行政组织机构都可用树形象地表示。树在计算机领域中也有着广泛的应用，例如在编译程序中，用树来表示源程序的语法结构；在数据库系统中，可用树来组织信息；在分析算法的行为时，可用树来描述其执行过程。 二
Java的演变历程(发展史)
数据库
03-28 357
注：技术和语法只是其中的一部分，以影响程度作为选取描述优先顺。 Java语言的前身：Oak（橡树） Java1.0提出了“Write Once，Run Anywhere”的口号 JDK 1.1 技术：JAR文件格式、JDBC、JavaBeans、RMI。 语法：内部类（Inner Class）和反射（Reflection）。 JDK 1.2 把Java技术体系拆分为3个方向，分别是 ...
计算器-二叉树实现
m0_43456002的博客
02-12 1388
#include<iostream> #include<string> #include<stack> using namespace std; //二叉树的结构 typedef struct BiTNode { int data;//数据域 struct BiTNode* lchild = nullptr;//指针必须初始化，c11标准 struct ...
java方向面试宝典.pdf
最新发布
09-14
Java语言是目前广泛应用的编程语言之一，其特点和优势包括：跨平台性（通过Java虚拟机JVM实现），面向对象，自动内存管理（垃圾回收机制），丰富的类库，以及强大的可移植性和安全性。Java虚拟机（JVM）是运行Java...
Java数据结构分析+Java程序员面试宝典
11-23
"Java数据结构分析+Java程序员面试宝典"是帮助准备Java面试的理想资源，它包含了两个核心部分：Java数据结构与算法分析以及Java面试技巧。 首先，让我们深入探讨数据结构。数据结构是组织和存储数据的方式，以便更...
java面试宝典.rar
01-05
Java面试宝典是针对Java开发者在求职面试时必备的学习资料，涵盖了广泛的Java技术知识点和面试常见问题。这份PDF文档很可能是对Java核心技术、面试技巧、以及行业趋势的全面梳理，旨在帮助求职者提升面试成功率。 1...
数据结构-二叉树及其应用
m0_62464074的博客
12-15 1742
实验项目名称 二叉树及其应用 实验要求 树是数据结构中应用极为广泛的非线性结构，本单元的实验达到熟悉二叉树的存储结构的特性，以及如何应用树结构解决具体问题。 实验内容 利用二叉树求解表达式的值。 算法分析 void EXTInitStack(ETLinkStack& LS)// 树栈初始化 { LS = NULL; } void EXTPush(ETLinkStack& LS, ExpTree ET)// 树栈添加元素 { ETStackNode...
二叉树的非递归操作（包括广义表建树、三种遍历方法、以及求节点等）
10-01
用非递归方法做的关于二叉树的 一些操作，存储结构用的是三叉链表，不过主要还是二叉树的东西。
树
weixin_38324954的博客
07-14 268
1.树——非线性数据结构 树在计算机科学的各个领域中被广泛应用：操作系统、图像学、数据库系统、计算机网络 跟自然界中的树一样，数据结构也分为：根、枝和叶等三个部分。一般数据结构的图示把根放在上方，叶放在下方。 2.分类树的特征 （1）分类体系是层次化的。树是一种分层结构，越接近顶部的层越普遍，越接近底部的层越独特。 （2）一个节点的子节点与另一个节点的子节点相互之间是隔离、独立的 猫属Felis和蝇属Musca下面都有Domestica的同名节点，但相互之间并无任何关联，可以修改其中一个Domestica
算法5.12-5.13表达式求值
m0_65185254的博客
11-19 1129
数据结构(树和二叉树)
java中的树_java回顾之树
weixin_31721961的博客
02-16 427
java回顾之树一、计算机中的树　1.2、二叉树如果书中的每个节点的子节点的个数不超过2，那么该树就是一个二叉树1.3二叉查找树1、左子树上所有的节点的值均小于他的父节点的值2、右子树上所有的节点值均大于他的父节点的值3、每一个子节点最多有两个子树二叉查找树的排序：按照左中右的方式就能够获取到从小到大排列的元素。1.4二叉平衡树二叉平衡树是一种特殊的二叉查找树，二叉平衡树最高高度和最低高度高度差绝...
Java - 树状结构数据解析
AugSnow的博客
10-15 7481
由于工作中好多地方需要树状结构数据，在参考了网上递归实现和数据库存储过程实现，都不太满意。突然想到zTree也有解析该类数据的要求，所以在阅读了zTree源码的前提了，按照他的实现原理，写了一个java版的实现方案 @SuppressWarnings("unchecked") public List> parseTree(List> list) { List> resultList = n
java 二叉树面试_二叉树操作（面试必备）
weixin_42321496的博客
02-28 393
本篇针对面试中常见的二叉树操作作个总结：前序遍历，中序遍历，后序遍历；层次遍历；求树的结点数；求树的叶子数；求树的深度；求二叉树第k层的结点个数；判断两棵二叉树是否结构相同；求二叉树的镜像；求两个结点的最低公共祖先结点；求任意两结点距离；找出二叉树中某个结点的所有祖先结点；不使用递归和栈遍历二叉树；二叉树前序中序推后序；判断二叉树是不是完全二叉树；判断是否是二叉查找树的后序遍历结果；给定一个二叉查...
Java面试--二叉树
小刺猬喜歡獨角獸
08-20 3214
面试题:讲一下二叉树的遍历 一、二叉树遍历方式 1、前序遍历：按照“根左右”,先遍历根节点，再遍历左子树 ，再遍历右子树 2、中序遍历：按照“左根右“,先遍历左子树，再遍历根节点，最后遍历右子树 3、后续遍历：按照“左右根”，先遍历左子树，再遍历右子树，最后遍历根节点 二、二叉树遍历的java实现 定义节点类： private static class Bi...
数据结构java版之二叉树（部分offer面试题篇）
weixin_58850105的博客
01-22 1912
目录 一、二叉树的基本操作 1.获取树中节点的个数 2.获取叶子节点的个数 3.子问题思路-求叶子结点个数 4.获取第K层节点的个数 5.获取二叉树的高度 6.检测值为value的元素是否存在 7.判断一棵树是不是完全二叉树 二、二叉树相关oj题 1. 检查两颗树是否相同 2. 另一颗树的子树 3. 二叉树最大深度 4. 判断一颗二叉树是否是平衡二叉树 5. 对称二叉树 6. 二叉树的构建及遍历 7. 二叉树的分层遍历 8. 给定一个二叉树, 找到该树中两个指定节点的最..
二叉树镜像反转实现及Java面试算法指南
"二叉树镜像反转的Java实现及面试算法书籍介绍" 在计算机科学中，二叉树是一种常用的数据结构，它由节点组成，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树的镜像反转是一个常见的操作，它涉及到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值