java实现二叉树，前，中，后序递归以及非递归遍历以及查询二叉树（Java）

树的一些基本知识点：

链接：https://pan.baidu.com/s/1g6ZxO_o44LUyW3fl-3Ve6g
提取码：k5dx

二叉树以及哈夫曼知识点：

链接：https://pan.baidu.com/s/1IjwG5BYStf2KC06FpXq4tw
提取码：omm2

二叉树的构建：

package com.dn.binarytree;

import java.awt.List;
import java.util.*;


public class BinaryTree {
	private TreeNode  root = null;
	
	public BinaryTree(){
		root = new TreeNode(1, "A");
	}
	
	/**
	 * 构建二叉树
	 *         A
	 *     B       C
	 * D      E        F
	 */
	public void createBinaryTree(){
		TreeNode nodeB = new TreeNode(2, "B");
		TreeNode nodeC = new TreeNode(3, "C");
		TreeNode nodeD = new TreeNode(4, "D");
		TreeNode nodeE = new TreeNode(5, "E");
		TreeNode nodeF = new TreeNode(6, "F");
		root.leftChild = nodeB;
		root.rightChild = nodeC;
		nodeB.leftChild = nodeD;
		nodeB.rightChild = nodeE;
		nodeC.rightChild = nodeF;
	}
	
	/**
	 * 求二叉树的高度
	 * @author Administrator
	 *
	 */
	public int getHeight(){
		return getHeight(root);
	}
	
	private int getHeight(TreeNode node) {
		if(node == null){
			return 0;
		}else{
			int i = getHeight(node.leftChild);
			int j = getHeight(node.rightChild);
			return (i<j)?j+1:i+1;
		}
	}

	/**
	 * 获取二叉树的结点数
	 * @author Administrator
	 *
	 */
	public int getSize(){
		return getSize(root);
	}
	
	
	private int getSize(TreeNode node) {
		if(node == null){
			return 0;
		}else{
			return 1+getSize(node.leftChild)+getSize(node.rightChild);
		}
	}
	/*
	 * 根据前序遍历的结果来构建二叉树
	 * ABD##E##C#F##
	 */
	public void createBinaryPre(ArrayList<String> data) {
		
		createBinaryTree(data.size(),data);
	}

	private TreeNode createBinaryTree(int size, ArrayList<String> data) {
		if (data.size()==0) {
			return null;
		}
		String d=data.get(0);
		TreeNode node;
		int index=size-data.size();//数组的长度减去现在的数据长度就是索引的值
		if(d.equals("#")) {
			node=null;//如果取得的为#则置空
			data.remove(0);
			return node;
			
		}
		node=new TreeNode(index,d);
		if(index==0) {
			root=node;
		}
		
			data.remove(0);
			node.leftChild=createBinaryTree(size,data);
			node.rightChild=createBinaryTree(size,data);
		
		return node;
		
	}

	/**
	 * 前序遍历——迭代
	 * @author Administrator
	 *
	 */
	public void preOrder(TreeNode node){
		if(node == null){
			return;
		}else{
			System.out.println("preOrder data:"+node.getData());
			preOrder(node.leftChild);
			preOrder(node.rightChild);
		}
	}
	
	/**
	 * 前序遍历——非迭代
	 */
	
	public void nonRecOrder(TreeNode node){
		if(node == null){
			return;
		}
		Stack<TreeNode> stack = new Stack<TreeNode>();
		stack.push(node);
		while(!stack.isEmpty()){
			//出栈和进栈
			TreeNode n = stack.pop();//弹出根结点
			//压入子结点
			System.out.println("nonRecOrder data"+n.getData());
			if(n.rightChild!=null){
				stack.push(n.rightChild);
				
			}
			if(n.leftChild!=null){
				stack.push(n.leftChild);
			}
		}
	}
	/*
	 * 中序遍历——迭代
	 * @author Administrator
	 *
	 */
	public void midOrder(TreeNode node){
		if(node == null){
			return;
		}else{
			midOrder(node.leftChild);
			System.out.println("midOrder data:"+node.getData());
			midOrder(node.rightChild);
		}
	}
	
	/**
	 * 后序遍历——迭代
	 * @author Administrator
	 *
	 */
	public void postOrder(TreeNode node){
		if(node == null){
			return;
		}else{
			postOrder(node.leftChild);
			postOrder(node.rightChild);
			System.out.println("postOrder data:"+node.getData());
		}
	}
	public class TreeNode{
		private int index;
		private String data;
		private TreeNode leftChild;
		private TreeNode rightChild;
		
	
		public int getIndex() {
			return index;
		}


		public void setIndex(int index) {
			this.index = index;
		}


		public String getData() {
			return data;
		}


		public void setData(String data) {
			this.data = data;
		}


