用java写二叉树算法，实现添加数据形成二叉树功能，并以先序的方式打印出来

Question

用java写二叉树算法，实现添加数据形成二叉树功能，并以先序的方式打印出来?

Answer 1

import   java.io.*;   
  import   java.util.Stack;   
    
  public   class   myTest   {   
  private   myTree   tree;   
    
    
  /**   
  *二叉树的插入，参数为（关键字，数据）   
  *   
  **/   
  public   void   insert(int   key,   int   data)   
  {   
  if(tree   ==   null)   
  {   
  tree   =   new   myTree();   
  tree.key   =   key;   
  tree.data   =   data;   
  }   
  else   
  {   
  myTree   newTree   =   new   myTree();   
  newTree.key   =   key;   
  newTree.data   =   data;   
  myTree   parent   =   tree;   
  while(true)   
  {   
  if(   newTree.key   <   parent.key)   
  {   
  if(   parent.leftChild   ==   null)   
  {   
  parent.leftChild   =   newTree;   
  return;   
  }   
  else   
  {   
  parent   =   parent.leftChild;   
  }   
  }   
  else   if(   newTree.key   >   parent.key)   
  {   
  if(parent.rightChild   ==   null)   
  {   
  parent.rightChild   =   newTree;   
  return;   
  }   
  else   
  {   
  parent   =   parent.rightChild;   
  }   
  }   
  }   
    
  }   
  }   
    
  /**   
    *   二叉树的查找，参数为（关键字），返回值为   myTree的一个实例   
    *     
    *   **/   
  public   myTree   find(int   key)   
  {   
  if(   tree   ==   null   )   return   null;   
  myTree   curr   =   new   myTree();   
  curr.key   =   key;   
  myTree   parent   =   tree;   
  while(true)   
  {   
  if(   parent   ==   null)   
  {   
  return   null;   
  }   
  else   if(   curr.key   ==   parent.key)   
  {   
  return   parent;   
  }   
  else   if(   curr.key   >   parent.key)   
  {   
  parent   =   parent.rightChild;   
  }   
  else   if(   curr.key   <   parent.key)   
  {   
  parent   =   parent.leftChild;   
  }   
  }   
  }   
    
    
    
  /*   
    *     
    *   递归的二叉树中序遍历   
    *     
    *     
    */   
  private   static   void   midOrder(myTree   tree)   
  {   
  if(tree   !=   null   )   
  {   
  midOrder(tree.leftChild);   
  System.out.println(tree+","+tree.key+","+tree.data);   
  midOrder(tree.rightChild);   
  }   
  }   
    
                      
  /*   
    *   前序遍历     
    */   
  private   static   void   frontOrder(myTree   tree)   
  {   
  if(tree   !=   null)   
  {   
  System.out.println(""+tree.key+"   ,   "+tree.data);   
  frontOrder(tree.leftChild);   
  frontOrder(tree.rightChild);   
  }   
  }   
    
    
  public   static   void   main(String[]   args)     
  {   
  System.out.println("Tree   view   Begin");   
  myTest   t1   =   new   myTest();   
  t1.insert(8,25);   
  t1.insert(5,9);   
  t1.insert(58,87);   
  t1.insert(13,82);   
  t1.insert(4,8);   
  t1.insert(12,54);   
  t1.insert(53,123);   
  t1.insert(56,47);   
  t1.insert(2,75);   
  t1.insert(34,5);   
  t1.insert(6,23);   
  System.out.println("现在开始遍历:");   
  midOrder2(t1.tree);   
  midOrder(t1.tree);   
  }   
  }

Answer 2

在JAVA中实现二叉树，程序如下　　 //********************************************************************　　//filename: BinaryTreeTest.java　　//purpose: test a binarytree with java　　//date: 2002/12/18　　//author: flyfan　　//ver: 0.1　　 //********************************************************************　　public class BinaryTreeTest　　{　　public static void main(String args[])　　{　　BinaryTreeTest b=new BinaryTreeTest();　　int data[]={12,11,34,45,67,89,56,43,22,98};　　BinaryTree root =new BinaryTree(data[0]);　　System.out.print("二叉树的中的数据：　　");　　for(int i=1;i<data.length;i++)　　{　　root.insertTree(root,data[i]);　　System.out.print(data[i-1]+";");　　}　　System.out.println(data[data.length-1]);　　int key=Integer.parseInt(args[0]);　　if(b.searchkey(root,key))　　{　　System.out.println("找到了:"+key);　　}　　else　　{　　System.out.println("没有找到："+key);　　}　　}　　public boolean searchkey(BinaryTree root, int key)　　{　　boolean bl=false;　　if(root==null)　　{　　bl=false;　　return bl;　　}　　else if(root.data==key)　　{　　bl=true;　　return bl;　　}　　else if(key>=root.data)　　{　　return searchkey(root.rightpoiter,key);　　}　　return searchkey(root.leftpoiter,key);　　}　　}　　class BinaryTree　　{　　int data;　　BinaryTree leftpoiter;　　BinaryTree rightpoiter;　　BinaryTree(int data)　　{　　this.data=data;　　leftpoiter=null;　　rightpoiter=null;　　}　　public void insertTree(BinaryTree root, int data)　　{　　if(data>=root.data)　　{　　if(root.rightpoiter==null)　　{　　root.rightpoiter=new BinaryTree(data);　　}　　else　　{　　insertTree(root.rightpoiter,data);　　}　　}　　else　　{　　if(root.leftpoiter==null)　　{　　root.leftpoiter=new BinaryTree(data);　　}　　else　　{　　insertTree(root.leftpoiter,data);　　}　　}　　}　　}　　//end　　讲解：上述各序小，但层次分明，结构严谨，如果有数据库结构知识与C语文能力的JAVA初学者　　一看就明白，二个方法如同C语文中的函数，一个寻找关键字－－searchkey 另一个是插入一个　　结点：insertTree 而class BinaryTree 如同一个C语言中的共同体.　　另外这是一个完全的先序遍历二叉树的语法。先根结点，再左结点，如无再右结点，如些加归至　　搜索完毕。　　运行命令行：java BinaryTreeTest intNumber(一个整数）

