数据结构-二叉树（一）

用链表来实现二叉树存储结构

算法代码

/**
 * 
 * @ClassName: TreeNode
 * @Description: 树的节点
 * @author: fuling
 * @date: 2020年8月23日 下午2:24:06
 */
public class TreeNode {
	private int id;
	private String ele;
	private TreeNode left; //当前节点的左节点
	private TreeNode right; //当前节点的右节点
	
	
	public TreeNode() {
		super();
		// TODO Auto-generated constructor stub
	}
	public TreeNode(int id, String ele) {
		super();
		this.id = id;
		this.ele = ele;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getEle() {
		return ele;
	}
	public void setEle(String ele) {
		this.ele = ele;
	}
	public TreeNode getLeft() {
		return left;
	}
	public void setLeft(TreeNode left) {
		this.left = left;
	}
	public TreeNode getRight() {
		return right;
	}
	public void setRight(TreeNode right) {
		this.right = right;
	}
	@Override
	public String toString() {
		return "TreeNode [id=" + id + ", ele=" + ele + "]";
	}
	
	/**
	 * 
	 * @Title: preOrder
	 * @Description: 前序遍历
	 * 算法：
	 * 1.输出当前节点信息
	 * 2.如果当前节点左子树不为空：遍历当前节点的左子树
	 * 3.如果当前节点右子树不为空：遍历当前节点的右子树
	 * @return: void
	 */
	public void preOrder() {
		//1.输出当前节点信息
		System.out.println(this);
		
		//2.如果当前节点左子树不为空：遍历当前节点的左子树
		if(this.left != null)this.left.preOrder();
		
		//3.如果当前节点右子树不为空：遍历当前节点的右子树
		if(this.right != null)this.right.preOrder();
	}
	
	/**
	 * 
	 * @Title: infixOrder
	 * @Description: 中序遍历
	 * 算法：
	 * 1.如果当前节点左子树不为空：遍历当前节点的左子树
	 * 2.输出当前节点信息
	 * 3.如果当前节点右子树不为空：遍历当前节点的右子树
	 * @return: void
	 */
	public void infixOrder() {
		//1.如果当前节点左子树不为空：遍历当前节点的左子树
		if(this.left != null)this.left.infixOrder();
		
		//2.输出当前节点信息
		System.out.println(this);
		
		//3.如果当前节点右子树不为空：遍历当前节点的右子树
		if(this.right != null)this.right.infixOrder();
	}
	
	/**
	 * 
	 * @Title: postOrder
	 * @Description: 后序遍历
	 * @return: void
	 * 算法：
	 * 1.如果当前节点左子树不为空：遍历当前节点的左子树 
	 * 2.如果当前节点右子树不为空：遍历当前节点的右子树
	 * 3.输出当前节点信息
	 */
	public void postOrder() {
		//1.如果当前节点左子树不为空：遍历当前节点的左子树
		if(this.left != null)this.left.postOrder();
		
		//2.如果当前节点右子树不为空：遍历当前节点的右子树
		if(this.right != null)this.right.postOrder();
		
		//3.输出当前节点信息
		System.out.println(this);
	}
	
	/**
	 * 
	 * @Title: preSearch
	 * @Description: 前序查找
	 * @param: @param ele 所要查找的参数
	 * @return: TreeNode 查找到的节点，如果找不到，则返回null
	 * 算法：
	 * 1.比较当前元素是否与所查找参数匹配，是则返回该元素
	 * 2.否则若当前节点左子树不为空，就向左子树继续查找，若从左子树找到了，则返回
	 * 3.若从左子树找不到，当前节点若右子树不为空，向右子树继续查找，找到了，则返回
	 * 4.找不到，返回null
	 */
	public TreeNode preSearch(String ele) {
		//1.比较当前元素是否与所查找参数匹配，是则返回该元素
		if(this.ele.equals(ele))return this;
		
		TreeNode node = null;
		
		//否则若当前节点左子树不为空，就向左子树继续查找，若从左子树找到了，则返回
		if(this.left != null)node = this.left.preSearch(ele);
		if(node != null)return node;
		
		//3.若从左子树找不到，当前节点若右子树不为空，向右子树继续查找
		if(this.right != null)node = this.right.preSearch(ele);
		
		//4.从右边找到了，返回元素，找不到，返回null
		return node;
		
	}
	
	/**
	 * 
	 * @Title: remove
	 * @Description: 删除指定的元素，若该元素包含子树，则一并删除
	 * @param: @param ele 指定的值
	 * @return: TreeNode 删除成功则返回该元素，否则返回null
	 * 算法：
	 * 1.若左子树不为空，判断左子树节点是否匹配，是则把当前节点的左子树置空，返回该左子树节点
	 * 2.否则，若右子树不为空，判断右子树节点是否匹配，是则把当前节点的右子树置空，返回该右子树节点
	 * 3.否则，当左子树不为空时，遍历搜寻左子树
	 * 4.若返回结果为空，则当右子树不为空时，遍历搜寻右子树，返回结果;
	 */
	public TreeNode remove(String ele) {
		TreeNode node = null;
		
		//1.若左子树不为空，判断左子树节点是否匹配，是则把当前节点的左子树置空，返回该左子树节点
		if(this.left != null && this.left.ele == ele) {
			node = this.left;
			this.left = null;
			return node;
		}
		
		//2.否则，若右子树不为空，判断右子树节点是否匹配，是则把当前节点的右子树置空，返回该右子树节点
		if(this.right != null && this.right.ele == ele) {
			node = this.right;
			this.right = null;
			return node;
		}
		
		//3.否则，当左子树不为空时，遍历搜寻左子树
		if(this.left != null)node = this.left.remove(ele);
		if(node != null)return node;
		
		//4.若返回结果为空，则当右子树不为空时，遍历搜寻右子树，返回结果;
		if(this.right != null)node = this.right.remove(ele);
		return node;
		
		
	}
}

/**
 * 
 * @ClassName: LinkListTree
 * @Description: 链表实现的二叉树存储结构
 * @author: fuling
 * @date: 2020年8月23日 下午2:21:50
 */
public class LinkListBinaryTree {

