二叉搜索树（排序二叉树）的Java实现

排序二叉树

树结点类

public class TreeNode {
		private String element;
		private TreeNode leftNode;
		private TreeNode rightNode;
		private TreeNode parentNode;
		public TreeNode() {
			element="";
			leftNode=null;
			rightNode=null;
			parentNode=null;
		}
		public TreeNode(String str) {
			element=str;
			leftNode=null;
			rightNode=null;
			parentNode=null;
			
		}
		public TreeNode(String str,TreeNode parent) {
			element=str;
			leftNode=null;
			rightNode=null;
			parentNode=parent;
			
		}
		public TreeNode getParentNode() {
			return parentNode;
		}
		public void setParentNode(TreeNode left) {
			parentNode=left;
		}
		public String getElement() {
			return element;
		}
		public void setElenment(String str) {
			element=str;
		}
		public TreeNode getLeftNode() {
			return leftNode;
		}
		public void setLeftNode(TreeNode left) {
			leftNode=left;
		}
		public TreeNode getRightNode() {
			return rightNode;
		}
		public void setRightNode(TreeNode right) {
			rightNode=right;
		}
	}

二叉树类

import java.util.*;
	
	public class Tree {
		private TreeNode root;
		public Tree(String str) {
			root=new TreeNode(str);
		}
		public TreeNode getRoot() {
			return root;
		}
		public void setRoot(TreeNode root1) {
			root=root1;
		}
		//插入树左结点
		private void insertLeftNode(TreeNode node,String s) {
			TreeNode left=new TreeNode(s,node);
			node.setLeftNode(left);
		}
		//处理删除结点，并交换
		public void SwapNode(TreeNode node,TreeNode nodes) {
			if(nodes.getParentNode().getElement().compareTo(nodes.getElement())>0) {
				nodes.getParentNode().setLeftNode(null);
			}
			else {
				nodes.getParentNode().setRightNode(null);
			}
			if(nodes.getLeftNode()==null)nodes.setLeftNode(node.getLeftNode());
			if(nodes.getRightNode()==null)nodes.setRightNode(node.getRightNode());
			if(node.getParentNode()!=null) {
				nodes.setParentNode(node.getParentNode());
				if(node.getParentNode().getElement().compareTo(node.getElement())>0) {
					node.getParentNode().setLeftNode(nodes);
				}
				else {
					node.getParentNode().setRightNode(nodes);
				}
			}
			else nodes.setParentNode(null);
			if(node==root)root=nodes;
			node=null;
		}
		//插入树右结点
		private void insertRightNode(TreeNode node,String s) {
			TreeNode right=new TreeNode(s,node);
			node.setRightNode(right);
		}
		public TreeNode searchNode(String s) {
			TreeNode p=root;
			while(p!=null) {
				if(p.getElement().equals(s))return p;
				if(p.getElement().compareTo(s)>0) {
					p=p.getLeftNode();
				}
				else {
					p=p.getRightNode();
				}
			}
			return null;
		}
		//二叉搜索树(排序二叉树)插入树结点
		public void sortInsertNode(String s) {
			TreeNode p=root;
			while(p!=null) {
				if(p.getElement().compareTo(s)>0) {
					if(p.getLeftNode()==null) {
						insertLeftNode(p, s);
						return;
					}
					else p=p.getLeftNode();
				}
				else {
					if(p.getRightNode()==null) {
						insertRightNode(p, s);
						return;
					}
					else p=p.getRightNode();
				}
			}
		}
		//删除有左右孩子的结点
		public void deleteBoth(TreeNode node) {
			TreeNode nodes=node.getLeftNode();
			if(nodes.getRightNode()!=null) {
				nodes=leftMaxNode(nodes);
			}
			SwapNode(node,nodes);
		}
		//删除叶子节点
		public void deleteNull(TreeNode node) {
			if(node.getParentNode().getElement().compareTo(node.getElement())>0) {
				node.getParentNode().setLeftNode(null);
			}
			else {
				node.getParentNode().setRightNode(null);
			}
			node=null;
		}
		//删除单个左孩子
		public void deleteLeftSignal(TreeNode node) {
			TreeNode nodes=node.getLeftNode();
			if(nodes.getRightNode()!=null) {
				nodes=leftMaxNode(nodes);
			}
			SwapNode(node,nodes);
		}
		//删除单个右孩子
		public void deleteRightSignal(TreeNode node) {
			TreeNode nodes=node.getRightNode();
			if(nodes.getLeftNode()!=null) {
				nodes=rightMinNode(nodes);
			}
			SwapNode(node,nodes);
		}
		
		//寻找左节点最大值
		public TreeNode leftMaxNode(TreeNode roots) {
			while(roots.getRightNode()!=null) {
				roots=roots.getRightNode();
			}
			return roots;
		}
		//寻找右节点最小
		public TreeNode rightMinNode(TreeNode roots) {
			while(roots.getLeftNode()!=null) {
				roots=roots.getLeftNode();
			}
			return roots;
		}
		//以列表形式删除结点，重新插入（不推荐）
		public void delete(String s,List<String> list) {
			TreeNode p=searchNode(s);
			if(p==null)return;
			else {
				//List<String> list=new ArrayList<>();
				root=new TreeNode(list.get(0));
				list.remove(0);
				list.remove(p.getElement());
				for(String i:list)
					sortInsertNode(i);
			}
		}
		//删除结点
		public void deleteNode(String s) {
			TreeNode p=searchNode(s);
			if(p==null)return;
			else { 
				if(p.getLeftNode()==null&&p.getRightNode()==null) {
					deleteNull(p);
				}
				else {
					if(p.getLeftNode()==null) {
						deleteRightSignal(p);
					}
					else if(p.getRightNode()==null) {
						deleteLeftSignal(p);
					}
					else {
						deleteBoth(p);
					}
				}
			}
		}
		//先序
		public void prePrint(TreeNode roots) {
			System.out.print(roots.getElement()+" ");
			if(roots.getLeftNode()!=null)prePrint(roots.getLeftNode());
			if(roots.getRightNode()!=null)prePrint(roots.getRightNode());
		}
		//中序
		public void minPrint(TreeNode roots) {
			if(roots.getLeftNode()!=null)minPrint(roots.getLeftNode());
			System.out.print(roots.getElement()+" ");
			if(roots.getRightNode()!=null)minPrint(roots.getRightNode());
		}
		//后序
		public void lastPrint(TreeNode roots) {
			if(roots.getLeftNode()!=null)lastPrint(roots.getLeftNode());
			if(roots.getRightNode()!=null)lastPrint(roots.getRightNode());
			System.out.print(roots.getElement()+" ");
		}
	}

主函数测试

	import java.util.*;
	
	public class TreeMain {
		public static void main(String[] args) {
			List<String> list=new ArrayList<>();
			list.add("5");
			list.add("4");
			list.add("3");
			list.add("7");
			list.add("1");
			list.add("2");
			list.add("8");
			list.add("9");
			list.add("0");
			Tree tree=new Tree(list.get(0));
			for(int i=1;i<list.size();i++)
				tree.sortInsertNode(list.get(i));
			//tree.delete("2",list);
			//tree.deleteNode("4");
			System.out.println("先序遍历：");
			tree.prePrint(tree.getRoot());
			System.out.println("\n中序遍历：");
			tree.minPrint(tree.getRoot());
			System.out.println("\n后序遍历：");
			tree.lastPrint(tree.getRoot());
		}
	}