• Java数据结构——二叉树 增加、删除、查询


    //二叉树系统
    public class BinarySystem {
    	public static void main(String[] args) {
    		BinaryDomain root = null;    //定义头结点
    		new BinaryAction().manage(root);
    	}
    }
    public class BinaryDomain {
    	private int value;		//二叉树值
    	BinaryDomain left;	//左结点
    	BinaryDomain right; //右结点
    	public int getValue() {
    		return value;
    	}
    	public void setValue(int value) {
    		this.value = value;
    	}
    	public BinaryDomain() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	public BinaryDomain(int value) {
    		super();
    		this.value = value;
    	}
    }
    public interface BinaryBean {
    	public void manage(BinaryDomain root);		//二叉树管理
    	public BinaryDomain add(BinaryDomain root);		//二叉树增加
    	public BinaryDomain delete(BinaryDomain root);	//二叉树删除
    	public void query(BinaryDomain root);	//二叉树查询
    	public void update(BinaryDomain root);	//二叉树修改
    }
    
    
    import java.util.Scanner;
    
    public class BinaryAction implements BinaryBean{
    
    	private Scanner input = new Scanner(System.in);
    	@Override
    	public void manage(BinaryDomain root) {
    		while (true) {
    			System.out.println("①增加   ②删除   ③查询   ④修改   ⑤返回");
    			int select = input.nextInt();
    			if (select == 1) {
    				root = add(root);
    			} else if (select == 2) {
    				root = delete(root);
    			} else if (select == 3) {
    				query(root);
    			} else if (select == 4) {
    				update(root);
    			} else {
    				break;
    			}
    		}
    	}
    
    	//增加
    	@Override
    	public BinaryDomain add(BinaryDomain root) {
    		System.out.println("请输入需要增加的值: ");
    		int value = input.nextInt();
    		if (value < 0) {
    			System.out.println("输入的值不合法");
    		} else {
    			BinaryDomain binary = new BinaryDomain(value);	//将值存入对象
    			if (root == null) {	//头为空 
    				root = binary;	//将值给头
    				System.out.println("二叉树的头结点增加成功");
    			} else {
    				BinaryDomain temp = root;	//将头保护起来
    				while (temp != null) {
    					//小左大右
    					if (binary.getValue() > temp.getValue()) {
    						//要增加的值大于当前头的值
    						if (temp.right == null) {
    							temp.right = binary;
    							System.out.println("添加右子树值成功");
    							break;
    						} else {
    							temp = temp.right;
    						}
    					} else if (binary.getValue() < temp.getValue()){
    						//要增加的值小于当前头的值
    						if (temp.left == null) {
    							temp.left = binary;
    							System.out.println("添加左子树值成功");
    							break;
    						} else {
    							temp = temp.left;
    						}
    					} else {
    						//要增加的值等于当前头的值
    						System.out.println("要增加的数值已存在,增加数据失败");
    						break;
    					}
    				}
    			}
    		}
    		return root;
    	}
    	
    	//删除
    	@Override
    	public BinaryDomain delete(BinaryDomain root) {
    		BinaryDomain temp = root;	//保护头结点
    		BinaryDomain tempPre = null;	//要删除的前一个结点
    		BinaryDomain del = null;	//记录要删除的结点
    		System.out.println("请输入需要删除的值: ");
    		int value = input.nextInt();
    		while (temp != null) {
    			if (temp.getValue() == value) {
    				//当前结点值 == 要删除的值
    				del = temp;		//记录要删除的结点
    				break;
    			} else if (temp.getValue() > value) {
    				//当前结点值 > 要删除的值 往左移至下一个
    				tempPre = temp;	//记录要删除结点的前一个结点
    				temp = temp.left;
    			} else {
    				//当前结点值 < 要删除的值	往右移至下一个
    				tempPre = temp;
    				temp = temp.right;
    			}
    		}
    		//判断要删除的结点是否为头结点
    		if (del != null && tempPre == null) {
    			System.out.println("要删除的为头结点");
    			if (del.left == null && del.right == null) {
    				//头结点 无左无右
    				root = null;
    				System.out.println("删除 无左无右 头结点成功");
    			} else if (del.left != null && del.right == null) {
    				//要删除的头结点 有左无右
    				root = del.left;
    				System.out.println("删除 有左无右 头结点成功");
    			} else if (del.left == null && del.right != null) {
    				//要删除的头结点 无左有右
    				root = del.right;
    				System.out.println("删除 无左有右 头结点成功");
    			} else {
    				//要删除的头结点 有左有右
    				System.out.println("要删除的头结点有左有右: ①上移左边的最右边结点值   ②上移右边的最左边结点值");
    				int option = input.nextInt();
    				if (option == 1) {
    					//移左边的最右边结点的值
    					BinaryDomain delLeft = del.left;	//用一个对象指向要删除结点的左边
    					if (delLeft.right == null && delLeft.left == null) {
    						//如果要删除的结点的左边结点没有子结点,则把要删除的结点值等于delLeft值,需要删除结点的左结点为空
    						del.setValue(delLeft.getValue());
    						del.left = null;
    						System.out.println("删除 有左有右 头结点成功,头结点的左子树下 无子树");
    					} else if (delLeft.right == null && delLeft.left != null) {
    						//要删除的结点的左边结点 有左子树无右子树
    						del.setValue(delLeft.getValue());
    						del.left = delLeft.left;
    						System.out.println("删除 有左有右 头结点成功,头结点的左子树下 有左子树无右子树");
    					} else {
    						//要删除的结点的左边结点有右子树
    						BinaryDomain movePre = null; //记录删除结点左边结点的需要移走的最右边的结点的父结点
    						while (delLeft.right != null) {
    							movePre = delLeft;
    							delLeft = delLeft.right;
    						}
    						del.setValue(delLeft.getValue());
    						movePre.right = delLeft.left;
    						System.out.println("删除 有左有右 头结点成功,头结点的左子树下 有右子树 需要移动");
    					}
    				} else {
    					//移右边的最左边结点值
    					BinaryDomain delRight = del.right;	//用一个对象指向要删除结点的右边
    					if (delRight.right == null && delRight.left == null) {
    						//如果要删除的结点的右边结点没有子结点,则把要删除的结点值等于delRight值,需要删除结点的右结点为空
    						del.setValue(delRight.getValue());
    						del.right = null;
    						System.out.println("删除 有左有右 头结点成功,头结点的右子树下 无子树");
    					} else if (delRight.right != null && delRight.left == null) {
    						//要删除的结点的右边结点 有右子树无左子树
    						del.setValue(delRight.getValue());
    						del.right = delRight.right;
    						System.out.println("删除 有左有右 头结点成功,头结点的右子树下 有右子树无左子树");
    					} else {
    						//要删除的结点的右边结点有左子树
    						BinaryDomain movePre = null;	//记录删除结点右边结点的需要移走的最左边的结点的父结点
    						while (delRight.left != null) {
    							movePre = delRight;
    							delRight = delRight.left;
    							System.out.println("删除 有左有右 头结点成功,头结点的右子树下 有左子树 需要移动");
    						}
    					}
    				}
    			}
    		} else {
    			//要删除的不是头结点
    			if (del.left == null && del.right == null) {
    				//要删除的结点无左无右 为叶子结点
    				System.out.println("需要删除的为叶子结点");
    				if (del.getValue() > tempPre.getValue()) {
    					//要删除的值大于父结点的值 删除的为右叶子结点
    					tempPre.right = null;
    					System.out.println("删除非根结点下的右叶子结点成功");
    				} else {
    					//要删除的值小于父结点的值 删除的为左叶子结点
    					temp.left = null;
    					System.out.println("删除非根结点下的左叶子结点成功");
    				}
    			} else if (del.left == null && del.right != null) {
    				//要删除的结点无左有右
    				if (del.getValue() > tempPre.getValue()) {
    					//要删除的值大于父结点的值 要删除的为父结点下的右子树
    					tempPre.right = del.right;
    					System.out.println("删除非根结点下的右子树成功,且该右子树下 有右子树无左子树");
    				} else {
    					//要删除的值小于父结点的值 要删除的为父结点下的左子树
    					tempPre.left = del.right;
    					System.out.println("删除非根结点下的左子树成功,且该左子树下 有右子树无左子树");
    				}
    			} else if (del.left != null && del.right == null) {
    				//要删除的结点有左无右
    				if (del.getValue() > tempPre.getValue()) {
    					//要删除的值大于父结点的值 要删除的为父结点下的右子树
    					tempPre.right = del.left;
    					System.out.println("删除非根结点下的右子树成功,且该右子树下 有左子树无右子树");
    				} else {
    					//要删除的值小于父结点的值 要删除的为父结点下的左子树
    					tempPre.left = del.left;
    					System.out.println("删除非根结点下的左子树成功,且该左子树下 有左子树无右子树");
    				}
    			}else {
    				//要删除的结点有左有右
    				System.out.println("要删除的结点有左有右: ①上移左边的最右边结点值   ②上移右边的最左边结点值");
    				int option = input.nextInt();
    				if (option == 1) {
    					//移左边的最右边结点
    					BinaryDomain delLeft = del.left;		//定义对象指向要删除结点的左边结点
    					if (delLeft.right == null && delLeft.left == null) {
    						//要删除结点的左边结点 无左子树无右子树
    						del.setValue(delLeft.getValue());
    						del.left = null;
    						System.out.println("删除非根结点下左子树成功,且该左子树下 无左子树无右子树");
    					} else if (delLeft.right == null && delLeft.left != null) {
    						//要删除结点的左边结点 有左子树无右子树
    						del.setValue(delLeft.getValue());
    						del.left = delLeft.left;
    						System.out.println("删除非根结点下左子树成功,且该左子树下 有左子树无右子树");
    					} else {
    						//要删除结点的左边结点 无左子树有右子树
    						BinaryDomain movePre = null;	//记录删除结点左边结点的需要移走的最右边的结点的父结点
    						while (delLeft.right != null) {
    							movePre = delLeft;
    							delLeft = delLeft.right;
    						}
    						del.setValue(delLeft.getValue());
    						movePre.right = delLeft.left;
    						System.out.println("删除非根结点下左子树成功,且该左子树下 有右子树 需要移动");
    					}
    				} else {
    					//移右边的最左边结点
    					BinaryDomain delRight = del.right;	//定义对象指向要删除结点的右结点
    					if (delRight.right == null && delRight.left == null) {
    						//要删除结点的右子树下无子树
    						del.setValue(delRight.getValue());
    						del.right = null;
    						System.out.println("删除非根结点下右子树成功,且该右子树下 无子树");
    					} else if (delRight.right != null && delRight.left == null) {
    						//要删除结点的右子树下有右子树无左子树
    						del.setValue(delRight.getValue());
    						del.right = delRight.right;
    						System.out.println("删除非根结点下右子树成功,且该右子树下 无左子树有右子树");
    					} else {
    						//要删除结点的右子树下有左子树
    						BinaryDomain movePre = null;	//记录删除结点右边结点的需要移走的最左边的结点的父结点
    						while (delRight.left != null) {
    							movePre = delRight;
    							delRight = delRight.left;
    						}
    						del.setValue(delRight.getValue());
    						movePre.left = del.right;
    						System.out.println("删除非根结点下右子树成功,且该右子树下 有左子树 需要移动");
    					}
    				}
    			}
    		}
    		return root;
    	}
    
    	//查询
    	@Override
    	public void query(BinaryDomain root) {
    		System.out.println("①先序查询   ②中序查询   ③后序查询");
    		int select = input.nextInt();
    		if (select == 1) {
    			//先序查询  根 左 右
    			preorder(root);
    		} else if (select == 2) {
    			//中序查询  左 根 右
    			inorder(root);
    		} else {
    			//后序查询  左  右 根
    			epilogue(root);
    		}
    	}
    
    	//先序查询  根 左 右
    	public void preorder(BinaryDomain root) {
    		BinaryDomain temp = root;
    		if (temp != null) {
    			System.out.println("先序查询为: "+temp.getValue());	//根
    			preorder(temp.left);	//左
    			preorder(temp.right);	//右
    		}
    	}
    
    	//中序查询  左 根 右
    	public void inorder (BinaryDomain root) {
    		BinaryDomain temp = root;
    		if (temp != null) {
    			inorder(temp.left);	//左
    			System.out.println("中序查询为: "+temp.getValue());	//根
    			inorder(temp.right);	//右
    		}
    	}
    
    	//后序查询  左  右 根
    	public void epilogue (BinaryDomain root) {
    		BinaryDomain temp = root;
    		if (temp != null) {
    			epilogue (temp.left);	//左
    			epilogue (temp.right);	//右
    			System.out.println("后序查询为: "+temp.getValue());	//根
    		}
    	}
    	
    	//修改
    	@Override
    	public void update(BinaryDomain root) {
    		System.out.println("请输入需要修改的数据元素: ");
    		int update = input.nextInt();
    	}
    }
    
    
    
    修改没写了 ,很麻烦 ,如有需要留言,告诉你具体实现思路。。

  • 相关阅读:
    async 异步协程进阶
    linux 磁盘100% 清理
    时间戳,日期,string互转
    ioutils
    logging basic
    【BZOJ5323】【JXOI2018】—游戏(组合数学+线性筛)
    【BZOJ5323】【JXOI2018】—游戏(组合数学+线性筛)
    【CodeChef】—Sum of Cubes(斯特林数+容斥+三元环计数)
    【CodeChef】—Sum of Cubes(斯特林数+容斥+三元环计数)
    【TopCoder SRM 686】—CyclesNumber(斯特林数)
  • 原文地址:https://www.cnblogs.com/798911215-Darryl-Tang/p/9301891.html
Copyright © 2020-2023  润新知