「java结构树统计」java返回树形结构数据
今天给各位分享java结构树统计的知识，其中也会对java返回树形结构数据进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、java中如何求树型结构节点总数
- 2、java与oracle 树形结构，统计方式的问题 倾家荡产求救
- 3、如何用Java实现树形结构啊？
- 4、编写算法，对一颗以孩子-兄弟链表表示的树统计每层结点的个数.（是每层结点个数不单单是叶子结点个数）
- 5、数据结构编程： 统计二叉树中叶子结点的个数。
java中如何求树型结构节点总数
用递归： public int size(){ return size(root); } public int size(TreeNode root){ if(root==null) return 0; else return 1+size(root.left)+size(root.right); } 不懂百度hi我。
java与oracle 树形结构，统计方式的问题 倾家荡产求救
我认为最效率的方法还是加一个匹配串的字段比如一级部门两位，所有下级部门都以两位开头，最终结果用下级部门匹配串like父部门匹配串加%就好。
可以用一个存储去维护匹配串。
如何用Java实现树形结构啊？
package tree;
import java.util.LinkedList;
import java.util.List;
/**
* 功能：把一个数组的值存入二叉树中，然后进行3种方式的遍历
*
* 参考资料0:数据结构(C语言版)严蔚敏
*
* 参考资料1：
*
* 参考资料2：
*
* @author ocaicai@yeah.net @date: 2011-5-17
*
*/
public class BinTreeTraverse2 {
private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
private static ListNode nodeList = null;
/**
* 内部类：节点
*
* @author ocaicai@yeah.net @date: 2011-5-17
*
*/
private static class Node {
Node leftChild;
Node rightChild;
int data;
Node(int newData) {
leftChild = null;
rightChild = null;
data = newData;
}
}
public void createBinTree() {
nodeList = new LinkedListNode();
// 将一个数组的值依次转换为Node节点
for (int nodeIndex = 0; nodeIndex array.length; nodeIndex++) {
nodeList.add(new Node(array[nodeIndex]));
}
// 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树
for (int parentIndex = 0; parentIndex array.length / 2 - 1; parentIndex++) {
// 左孩子
nodeList.get(parentIndex).leftChild = nodeList
.get(parentIndex * 2 + 1);
// 右孩子
nodeList.get(parentIndex).rightChild = nodeList
.get(parentIndex * 2 + 2);
}
// 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理
int lastParentIndex = array.length / 2 - 1;
// 左孩子
nodeList.get(lastParentIndex).leftChild = nodeList
.get(lastParentIndex * 2 + 1);
// 右孩子,如果数组的长度为奇数才建立右孩子
if (array.length % 2 == 1) {
nodeList.get(lastParentIndex).rightChild = nodeList
.get(lastParentIndex * 2 + 2);
}
}
/**
* 先序遍历
*
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
*
* @param node
* 遍历的节点
*/
public static void preOrderTraverse(Node node) {
if (node == null)
return;
System.out.print(node.data + " ");
preOrderTraverse(node.leftChild);
preOrderTraverse(node.rightChild);
}
/**
* 中序遍历
*
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
*
* @param node
* 遍历的节点
*/
public static void inOrderTraverse(Node node) {
if (node == null)
return;
inOrderTraverse(node.leftChild);
System.out.print(node.data + " ");
inOrderTraverse(node.rightChild);
}
/**
* 后序遍历
*
* 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
*
* @param node
* 遍历的节点
*/
public static void postOrderTraverse(Node node) {
if (node == null)
return;
postOrderTraverse(node.leftChild);
postOrderTraverse(node.rightChild);
System.out.print(node.data + " ");
}
public static void main(String[] args) {
BinTreeTraverse2 binTree = new BinTreeTraverse2();
binTree.createBinTree();
// nodeList中第0个索引处的值即为根节点
Node root = nodeList.get(0);
System.out.println("先序遍历：");
preOrderTraverse(root);
System.out.println();
System.out.println("中序遍历：");
inOrderTraverse(root);
System.out.println();
System.out.println("后序遍历：");
postOrderTraverse(root);
}
}
编写算法，对一颗以孩子-兄弟链表表示的树统计每层结点的个数.（是每层结点个数不单单是叶子结点个数）
typedef struct CSNode
{
Elemtype data;
struct CSNode *firstchild,*nextsibling;
}CSNode,*CSTree;
typedef struct node{
CSTree child;
struct node *next;
} * nd;
count(CSTree T){
nd p,q,e;
CSTree r;
int i,c;
//i记录层数，c记录每层的结点数；
p=(nd)malloc(sizeof(struct node));
p-child=T;p-next=NULL;
q=p;i=1;
while(q){
c=0;p-next=NULL;
while(q){
r=q-child-firstchild;
while(r){
c++;
if(r-firstchild){
e=(nd)malloc(sizeof(struct node));e-child=r-firstchild;e-next=NULL;
e-next=p-next;p-next=e;
}
r=r-nextsibling;
}
e=q;q=q-next;free(e);
}
printf("第%d层结点数为：%d\n",i,c);
i++;
q=p-next;
}
}
数据结构编程： 统计二叉树中叶子结点的个数。
叶子节点：没有孩子节点的节点
也就是说，当我们明白了叶子节点的定义后，只需要遍历一遍二叉树，把符合这种条件（左孩子节点和右孩子节点都为NULL的节点）的节点统计出来就可以了。
于是，实际上这个问题也就转化成了如何遍历二叉树？很显然，遍历二叉树是可以有多种方式的，如：前序遍历（递归/非递归）、中序遍历（递归/非递归）、后序遍历（递归/非递归）、层次遍历等等。
下面我将给出使用递归前序遍历以及层次遍历两种思路实现的求解叶子节点的示例代码吧，仅供参考。其他几种实现方式思路类似，可自行尝试。示例代码如下：
package cn.zifangsky.tree.questions;
import org.junit.Test;
import cn.zifangsky.queue.LinkQueue;
import cn.zifangsky.tree.BinaryTreeNode;
/**
* 求二叉树中叶子节点的个数
* @author Administrator
*
*/
public class Question2 {
/**
* 通过递归前序遍历获取叶子节点个数
* @param root
* @return
*/
public int getNumberOfLeavesByPreOrder(BinaryTreeNode root){
if(root == null){
return 0;
}else{
if(root.getLeft() == null root.getRight() == null){ //叶子节点
return 1;
}else{
return getNumberOfLeavesByPreOrder(root.getLeft()) + getNumberOfLeavesByPreOrder(root.getRight());
}
}
}
/**
* 使用层次遍历获取二叉树叶子节点个数
*
* @时间复杂度 O(n)
* @param root
*/
public int getNumberOfLeavesByQueue(BinaryTreeNode root){
int count = 0; //叶子节点总数
LinkQueueBinaryTreeNode queue = new LinkQueue();
if(root != null){
queue.enQueue(root);
}
while (!queue.isEmpty()) {
BinaryTreeNode temp = (BinaryTreeNode) queue.deQueue();
//叶子节点：左孩子节点和右孩子节点都为NULL的节点
if(temp.getLeft() == null temp.getRight() == null){
count++;
}else{
if(temp.getLeft() != null){
queue.enQueue(temp.getLeft());
}
if(temp.getRight() != null){
queue.enQueue(temp.getRight());
}
}
}
return count;
}
/**
* 测试用例
*/
@Test
public void testMethods(){
/**
* 使用队列构造一个供测试使用的二叉树
* 1
* 2 3
* 4 5 6 7
* 8 9
*/
LinkQueueBinaryTreeNode queue = new LinkQueueBinaryTreeNode();
BinaryTreeNode root = new BinaryTreeNode(1); //根节点
queue.enQueue(root);
BinaryTreeNode temp = null;
for(int i=2;i10;i=i+2){
BinaryTreeNode tmpNode1 = new BinaryTreeNode(i);
BinaryTreeNode tmpNode2 = new BinaryTreeNode(i+1);
temp = (BinaryTreeNode) queue.deQueue();
temp.setLeft(tmpNode1);
temp.setRight(tmpNode2);
if(i != 4)
queue.enQueue(tmpNode1);
queue.enQueue(tmpNode2);
}
System.out.println("叶子节点个数是：" + getNumberOfLeavesByPreOrder(root));
System.out.println("叶子节点个数是：" + getNumberOfLeavesByQueue(root));
}
}
测试代码输出如下：
叶子节点个数是：5
叶子节点个数是：5
附：
二叉树节点BinaryTreeNode的定义：
package cn.zifangsky.tree;
public class BinaryTreeNode {
private int data; // 数据
private BinaryTreeNode left; //左孩子节点
private BinaryTreeNode right; //右孩子节点
public BinaryTreeNode(int data) {
this.data = data;
}
public BinaryTreeNode(int data, BinaryTreeNode left, BinaryTreeNode right) {
this.data = data;
this.left = left;
this.right = right;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public BinaryTreeNode getLeft() {
return left;
}
public void setLeft(BinaryTreeNode left) {
this.left = left;
}
public BinaryTreeNode getRight() {
return right;
}
public void setRight(BinaryTreeNode right) {
this.right = right;
}
}
队列LinkQueue的定义：
package cn.zifangsky.queue;
import cn.zifangsky.linkedlist.SinglyNode;
/**
* 基于单链表实现的队列
* @author zifangsky
* @param K
*/
public class LinkQueueK extends Object{
private SinglyNode? frontNode; //队首节点
private SinglyNode? rearNode; //队尾节点
public LinkQueue() {
frontNode = null;
rearNode = null;
}
/**
* 返回队列是否为空
* @时间复杂度 O(1)
* @return
*/
public boolean isEmpty(){
return (frontNode == null);
}
/**
* 返回存储在队列的元素个数
* @时间复杂度 O(n)
* @return
*/
public int size(){
int length = 0;
SinglyNode? currentNode = frontNode;
while (currentNode != null) {
length++;
currentNode = currentNode.getNext();
}
return length;
}
/**
* 入队：在链表表尾插入数据
* @时间复杂度 O(1)
* @param data
*/
public void enQueue(K data){
SinglyNodeK newNode = new SinglyNodeK(data);
if(rearNode != null){
rearNode.setNext(newNode);
}
rearNode = newNode;
if(frontNode == null){
frontNode = rearNode;
}
}
/**
* 出队：删除表头节点
* @时间复杂度 O(1)
* @return
*/
public Object deQueue(){
if(isEmpty()){
throw new RuntimeException("Queue Empty!");
}else{
Object result = frontNode.getData();
if(frontNode == rearNode){
frontNode = null;
rearNode = null;
}else{
frontNode = frontNode.getNext();
}
return result;
}
}
}
单链表节点SinglyNode的定义：
package cn.zifangsky.linkedlist;
/**
* 单链表的定义
* @author zifangsky
* @param K
*/
public class SinglyNodeK extends Object {
private K data; // 数据
private SinglyNode? next; // 该节点的下个节点
public SinglyNode(K data) {
this.data = data;
}
public SinglyNode(K data, SinglyNode? next) {
this.data = data;
this.next = next;
}
public K getData() {
return data;
}
public void setData(K data) {
this.data = data;
}
public SinglyNode? getNext() {
return next;
}
public void setNext(SinglyNode? next) {
this.next = next;
}
@Override
public String toString() {
return "SinglyNode [data=" + data + "]";
}
}
java结构树统计的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java返回树形结构数据、java结构树统计的信息别忘了在本站进行查找喔。