java:树的基本方法

原创 2016年08月28日 16:04:35
package demo_tree;

import java.util.Stack;

public class BinaryTree {
	
	private class Node{
		/**
		 * @param level 层序
		 * @param data 数据域
		 */
		private int level = 0;
		private String data= null;
		private boolean isVisited;
		private Node leftChild;
		private Node rightChild;
		
		public Node() {}

		public Node(int level, String data) {
			this.level = level;
			this.data = data;
			isVisited = false;
			leftChild = null;
			rightChild = null;
		}
		
		public int getLevel() {
			return level;
		}
		public void setLevel(int level) {
			this.level = level;
		}
		public String getData() {
			return data;
		}
		public void setData(String data) {
			this.data = data;
		}		
	}
	
	/** 根节点**/
	private Node root = null;
	
	public BinaryTree(){
		root = new Node(1, "rootNode(A)");
	}
	
	/*
	 * 另一种方法
	 * private Node root = new Node(1, "rootNode(A)");
	 */
	
	/**
	 * 
	 * @Description: 创建一棵二叉树    
	 *  <pre> 
	 *           A 
	 *     B          C 
	 *  D     E            F 
	 *  </pre> 
	 * void  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:09:49
	 */
	public void createBinTree(){
		Node NodeB= new Node(2, "B");
		Node NodeC = new Node(2, "C");
		Node NodeD = new Node(3, "D");
		Node NodeE = new Node(3, "E");
		Node NodeF = new Node(4, "F");
		
		root.leftChild = NodeB;
		root.rightChild = NodeC;
		NodeB.leftChild = NodeD;
		NodeB.rightChild = NodeE;
		NodeC.rightChild = NodeF;
	}
	
	/**
	 * 
	 * @Description: 树是否为空
	 * @return   
	 * boolean  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:09:39
	 */
	public boolean isEmpty(){
		if(root == null){
			return true;
		}else{
			return false;
		}
		
		/*
		 * 简略写法
		 * return root == null;
		 */
	}
	
	/**
	 * 
	 * @Description: 递归求某个节点的高度
	 * @param node
	 * @return   
	 * int  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:17:26
	 */
	private int height(Node node){
		if(node == null){
			return 0; //递归结束:空树高度为0 
		}else{
			int leftHeight = height(node.leftChild)+1;
			int rightHeight = height(node.rightChild)+1;
			return leftHeight>rightHeight?leftHeight:rightHeight;
		}
	}
	
	/**
	 * 
	 * @Description: 树的高度,即根节点的高度
	 * @return   
	 * int  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:19:01
	 */
	public int height(){
		return height(root);
	}
	
	/**
	 * 
	 * @Description: 递归求某个节点的子孙节点个数
	 * @param node
	 * @return   
	 * int  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:21:08
	 */
	private int size(Node node){
		if(node == null){
			return 0;
		}else{
			int leftSize = size(node.leftChild);
			int rightSize = size(node.rightChild);
			return leftSize + rightSize + 1;
		}
	}
	
	/**
	 * 
	 * @Description: 树的总结点数,即根节点的子孙节点数
	 * @return   
	 * int  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:23:11
	 */
	public int size(){
		return size(root);
	}
	
	/**
	 * 
	 * @Description: 返回双亲节点
	 * @param node
	 * @param element
	 * @return   
	 * Node  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:36:16
	 */
	public Node parent(Node node, Node element){
		if(node == null){
			return null;
		}
		if((node.leftChild == element) || (node.rightChild == element)){
				return node; //返回父结点地址 
		}
		
		Node p;
		//现在左子树中找,如果左子树中没有找到,才到右子树去找 
		if((p = parent(node.leftChild, element)) != null){
			return p;  //递归在左子树中搜索 
		}else{
			return parent(node.rightChild, element);//递归在右子树中搜索 ,右子数允许返回null
		}
	}
	
	/**
	 * 
	 * @Description: 获得左子树,注意判断节点是否为空
	 * @param node
	 * @return   
	 * Node  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:38:46
	 */
	public Node getLeftChild(Node node){
		return (node == null)?null:node.leftChild;
	}
	
	/**
	 * 
	 * @Description: 获得右子树,注意判断节点是否为空
	 * @param node
	 * @return   
	 * Node  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:39:34
	 */
	public Node getRightChild(Node node){
		return (node == null)?null:node.rightChild;
	}
	
	/**
	 * 
	 * @Description: 获得根节点
	 * @return   
	 * Node  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 上午10:40:38
	 */
	public Node getRoot(){
		return root;
	}
	
	/**
	 * 
	 * @Description: 释放某个结点时,该结点的左右子树都已经释放,  
    			所以应该采用后续遍历,当访问某个结点时将该结点的存储空间释放  
	 * @param node   
	 * void  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 下午2:20:39
	 */
	public void destroy(Node node){
		if(node == null){
			return;
		}else{
			destroy(node.leftChild);
			destroy(node.rightChild);
			node = null;
		}
	}
	
	/**
	 * 
	 * @Description: 节点被访问
	 * @param node   
	 * void  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 下午2:27:55
	 */
	public void visited(Node node){
		node.isVisited = true;
		System.out.println("node:data"+node.data);
	}
	
