数据结构与算法——二叉树的学习总结与基本实现

引言

在数据结构与算法的学习中，我们都无法绕开树与二叉树的学习。
之前我们介绍过数组的数据结构，并且也学习了一些基本的查找算法，但是如果我们想要在有序数组中插入一个数据项，就必须要找到数据项的位置，然后将所有插入位置后的数据项全部向后移动一位，来给新的数据项腾出空间，这样一来，其实非常耗费时间。然后我们介绍了另外一种数据结构——链表。链表的插入删除效率较高，我们只需要改变一些引用值就可以了。但是查找数据又便得缓慢了。紧接着，我们就希望能够有一种数据结构同时具备以上两个优点。于是，树就诞生了。

树

树（tree）是一种抽象数据类型（ADT），用来模拟具有树状结构性质的数据集合。它是由n（n>0）个有限节点通过连接它们的边组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
下面将对思维导图里的内容予以实现：

二叉树

树的每个节点最多只能有两个子节点，便称之为二叉树。
关于二叉树的遍历有三种方法;

• 前序遍历：根左右
• 中序遍历：左根右
• 后序遍历：左右根
• 
  对于上图三种遍历方法的结果分别为：
  前序遍历：ABDECF
  中序遍历：DBEACF
  后序遍历：DEBFCA

二叉树的建立、创建节点、节点的查找、删除以及遍历具体实现代码如下：

package demo5;


public class TestBinaryTree {
	public static void main(String[]args) {
		//创建一个树
		BinaryTree  binTree=new BinaryTree();
		//创建一个根节点
		TreeNode root=new TreeNode(1);
		//把根节点赋个树
		binTree.setRoot(root);
		//创建一个左节点
		TreeNode rootL=new TreeNode(2);
		//把新创建的节点设置为根节点的子节点
		root.setLeftNode(rootL);
		//创建一个左节点
		TreeNode rootR=new TreeNode(3);
		//把新创建的节点设置为根节点的子节点
		root.setRightNode(rootR);
		//为第二层的左节点创建两个子节点
		rootL.setLeftNode(new TreeNode(4));
		rootL.setRightNode(new TreeNode(5));
		//为第二层的右节点创建两个子节点
		rootR.setLeftNode(new TreeNode(6));
		rootR.setRightNode(new TreeNode(7));
		//前序遍历树
		binTree.frontShow();
		System.out.println("==================");
		//中序遍历树
		binTree.middleShow();
		System.out.println("==================");
		//后序遍历
		binTree.afterShow();
		System.out.println("==================");
		//前序查找
		TreeNode  result=binTree.frontSearch(3);
		System.out.println(result);
		//删除一个子树
		binTree.delete(5);
		binTree.frontShow();
		
	}
}

package demo5;

public class TreeNode {
	//节点的权
	int value;
	//左节点
	TreeNode leftNode;
	//右节点
	TreeNode rightNode;
	
	public TreeNode(int value) {
		this.value=value;
	}
	//设置左儿子
	public void setLeftNode(TreeNode lNode) {
		this.leftNode=lNode;
	}
	//设置右儿子
		public void setRightNode(TreeNode rNode) {
			this.rightNode=rNode;
		}
	
		//前序遍历
		public void frontShow() {
			//先遍历当前节点内容
			System.out.println(value);
			//左节点
			if(leftNode!=null) {
			leftNode.frontShow();
			}
			//右节点
			if(rightNode!=null) {
				rightNode.frontShow();
				}
		}
		//中序遍历
		public void middleShow() {
			//左子节点
			if(leftNode!=null) {
				leftNode.middleShow();
			}
			//当前内容
			System.out.println(value);
			//右子节点
			if(rightNode!=null) {
				rightNode.middleShow();
			}
		}
		//后序遍历
		public void afterShow() {
			//左子节点
			if(leftNode!=null) {
				leftNode.middleShow();
			}
			//右子节点
			if(rightNode!=null) {
				rightNode.middleShow();
			}
			//当前节点
			System.out.println(value);
			
		}
		//前序查找
		public TreeNode  frontSearch(int i) {
			TreeNode target=null;
			//对比当前节点的值
			if(this.value==i) {
				return this;
				//当前节点的值不是要查找的节点
			}else {
				//查找左节点
				if(leftNode!=null) {
					//有可能可以找到，也可能找不到，找不到的haul，target=null
					target=leftNode.frontSearch(i);
				}
				//如果不为空，说明在左儿子中已经找到
				if(target!=null) {
					return target;
				}
				//查找右儿子
				if(rightNode!=null) {
					target =rightNode.frontSearch(i);
				}
			}
			return target;
		}
		//删除一个子树
		public void delete(int i) {
			TreeNode parent=this;
			//判断左儿子
		if(parent.leftNode!=null&&parent.leftNode.value==i) {
			parent.leftNode=null;
			return ;
			
		}
		//判断右儿子
		if(parent.rightNode!=null&&parent.rightNode.value==i) {
			parent.rightNode=null;
			return;
		}
		//递归检查并删除左儿子
		parent=leftNode;
		if(parent!=null) {
			parent.delete(i);
		}
		////递归检查并删除右儿子
		parent=rightNode;
		if(parent!=null) {
			parent.delete(i);
		}
	}
}

package demo5;

public class BinaryTree {
	
	TreeNode root;
	
	//设置根节点
	public void setRoot(TreeNode root) {
		this.root=root;
	}
	//获取根节点
	public TreeNode getRoot() {
		return root;
	}
	public void frontShow() {
		if(root!=null) {
		root.frontShow();
		}
	}
	
	public void middleShow() {
		if(root!=null) {
		root.middleShow();
		}
	}
	public void afterShow() {
		if(root!=null) {
		root.afterShow();
		}
	}
	
	public TreeNode frontSearch(int i) {
		return root.frontSearch(i);
	}
	public void delete(int i) {
		if(root.value==i) {
			root=null;
		}else {
			root.delete(i);
		}	
	}
}