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();
	}
}

修改沒寫了 ，很麻煩 ，如有需要留言，告訴你具體實現思路。。