	/**
	 * 
	 * @Description: 前序遍历
	 * @param node   
	 * void  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 下午2:28:22
	 */
	public void preOrder(Node node){
		if(node != null){
			visited(node);
			preOrder(node.leftChild);
			preOrder(node.rightChild);
		}
	}
	
	/**
	 * 
	 * @Description: 中序遍历
	 * @param node   
	 * void  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 下午2:31:58
	 */
	public void inOrder(Node node){
		if(node != null){
			inOrder(node.leftChild);
			visited(node);
			inOrder(node.rightChild);
		}
	}
	
	/**
	 * 
	 * @Description: 后序遍历
	 * @param node   
	 * void  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 下午2:32:15
	 */
	public void postOrder(Node node){
		if(node != null){
			postOrder(node.leftChild);
			postOrder(node.rightChild);
			visited(node);
		}
	}
	
	/**
	 * 
	 * @Description: 非递归前序遍历,NLR
	 * @param p   
	 * void  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 下午2:50:57
	 */
	public void noRecPreOrder(Node p){
		Stack<Node> stack = new Stack<Node>();
		Node node = p;
		while(node != null || stack.size() > 0){
			while(node != null){
				visited(node);
				stack.push(node);
				node = node.leftChild;
			}
			node = stack.pop();
			node = node.rightChild;
		}
	}
	
	/**
	 * 
	 * @Description: 非递归中序遍历,LNR
	 * @param p   
	 * void  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 下午2:57:45
	 */
	public void noRecInOrder(Node p){
		Stack<Node> stack = new Stack<Node>();
		Node node = p;
		while(node != null || stack.size() > 0){
			while(node != null){
				stack.push(node);
				node = node.leftChild;
			}
			if(stack.size() > 0){
				node = stack.pop();
				visited(node);
				node = node.rightChild;
			}
		}
	}
	
	/**
	 * 
	 * @Description: 非递归后序遍历,LRN
	 * @param p   
	 * void  
	 * @throws
	 * @author Guo
	 * @date 2016年8月28日 下午4:10:38
	 */
	public void noRecPostOrder(Node p){
		Stack<Node> stack = new Stack<Node>();
		Node node = p;
		while(p != null){
			for(;p.leftChild != null ; p=p.leftChild){
				stack.push(p);
			}
			while(p!=null && (p.rightChild==null || p.rightChild==node)){
				visited(p);
				node = p;
				if(stack.empty()){
					return;
				}
				p = stack.pop();
			}
			stack.push(p);
			p = p.rightChild;
		}
	}
	
	public static void main(String[] args) {
		BinaryTree tree = new BinaryTree();
		tree.createBinTree();
		System.out.println("root:"+tree.getRoot());
		System.out.println("heigth:"+tree.height());
		System.out.println("size:"+tree.size());
		System.out.println("isEmpty:"+tree.isEmpty());
		System.out.println("----------");
		System.out.println("preOrder:");
		tree.preOrder(tree.root);
		System.out.println("inOrder:");
		tree.inOrder(tree.root);
		System.out.println("postOrder:");
		tree.postOrder(tree.root);
		System.out.println("----------");
		System.out.println("preOrder:");
		tree.noRecPreOrder(tree.root);
		System.out.println("inOrder:");
		tree.noRecInOrder(tree.root);
		System.out.println("postOrder:");
		tree.noRecPostOrder(tree.root);
	}
}

java实现树

java实现一颗简单的树,提供树的基本功能,插入节点、获取树的深度等。
  • jdhanhua
  • jdhanhua
  • 2011年07月12日 15:32
  • 31193

重温数据结构:树 及 Java 实现

读完本文你将了解到: 什么是树 树的相关术语 根节点父亲节点孩子节点叶子节点如上所述 节点的度 树的度 节点的层次 树的高度 树的深度 树的两种实现 数组表示 链表表示的节点 树的几种常见分类及使用场...

java对于树的构建

package tree; import java.util.ArrayList; import java.util.List; import org.apache.commons.coll...

数据库中树结构数据,转换为Java对象树结构( 多叉树结构 )

总体就是图所表示所表示的转换,由数据库 => Java对象转换,代码比较简单,在之前的基础上又加了一个数据库查询方法queryListToMap(); //No.1.1 (推荐使用 运行时间较短) ...

Java集合类汇总记录-- apache.commons4(TreeList)

apache-commons库用tree实现了实现了List的接口,也就是TreeList类。与标准的LinkedList相比,TreeList稍微浪费一点空间,但常用操作的时间复杂度均降低到了O(l...

java集合——树集(TreeSet)+对象的比较

【0】README0.1) 本文描述转自 core java volume 1, 源代码为原创,旨在理解 java日志——基本日志+高级日志 的相关知识; 0.2) for full source ...

java里面的树型的使用

java,JTree

java里面的树型结构

package org.wj.tree; import java.awt.Color; import java.awt.Font; import java.awt.GridLayout;...

【数据结构】之二叉树的java实现

二叉树的定义: 二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树的形式,即使是一般的树也能简单地转换为二叉树,而且二叉树的存储结构及其算法都较为简单,因此二叉树显得特别重要。...

Java递归应用:输出树形菜单

树节点类:package cn.com.tree; public class Node { private Integer id; private Integer parentId; priv...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java:树的基本方法
举报原因:
原因补充:

(最多只允许输入30个字)