1.二叉树的概念
- 树有很多种,每个节点最多只能有两个子节点的一种形式称为二叉树。
- 二叉树的子节点分为左节点和右节点。
- 如果该二叉树的所有叶子节点都在最后一层,并且结点总数= 2^n -1 , n 为层数,则我们称为满二叉树。
- 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层,而且最后一层的叶子节点在左边连续,倒数第二层的叶子节点在右边连续,我们称为完全二叉树。
- 树的遍历
前序遍历: 先输出父节点,再遍历左子树和右子树
中序遍历: 先遍历左子树,再输出父节点,再遍历右子树
后序遍历: 先遍历左子树,再遍历右子树,最后输出父节点
小结: 看输出父节点的顺序,就确定是前序,中序还是后序 - 树的查找——查找指定节点
前序查找:先比较父节点,再遍历左子树和右子树
中序查找:先遍历左子树,再比较父节点,再遍历右子树
后序查找:先遍历左子树,再遍历右子树,最后比较父节点
2.前序中序后序遍历二叉树
2.1前序遍历
1.先输出当前节点(初始时是root节点)
2.如果左子节点不为空,则递归继续前序遍历
3.如果右子节点不为空,则递归继续前序遍历
//前序遍历
//1.先输出当前节点(初始时是root节点)
//2.如果左子节点不为空,则递归继续前序遍历
//3.如果右子节点不为空,则递归继续前序遍历
public void preOrder(){
System.out.println(this);
if(this.left!=null){
this.left.preOrder();
}
if(this.right!=null){
this.right.preOrder();
}
}
2.2中序遍历
1.如果左子节点不为空,则递归继续中序遍历
2.输出当前节点
3.如果右子节点不为空,则递归继续中序遍历
//中序遍历
//1.如果左子节点不为空,则递归继续中序遍历
//2.输出当前节点
//3.如果右子节点不为空,则递归继续中序遍历
public void infixOrder(){
if(this.left!=null){
this.left.infixOrder();
}
System.out.println(this);
if(this.right!=null){
this.right.infixOrder();
}
}
2.3后序遍历
1.如果左子节点不为空,则递归继续后序遍历
2.如果右子节点不为空,则递归继续后序遍历
3.输出当前节点
//后序遍历
//1.如果左子节点不为空,则递归继续后序遍历
//2.如果右子节点不为空,则递归继续后序遍历
//3.输出当前节点
public void postOrder(){
if(this.left!=null){
this.left.postOrder();
}
if(this.right!=null){
this.right.postOrder();
}
System.out.println(this);
}
3.前序中序后序查找二叉树
3.1前序查找
1.判断当前结点是否为要查找的结点,如果相等,返回
2.判断左子树是否为空,如果不为空,则递归前序查找
3.判断右子树是否为空,如果不为空,则递归前序查找
//前序查找
//1.判断当前结点是否为要查找的结点,如果相等,返回
//2.判断左子树是否为空,如果不为空,则递归前序查找
//3.判断右子树是否为空,如果不为空,则递归前序查找
public Node preSearch(int val){
Node resNode=null;
//判断当前结点
if(this.val==val){
return this;
}
//在左子树查找
if(this.left!=null){
resNode=this.left.preSearch(val);
}
//如果在左子树找到,返回
if(resNode!=null){
return resNode;
}
//在右子树查找
if(this.right!=null){
resNode=this.right.preSearch(val);
}
//如果在左子树找到,返回
if(resNode!=null){
return resNode;
}
//若未查找到,返回空
return null;
}
3.2中序查找
1.判断左子树是否为空,如果不为空,则递归中序查找
2.判断当前结点是否为要查找的结点,如果相等,返回
3.判断右子树是否为空,如果不为空,则递归中序查找
//中序查找
//1.判断左子树是否为空,如果不为空,则递归中序查找
//2.判断当前结点是否为要查找的结点,如果相等,返回
//3.判断右子树是否为空,如果不为空,则递归中序查找
public Node infixSearch(int val){
Node resNode=null;
//在左子树查找
if(this.left!=null){
resNode=this.left.infixSearch(val);
}
//如果在左子树找到,返回
if(resNode!=null){
return resNode;
}
//判断当前结点
if(this.val==val){
return this;
}
//在右子树查找
if(this.right!=null){
resNode=this.right.infixSearch(val);
}
//如果在右子树找到,返回
if(resNode!=null){
return resNode;
}
//若未查找到,返回空
return null;
}
3.3后序查找
1.判断左子树是否为空,如果不为空,则递归后序查找
2.判断右子树是否为空,如果不为空,则递归后序查找
3.判断当前结点是否为要查找的结点,如果相等,返回
//后序查找
//1.判断左子树是否为空,如果不为空,则递归后序查找
//2.判断右子树是否为空,如果不为空,则递归后序查找
//3.判断当前结点是否为要查找的结点,如果相等,返回
public Node postSearch(int val){
Node resNode=null;
//在左子树查找
if(this.left!=null){
resNode=this.left.postSearch(val);
}
//如果在左子树找到,返回
if(resNode!=null){
return resNode;
}
//在右子树查找
if(this.right!=null){
resNode=this.right.postSearch(val);
}
//如果在右子树找到,返回
if(resNode!=null){
return resNode;
}
//判断当前结点
if(this.val==val){
return this;
}
//若未查找到,返回空
return null;
}
4.具体实现
//定义BinaryTree 二叉树
class BinaryTree{
private Node root; //根节点
public Node getRoot() {
return root;
}
public void setRoot(Node root) {
this.root = root;
}
//前序遍历
public void preOrder(){
if(this.root!=null){
this.root.preOrder();
}
else{
System.out.println("当前二叉树为空,无法遍历");
}
}
//中序遍历
public void infixOrder(){
if(this.root!=null){
this.root.infixOrder();
}
else{
System.out.println("当前二叉树为空,无法遍历");
}
}
//中序遍历
public void postOrder(){
if(this.root!=null){
this.root.postOrder();
}
else{
System.out.println("当前二叉树为空,无法遍历");
}
}
//前序查找
public Node preSearch(int val){
if(this.root!=null){
return this.root.preSearch(val);
}
else{
System.out.println("当前二叉树为空,无法遍历");
return null;
}
}
//中序查找
public Node infixSearch(int val){
if(this.root!=null){
return this.root.infixSearch(val);
}
else{
System.out.println("当前二叉树为空,无法遍历");
return null;
}
}
//后序查找
public Node postSearch(int val){
if(this.root!=null){
return this.root.postSearch(val);
}
else{
System.out.println("当前二叉树为空,无法遍历");
return null;
}
}
//删除结点
public void delNode(int val){
if(this.root!=null){
//如果删除的结点是根结点
if(this.root.getVal()==val){
this.root=null;
}
else{
this.root.delNode(val);
}
}
else{
System.out.println("树为空,不能删除");
}
}
}
//创建Node结点
class Node{
private int val;
private Node left;
private Node right;
//构造器
public Node(int val) {
super();
this.val = val;
}
public int getVal() {
return val;
}
public void setVal(int val) {
this.val = val;
}
public Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node right) {
this.right = right;
}
@Override
public String toString() {
return "Node [val=" + val + "]";
}
//前序遍历
//1.先输出当前节点(初始时是root节点)
//2.如果左子节点不为空,则递归继续前序遍历
//3.如果右子节点不为空,则递归继续前序遍历
public void preOrder(){
System.out.println(this);
if(this.left!=null){
this.left.preOrder();
}
if(this.right!=null){
this.right.preOrder();
}
}
//中序遍历
//1.如果左子节点不为空,则递归继续中序遍历
//2.输出当前节点
//3.如果右子节点不为空,则递归继续中序遍历
public void infixOrder(){
if(this.left!=null){
this.left.infixOrder();
}
System.out.println(this);
if(this.right!=null){
this.right.infixOrder();
}
}
//后序遍历
//1.如果左子节点不为空,则递归继续后序遍历
//2.如果右子节点不为空,则递归继续后序遍历
//3.输出当前节点
public void postOrder(){
if(this.left!=null){
this.left.postOrder();
}
if(this.right!=null){
this.right.postOrder();
}
System.out.println(this);
}
//前序查找
//1.判断当前结点是否为要查找的结点,如果相等,返回
//2.判断左子树是否为空,如果不为空,则递归前序查找
//3.判断右子树是否为空,如果不为空,则递归前序查找
public Node preSearch(int val){
Node resNode=null;
//判断当前结点
if(this.val==val){
return this;
}
//在左子树查找
if(this.left!=null){
resNode=this.left.preSearch(val);
}
//如果在左子树找到,返回
if(resNode!=null){
return resNode;
}
//在右子树查找
if(this.right!=null){
resNode=this.right.preSearch(val);
}
//如果在左子树找到,返回
if(resNode!=null){
return resNode;
}
//若未查找到,返回空
return null;
}
//中序查找
//1.判断左子树是否为空,如果不为空,则递归中序查找
//2.判断当前结点是否为要查找的结点,如果相等,返回
//3.判断右子树是否为空,如果不为空,则递归中序查找
public Node infixSearch(int val){
Node resNode=null;
//在左子树查找
if(this.left!=null){
resNode=this.left.infixSearch(val);
}
//如果在左子树找到,返回
if(resNode!=null){
return resNode;
}
//判断当前结点
if(this.val==val){
return this;
}
//在右子树查找
if(this.right!=null){
resNode=this.right.infixSearch(val);
}
//如果在右子树找到,返回
if(resNode!=null){
return resNode;
}
//若未查找到,返回空
return null;
}
//后序查找
//1.判断左子树是否为空,如果不为空,则递归后序查找
//2.判断右子树是否为空,如果不为空,则递归后序查找
//3.判断当前结点是否为要查找的结点,如果相等,返回
public Node postSearch(int val){
Node resNode=null;
//在左子树查找
if(this.left!=null){
resNode=this.left.postSearch(val);
}
//如果在左子树找到,返回
if(resNode!=null){
return resNode;
}
//在右子树查找
if(this.right!=null){
resNode=this.right.postSearch(val);
}
//如果在右子树找到,返回
if(resNode!=null){
return resNode;
}
//判断当前结点
if(this.val==val){
return this;
}
//若未查找到,返回空
return null;
}
//递归删除结点
//1.判断当前结点的左右结点是否满足删除条件,若满足,删除,return
//2.若左结点不为空,递归删除左子树
//3.若右结点不为空,递归删除右子树
public void delNode(int val){
//如果左子节点不为空且满足删除条件
if(this.left!=null&&this.left.val==val){
this.left=null;
return;
}
//如果右子节点不为空且满足删除条件
if(this.right!=null&&this.right.val==val){
this.right=null;
return;
}
//如果没有找到,下一层递归删除(左子树,右子树)
if(this.left!=null){
this.left.delNode(val);
}
if(this.right!=null){
this.right.delNode(val);
}
}
}