Answer 3

package com.xuz.datastruct.tree;public class Node {
public int key;
public Node left;
public Node right;

public Node(int key){
this.key = key;
}

public String toString(){
return "my key is "+key;
}
}
package com.xuz.datastruct.tree;public class Tree {
public Node root;

public Node findNode(Node node){
Node current = root ;
while (current.key != node.key) {
if (current.key > node.key) {
current = current.left;
} else {
current = current.right;
}

if (current == null) {
return null;
}
}

return current;
}

public void insertNode(Node node){
if (root == null) {
root = node;
} else {
Node current = root;
Node parent ;

while (true) {
parent = current;

if (current.key > node.key) {
current = current.left;

if (current == null) {
parent.left = node;
return ;
}
} else {
current = current.right;

if (current == null) {
parent.right = node;
return ;
}
}
}
}
} public void inOrder(Node current){
if (current != null) {
inOrder(current.left);
System.out.println(current);
inOrder(current.right);
}
}

public void preOrder(Node current){
if (current != null) {
System.out.println(current);
preOrder(current.left);
preOrder(current.right);
}
}

public void backOrder(Node current){
if (current != null) {
backOrder(current.left);
backOrder(current.right);
System.out.println(current);
}
} public Node minNode(){
Node current = root;
while (current.left != null) {
current = current.left;
}
return current;
}

public Node maxNode(){
Node current = root;
while (current.right != null) {
current = current.right;
}
return current;
} public boolean deleteNode(Node node){
Node current = root;
Node parent = root ;
boolean isLeft = true;

//找到要删除的节点
while (current.key != node.key) {
parent = current;

if (current.key > node.key) {
isLeft = true;
current = current.left;
} else {
isLeft = false;
current = current.right;
}

if (current == null) {
return false;
}
}

if (current.left == null && current.right == null) { //叶子
if (current.key == root.key) {
root = null;
} else if (isLeft) {
parent.left = null;
} else {
parent.right = null;
}
} else if (current.right == null) { //只有左节点
if (current.key == root.key) {
root = current.left;
} else if (isLeft) {
parent.left = current.left;
} else {
parent.right = current.left;
}
} else if (current.left == null) { //只有左节点
if (current.key == root.key) {
root = current.right;
} else if (isLeft) {
parent.left = current.right;
} else {
parent.right = current.right;
}
} else {//删除左右节点都有的节点
Node successor = getSuccessor(current); //找到中序后继

if (current == root) {
root = successor;
} else if (isLeft) {
parent.left = successor;
} else {
parent.right = successor;
}

successor.left = current.left;
} return true;
}

private Node getSuccessor(Node delNode){
Node successorParent = delNode;
Node successor = delNode;
Node current = delNode.right;

while(current != null){
successorParent = successor;
successor = current;
current = current.left;
}

if (successor != delNode.right) {
successorParent.left = successor.right;
successor.right = delNode.right;
}

return successor;
}
}

Answer 4

不好意思，注释较少。摘自《java数据结构和算法》 Robert Lafore 著

Answer 5

我这儿有个泛型二叉树，共同学习，深入了解：一、泛型二叉树 
public class BinaryTree< T extends Comparable> {//二叉树 
LinkedListvalues //一个链表 
private Node root // 根节点 
public void add(T value) {//在树中添加数据 
if(root == null) { 
root = new Node(value) 
} else { 
add(value, root) 
} 
} 
// 在树中递归插入一个对象 
private void add(T value, Node node) { 
int comparison = node.obj.compareTo(value) 
if(comparison == 0) { 
++node.count 
return 
} 
if(comparison > 0) { 
if(node.left == null) { 
node.left = new Node(value) 
} else { 
add(value, node.left) 
} 
} else { 
if(node.right == null) { 
node.right = new Node(value) 
} else { 
add(value, node.right) 
} 
} 
} 
public LinkedListsort() {//排序 
values = new LinkedList() 
treeSort(root) 
return values 
} 
private void treeSort(Node node) { 
if(node != null) { 
treeSort(node.left) 
// List the duplicate objects for the current node 
for(int i = 0 i< node.count i++) { 
values.addItem(node.obj) 
} 
treeSort(node.right) // Now process the right child 
} 
} 
// 定义节点类 
private class Node { 
Node(T value) { 
obj = value 
count = 1 
} 
T obj // 存储在节点中的对象 
int count // 相同节点的数目 
Node left // 左孩子节点 
Node right // 右孩子点 
} 
} 
二、泛型链表 
http://www.01yun.com/article.asp?3506.html