	private TreeNode root;//树的根节点

	public LinkListBinaryTree(TreeNode root) {
		super();
		this.root = root;
	}

	public TreeNode getRoot() {
		return root;
	}

	public void setRoot(TreeNode root) {
		this.root = root;
	}
	
	/**
	 * 
	 * @Title: preOreder
	 * @Description: 前序遍历
	 * @return: void
	 * @throws RuntimeException 若树为空，抛异常
	 */
	public void preOreder() {
		if(root == null)throw new RuntimeException("树为空!");
		root.preOrder();
	}
	
	/**
	 * 
	 * @Title: infixOrder
	 * @Description: 中序遍历
	 * @return: void
	 * @throws RuntimeException 若树为空，抛异常
	 */
	public void infixOrder() {
		if(root == null)throw new RuntimeException("树为空!");
		root.infixOrder();
	}
	
	/**
	 * 
	 * @Title: postOreder
	 * @Description: 后序遍历
	 * @return: void
	 * @throws RuntimeException 若树为空，抛异常
	 */
	public void postOreder() {
		if(root == null)throw new RuntimeException("树为空!");
		root.postOrder();
	}
	
	/**
	 * 
	 * @Title: preSearch
	 * @Description: 前序查找元素
	 * @param: @param ele 指定查找的值
	 * @return: TreeNode 找到则返回元素，否则返回null
	 * @throws RuntimeException 若树为空，抛异常
	 */
	public TreeNode preSearch(String ele) {
		
		if(root == null)throw new RuntimeException("树为空!");
		return root.preSearch(ele);
	}
	
	/**
	 * 
	 * @Title: remove
	 * @Description: 删除指定元素
	 * @param: @param ele 指定的值
	 * @return: TreeNode 删除成功则返回删除的元素，否则返回null
	 * @throws RuntimeException 若树为空，抛异常
	 */
	public TreeNode remove(String ele) {
		if(root == null)throw new RuntimeException("树为空!");
		
		//判断根节点是否匹配
		if(root.getEle().equals(ele)) {
			TreeNode node = root;
			root = null;
			return node;
		}
		
		return root.remove(ele);
	}
	
	
}

测试代码

public class MainTest {

	public static void main(String[] args) {
		LinkListTreeBinaryTest();
	}
	public static void LinkListTreeBinaryTest() {
		//手动建树
		TreeNode node1 = new TreeNode(1, "哆啦");
		TreeNode node2 = new TreeNode(2, "柴犬");
		TreeNode node3 = new TreeNode(3, "英短");
		TreeNode node4 = new TreeNode(4, "柯基");
		TreeNode node5 = new TreeNode(5, "二哈");
		node1.setLeft(node2);
		node1.setRight(node3);
		node2.setLeft(node4);
		node2.setRight(node5);
		
		LinkListBinaryTree tree = new LinkListBinaryTree(node1);
		System.out.println("前序遍历：");
		tree.preOreder();
		System.out.println("中序遍历：");
		tree.infixOrder();
		System.out.println("后序遍历：");
		tree.postOreder();
		
//		System.out.println("查找柯基");
//		TreeNode node = tree.preSearch("柯基");
//		if(node != null)System.out.println("找到啦：" + node);
//		else System.out.println("找不到该元素");
		
//		System.out.println("删除前前序遍历");
//		tree.preOreder();
//		System.out.println("删除柯基");
//		TreeNode remove = tree.remove("柯基");
//		if(remove != null)System.out.println("删除成功！");
//		else System.out.println("删除失败");
//		System.out.println("删除后前序遍历");
//		tree.preOreder();
	}

源代码github地址