用java怎么构造一个二叉树呢？

用java怎么构造一个二叉树？~

树形结构呗
用JTree，JTree可以添加node的

java构造二叉树，可以通过链表来构造，如下代码：

public class BinTree {
public final static int MAX=40;
BinTree []elements = new BinTree[MAX];//层次遍历时保存各个节点
    int front;//层次遍历时队首
    int rear;//层次遍历时队尾
private Object data; //数据元数
private BinTree left,right; //指向左,右孩子结点的链
public BinTree()
{
}
public BinTree(Object data)
{ //构造有值结点
   this.data = data;
   left = right = null;
}
public BinTree(Object data,BinTree left,BinTree right)
{ //构造有值结点
   this.data = data;
   this.left = left;
   this.right = right;
}
public String toString()
{
   return data.toString();
}
//前序遍历二叉树
public static void preOrder(BinTree parent){ 
     if(parent == null)
      return;
     System.out.print(parent.data+" ");
     preOrder(parent.left);
     preOrder(parent.right);
}
//中序遍历二叉树
public void inOrder(BinTree parent){
   if(parent == null)
      return;
   inOrder(parent.left);
   System.out.print(parent.data+" ");
     inOrder(parent.right);
}
//后序遍历二叉树
public void postOrder(BinTree parent){
   if(parent == null)
    return;
   postOrder(parent.left);
   postOrder(parent.right);
   System.out.print(parent.data+" ");
}
// 层次遍历二叉树 
public void LayerOrder(BinTree parent)
{ 
     elements[0]=parent;
     front=0;rear=1;
   while(front<rear)
   {
    try
    {
        if(elements[front].data!=null)
        {
           System.out.print(elements[front].data + " ");
           if(elements[front].left!=null)
          elements[rear++]=elements[front].left;
           if(elements[front].right!=null)
          elements[rear++]=elements[front].right;
           front++;
        }
    }catch(Exception e){break;}
   }
}
//返回树的叶节点个数
public int leaves()
{
   if(this == null)
    return 0;
   if(left == null&&right == null)
    return 1;
   return (left == null ? 0 : left.leaves())+(right == null ? 0 : right.leaves());
}
//结果返回树的高度
public int height()
{
   int heightOfTree;
   if(this == null)
    return -1;
   int leftHeight = (left == null ? 0 : left.height());
   int rightHeight = (right == null ? 0 : right.height());
   heightOfTree = leftHeight<rightHeight?rightHeight:leftHeight;
   return 1 + heightOfTree;
}
//如果对象不在树中,结果返回-1;否则结果返回该对象在树中所处的层次,规定根节点为第一层
public int level(Object object)
{
   int levelInTree;
   if(this == null)
    return -1;
   if(object == data)
    return 1;//规定根节点为第一层
   int leftLevel = (left == null?-1:left.level(object));
   int rightLevel = (right == null?-1:right.level(object));
   if(leftLevel<0&&rightLevel<0)
    return -1;
   levelInTree = leftLevel<rightLevel?rightLevel:leftLevel;
   return 1+levelInTree;
  
}
//将树中的每个节点的孩子对换位置
public void reflect()
{
   if(this == null)
    return;
   if(left != null)
    left.reflect();
   if(right != null)
    right.reflect();
   BinTree temp = left;
   left = right;
   right = temp;
}
// 将树中的所有节点移走,并输出移走的节点
public void defoliate()
{
   if(this == null)
    return;
   //若本节点是叶节点，则将其移走
   if(left==null&&right == null)
   {
    System.out.print(this + " ");
    data = null;
    return;
   }
   //移走左子树若其存在
   if(left!=null){
    left.defoliate();
    left = null;
   }
   //移走本节点，放在中间表示中跟移走...
   String innerNode += this + " ";
   data = null;
   //移走右子树若其存在
   if(right!=null){
    right.defoliate();
    right = null;
   }
}
   /**
* @param args
*/
public static void main(String[] args) {
   // TODO Auto-generated method stub
   BinTree e = new BinTree("E");
   BinTree g = new BinTree("G");
   BinTree h = new BinTree("H");
   BinTree i = new BinTree("I");
   BinTree d = new BinTree("D",null,g);
  
   BinTree f = new BinTree("F",h,i);
   BinTree b = new BinTree("B",d,e);
   BinTree c = new BinTree("C",f,null);
   BinTree tree = new BinTree("A",b,c);
  
        System.out.println("前序遍历二叉树结果: ");
        tree.preOrder(tree);
        System.out.println();
        System.out.println("中序遍历二叉树结果: ");
        tree.inOrder(tree);
        System.out.println();
        System.out.println("后序遍历二叉树结果: ");
        tree.postOrder(tree);
        System.out.println();
      System.out.println("层次遍历二叉树结果: ");
     tree.LayerOrder(tree);
     System.out.println();
        System.out.println("F所在的层次: "+tree.level("F"));
        System.out.println("这棵二叉树的高度: "+tree.height());
         System.out.println("--------------------------------------");
         tree.reflect();
          System.out.println("交换每个节点的孩子节点后......");
          System.out.println("前序遍历二叉树结果: ");
        tree.preOrder(tree);
        System.out.println();
        System.out.println("中序遍历二叉树结果: ");
        tree.inOrder(tree);
        System.out.println();
        System.out.println("后序遍历二叉树结果: ");
        tree.postOrder(tree);
        System.out.println();
      System.out.println("层次遍历二叉树结果: ");
     tree.LayerOrder(tree);
     System.out.println();
        System.out.println("F所在的层次: "+tree.level("F"));
        System.out.println("这棵二叉树的高度: "+tree.height());
}

二叉树的相关操作，包括创建，中序、先序、后序（递归和非递归），其中重点的是java在先序创建二叉树和后序非递归遍历的的实现。
package com.algorithm.tree;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.concurrent.LinkedBlockingQueue;

public class Tree<T> {

private Node<T> root;

public Tree() {
}

public Tree(Node<T> root) {
this.root = root;
}

//创建二叉树
public void buildTree() {

Scanner scn = null;
try {
scn = new Scanner(new File("input.txt"));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
root = createTree(root,scn);
}
//先序遍历创建二叉树
private Node<T> createTree(Node<T> node,Scanner scn) {

String temp = scn.next();

if (temp.trim().equals("#")) {
return null;
} else {
node = new Node<T>((T)temp);
node.setLeft(createTree(node.getLeft(), scn));
node.setRight(createTree(node.getRight(), scn));
return node;
}

}

//中序遍历(递归)
public void inOrderTraverse() {
inOrderTraverse(root);
}

public void inOrderTraverse(Node<T> node) {
if (node != null) {
inOrderTraverse(node.getLeft());
System.out.println(node.getValue());
inOrderTraverse(node.getRight());
}
}

//中序遍历(非递归)
public void nrInOrderTraverse() {

Stack<Node<T>> stack = new Stack<Node<T>>();
Node<T> node = root;
while (node != null || !stack.isEmpty()) {
while (node != null) {
stack.push(node);
node = node.getLeft();
}
node = stack.pop();
System.out.println(node.getValue());
node = node.getRight();

}

}
//先序遍历(递归)
public void preOrderTraverse() {
preOrderTraverse(root);
}

public void preOrderTraverse(Node<T> node) {
if (node != null) {
System.out.println(node.getValue());
preOrderTraverse(node.getLeft());
preOrderTraverse(node.getRight());
}
}

//先序遍历（非递归）
public void nrPreOrderTraverse() {

Stack<Node<T>> stack = new Stack<Node<T>>();
Node<T> node = root;

while (node != null || !stack.isEmpty()) {

while (node != null) {
System.out.println(node.getValue());
stack.push(node);
node = node.getLeft();
}
node = stack.pop();
node = node.getRight();
}

}

//后序遍历(递归)
public void postOrderTraverse() {
postOrderTraverse(root);
}

public void postOrderTraverse(Node<T> node) {
if (node != null) {
postOrderTraverse(node.getLeft());
postOrderTraverse(node.getRight());
System.out.println(node.getValue());
}
}

//后续遍历(非递归)
public void nrPostOrderTraverse() {

Stack<Node<T>> stack = new Stack<Node<T>>();
Node<T> node = root;
Node<T> preNode = null;//表示最近一次访问的节点

while (node != null || !stack.isEmpty()) {

while (node != null) {
stack.push(node);
node = node.getLeft();
}

node = stack.peek();

if (node.getRight() == null || node.getRight() == preNode) {
System.out.println(node.getValue());
node = stack.pop();
preNode = node;
node = null;
} else {
node = node.getRight();
}

}

}

//按层次遍历
public void levelTraverse() {
levelTraverse(root);
}

public void levelTraverse(Node<T> node) {

Queue<Node<T>> queue = new LinkedBlockingQueue<Node<T>>();
queue.add(node);
while (!queue.isEmpty()) {

Node<T> temp = queue.poll();
if (temp != null) {
System.out.println(temp.getValue());
queue.add(temp.getLeft());
queue.add(temp.getRight());
}

}

}

}

//树的节点

class Node<T> {

private Node<T> left;
private Node<T> right;
private T value;

public Node() {
}
public Node(Node<T> left,Node<T> right,T value) {
this.left = left;
this.right = right;
this.value = value;
}

public Node(T value) {
this(null,null,value);
}
public Node<T> getLeft() {
return left;
}
public void setLeft(Node<T> left) {
this.left = left;
}
public Node<T> getRight() {
return right;
}
public void setRight(Node<T> right) {
this.right = right;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}

}
测试代码：
package com.algorithm.tree;

public class TreeTest {

/**
* @param args
*/
public static void main(String[] args) {
Tree<Integer> tree = new Tree<Integer>();
tree.buildTree();
System.out.println("中序遍历");
tree.inOrderTraverse();
tree.nrInOrderTraverse();
System.out.println("后续遍历");
//tree.nrPostOrderTraverse();
tree.postOrderTraverse();
tree.nrPostOrderTraverse();
System.out.println("先序遍历");
tree.preOrderTraverse();
tree.nrPreOrderTraverse();

//
}

}

定义一个结点类：
public class Node {
private int value;
private Node leftNode;
private Node rightNode;

public Node getRightNode() {
return rightNode;
}
public void setRightNode(Node rightNode) {
this.rightNode = rightNode;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Node getLeftNode() {
return leftNode;
}
public void setLeftNode(Node leftNode) {
this.leftNode = leftNode;
}

}

初始化结点树：
public void initNodeTree()
{
int nodeNumber;
HashMap<String, Integer> map = new HashMap<String, Integer>();
Node nodeTree = new Node();

Scanner reader = new Scanner(System.in);

nodeNumber = reader.nextInt();
for(int i = 0; i < nodeNumber; i++) {
int value = reader.nextInt();
String str = reader.next();
map.put(str, value);
}

if (map.containsKey("#")) {
int value = map.get("#");
nodeTree.setValue(value);
setChildNode(map, value, nodeTree);
}

preTraversal(nodeTree);
}

private void setChildNode(HashMap<String, Integer> map, int nodeValue, Node parentNode) {
int value = 0;
if (map.containsKey("L" + nodeValue)) {
value = map.get("L" + nodeValue);
Node leftNode = new Node();
leftNode.setValue(value);
parentNode.setLeftNode(leftNode);

setChildNode(map, value, leftNode);
}

if (map.containsKey("R" + nodeValue)) {
value = map.get("R" + nodeValue);
Node rightNode = new Node();
rightNode.setValue(value);
parentNode.setRightNode(rightNode);

setChildNode(map, value, rightNode);
}
}

前序遍历该结点树：
public void preTraversal(Node nodeTree) {
if (nodeTree != null) {
System.out.print(nodeTree.getValue() + "\t");
preTraversal(nodeTree.getLeftNode());
preTraversal(nodeTree.getRightNode());
}
}

用java怎么构造一个二叉树?
答：定义一个结点类：\x0d\x0apublic class Node {\x0d\x0a private int value;\x0d\x0a private Node leftNode;\x0d\x0a private Node rightNode;\x0d\x0a \x0d\x0a public Node getRightNode() {\x...

java 构建二叉树
答：((Node)tree.get(i)).leftChild = (Node)tree.get(2*i+1);((Node)tree.get(i)).rightChild = (Node)tree.get(2*i+2);} 这样LinkedList 就存储了整个二叉树. 而第0个元素就是树根，思路大体是这样吧。

建立一个二叉树,附带查询代码,JAVA代码
答：import java.util.ArrayList;// 树的一个节点 class TreeNode { Object _value = null; // 他的值 TreeNode _parent = null; // 他的父节点，根节点没有PARENT ArrayList _childList = new ArrayList(); // 他...

java编程二叉树
答：要遍历此二叉树，先要建立一个二叉树，用C语言编写如下：（暂时可以不用理解，参考一下）/* Note:Your choice is C IDE */ include "stdio.h"define size sizeof(struct list)struct list { int data;struct list *...

如何用Java的方式设计一个后序线索二叉树的方法?
答：在Java中，你可以定义一个类来表示后序线索二叉树，其中包含有头节点、尾节点和当前节点指针。你可以使用递归或迭代方法遍历整棵树，并创建线索，即存储前驱和后继节点的指针。当访问到叶子节点时，需要将尾节点的指针指向它...

用java实现二叉树
答：那么，碰巧要找的数字位于99999那个地方，那查找的速度将很慢，因为要从第1个依次往后取，取出来后进行比较。平衡二叉树（构建平衡二叉树需要先排序，我们这里就不作考虑了）可以很好地解决这个问题，但二叉树的遍历（前...

用JAVA写二叉树
答：return -1;} public static void main(String[] args) { Tree2Bef tree=new Tree2Bef();String mid="84925163A7B";String bef="894526AB731";System.out.println(tree.getBef(mid,bef));} } 树结构如图:1 |--...

java实现二叉树的问题
答：//前序遍历二叉树的循环算法，每到一个结点先输出，再压栈，然后访问它的左子树，//出栈，访问其右子树，然后该次循环结束。private void front(Node2 current) { StackL stack = new StackL((Object)current);do { ...

二叉树的java实现与几种遍历
答：从定义可以看出，二叉树包括：1.空树 2.只有一个根节点 3.只有左子树 4.只有右子树 5.左右子树都存在有且仅有这5种表现形式二叉树的遍历分为三种：前序遍历中序遍历后序遍历前序遍历：按照“根左右”...

Java二叉树构造问题要求:从控制台输入一行扩展二叉树的字符串,然后根...
答：树类：package tree;import java.util.List;public class Tree { private int parentId;private int id;private String showStr;private String Spaces="";public Tree() { // TODO Auto-generated constructor stub } pu...

用java怎么构造一个二叉树呢？

相关兴趣推荐