		public TreeNode(int index,String data){
			this.index = index;
			this.data = data;
			this.leftChild = null;
			this.rightChild = null;
		}
	}
	
	
	public static void main(String[] args){
		BinaryTree binaryTree = new BinaryTree();
		binaryTree.createBinaryTree();
		int height = binaryTree.getHeight();
		System.out.println("treeHeihgt:"+height);
		int size = binaryTree.getSize();
		System.out.println("treeSize:"+size);
//		binaryTree.preOrder(binaryTree.root);
//		binaryTree.midOrder(binaryTree.root);
//		binaryTree.postOrder(binaryTree.root);
		binaryTree.nonRecOrder(binaryTree.root);
		System.out.println("通过前序遍历的数组来创建二叉树：");
		ArrayList<String> data=new ArrayList<>();
		String [] dataArray=new String[]{"A","B","D","#","#","E","#","#","F","#","#"};
		for(String d:dataArray) {
			data.add(d);
		}
		binaryTree.createBinaryPre(data);
		binaryTree.preOrder(binaryTree.root);
	}
}

打印结果：
treeHeihgt:3
treeSize:6
nonRecOrder dataA
nonRecOrder dataB
nonRecOrder dataD
nonRecOrder dataE
nonRecOrder dataC
nonRecOrder dataF
通过前序遍历的数组来创建二叉树：
preOrder data:A
preOrder data:B
preOrder data:D
preOrder data:E
preOrder data:F

代码分析：

（1）那么由于树的构建，就需要一个个的节点来连接完成，因此，我们需要构建一个BinaryTree，里面包含索引，数据，左孩子以及右孩子。
（2）这里我们需要一个root根节点
（3）createBinaryTree用于创建树，也就是连接每一个节点，
（4）对于求二叉树高度，我们只需要关注root与叶子节点之间的距离即可，用递归并+1来统计高度
（5）对于求二叉树节点个数 ，1+getSize(node.leftChild)+getSize(node.rightChild)，也是通过递归+1来实现，
（6）对于遍历二叉树，这里就介绍一下前序二叉树，中序和后序同理。，对于前序遍历，我们只需要先打印节点，然后在调用左孩子，最后右孩子用递归来实现即可
(7)非迭代的方法就需要用到栈的知识，先进后出
（8 ）根据前序遍历出来数组结构，来还原二叉树。

查找二叉树

1、查找二叉树概念

查找二叉树，又称二叉排序树（Binary Sort Tree）。一棵查找二叉树或者是一棵空树，或者满足以下递归条件：
　　（1）查找树的左右子树各是一棵查找树；
　　（2）若查找树的左子树非空，则其左子树上的各节点值均小于根节点的值；
　　（3）若查找树的右子树非空，则其右子树上的各节点值均大于根节点的值。
————————————————
版权声明：本文为CSDN博主「「已注销」」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/fightfaith/article/details/50639010

查询二叉树代码实现：

package com.dn.binarytree;

public class SearchBinaryTree {
	TreeNode root=null;
	public void searchBinaryTree() {
		
	}
	/*
	 * 中序遍历
	 */
	public void midOrder(TreeNode node) {
		if(node==null) {
			return ;
		}else {
			midOrder(node.leftchild);
			System.out.println(node.data);
			midOrder(node.rightchid);
		}
	}//通过中序刚好可以从小到大打印出来
	/*
	 * 创建二叉树，添加节点
	 */
	public TreeNode put(int data) {
		TreeNode node=null;
		TreeNode parent=null;
		if(root==null) {
			node=new TreeNode(0,data);
			node=root;
			return node;
		}
		node=root;
		while(node!=null) {
			parent=node;
			if(data>node.data) {
				node=node.rightchid;
						
			}else if(data<node.data){
				node=node.leftchild;
			}else {
				return node;
			}
		}
		//将此节点添加到相应位置
		node=new TreeNode(0,data);
		if(data<parent.data) {
			parent.leftchild=node;
		}else {
			parent.rightchid=node;
		}
		node.parent=parent;
		return node;
		}
	class TreeNode{
		public TreeNode(int key, int data) {
			super();
			this.key = key;
			this.data = data;
			this.leftchild=null;
			this.rightchid=null;
		}
		public int getKey() {
			return key;
		}
		public void setKey(int key) {
			this.key = key;
		}
		public TreeNode getLeftchild() {
			return leftchild;
		}
		public void setLeftchild(TreeNode leftchild) {
			this.leftchild = leftchild;
		}
		public TreeNode getRightchid() {
			return rightchid;
		}
		public void setRightchid(TreeNode rightchid) {
			this.rightchid = rightchid;
		}
		public int getData() {
			return data;
		}
		public void setData(int data) {
			this.data = data;
		}
		private int key;
		private TreeNode leftchild;
		private TreeNode rightchid;
		private TreeNode parent;
		private int data;
	}
public  static void main(String avgs[]) {
	SearchBinaryTree tree=new SearchBinaryTree();
	int [] intArray=new int[] {50,30,20,44,87,16,7,77};
	for(int i:intArray) {
	tree.put(i);
	}
	
}
}