java 树结构对象 java如何实现树结构

树是一种非常重要的数据结构，其中二叉树是最常用到的，之前学的时候用的都是c++，很长时间没有用了也忘得差不多了，最近一直都在用Java，所以总结一下怎样用java来实现二叉树的数据结构，用二叉树来存一个数组。

二叉树得特点有以下几个：1. 每个节点最多有两棵子树。2. 左子树和右子树是有顺序的，次序不能任意颠倒。3. 即使树中只有一课子树，也要区分他是左子树还是右子树；

二叉树的遍历：是指从根结点出发，按照某种次序，依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次；二叉树的遍历方式有好多种，如果我们限制了从左到右的习惯方式，那么主要就有以下几种：前序遍历，中序遍历，后序遍历和层序遍历。

二叉树的实现：二叉树也可以通过顺序存储和链式存储来实现；

  二叉树的顺序存储就是用一维数组存储二叉树中的结点，并且结点的存储位置，也就是数组的下标要能体现结点之间的逻辑关系，比如父结点与子结点的逻辑关系，子结点与子结点之间的关系；但顺序存储的实用性不强；所以一般采用链式存储；

   在Java中，采用类来声明树的节点 如下所示

public class Node  
{  
   private char key;                  // 数据 
   private Node left, right;    // 左右子结点 
 
   public Node(char key)  
   {  
       this(key, null, null);  
   }

 

public Node(char key, Node left, Node right)  
   {  
       this.key = key;  
       this.left = left;  
       this.right = right;  
   }  
 
   public char getKey()  
   {  
       return key;  
   }  
 
   public void setKey(char key)  
   {  
       this.key = key;  
   }  
 
   public Node getLeft()  
   {  
       return left;  
   }  
 
   public void setLeft(Node left)  
   {  
       this.left = left;  
   }  
 
   public Node getRight()  
   {  
       return right;  
   }  
 
   public void setRight(Node right)  
   {  
       this.right = right;  
   }  

}

接下来就是创建一个二叉树，以及对二叉树进行前序遍历，中序遍历，后序遍历和层序遍历。

public class Tree  
{  
   protected Node root;  
 
   public Tree(Node root)  
   {  
       this.root = root;  
   }  
 
   public Node getRoot()  
   {  
       return root;  
   }

  初始化，构造二叉树

public static Node init()  
   {  
       Node a = new Node('A');  
       Node b = new Node('B', null, a);  
       Node c = new Node('C');  
       Node d = new Node('D', b, c);  
       Node e = new Node('E');  
       Node f = new Node('F', e, null);  
       Node g = new Node('G', null, f);  
       Node h = new Node('H', d, g);  
       return h;         根结点
   }

 

  访问节点

public static void visit(Node p)  
   {  
       System.out.print(p.getKey() + " ");  
   }

 

  递归实现前序遍历

protected static void preorder(Node p)  
   {  
       if (p != null)  
       {  
           visit(p);  
           preorder(p.getLeft());  
           preorder(p.getRight());  
       }  
   }

  递归实现中序遍历

protected static void inorder(Node p)  
   {  
       if (p != null)  
       {  
           inorder(p.getLeft());  
           visit(p);  
           inorder(p.getRight());  
       }  
   }

 

  递归实现后序遍历

protected static void postorder(Node p)  
   {  
       if (p != null)  
       {  
           postorder(p.getLeft());  
           postorder(p.getRight());  
           visit(p);  
       }  
   }

 

  非递归实现前序遍历

protected static void iterativePreorder(Node p)  
   {  
       Stack stack = new Stack();  
       if (p != null)  
       {  
           stack.push(p);  
           while (!stack.empty())  
           {  
               p = stack.pop();  
               visit(p);  
               if (p.getRight() != null)  
                   stack.push(p.getRight());  
               if (p.getLeft() != null)  
                   stack.push(p.getLeft());  
           }  
       }  
   }

 

  非递归实现后序遍历

protected static void iterativePostorder(Node p)  
   {  
       Node q = p;  
       Stack stack = new Stack();  
       while (p != null)  
       {  
           左子树入栈 
           for (; p.getLeft() != null; p = p.getLeft())  
               stack.push(p);  
           当前结点无右子结点或右子结点已经输出
           while (p != null && (p.getRight() == null || p.getRight() == q))  
           {  
               visit(p);  
               q = p;        // 记录上一个已输出结点 
               if (stack.empty())  
                   return;  
               p = stack.pop();  
           }  
           处理右子结点 
           stack.push(p);  
           p = p.getRight();  
       }  
   }

  非递归实现中序遍历

protected static void iterativeInorder(Node p)  
   {  
       Stack stack = new Stack();  
       while (p != null)  
       {  
           while (p != null)  
           {  
               if (p.getRight() != null)  
                   stack.push(p.getRight());   当前结点右子结点入栈 
               stack.push(p);                  // 当前结点入栈
               p = p.getLeft();  
           }  
           p = stack.pop();  
           while (!stack.empty() && p.getRight() == null)  
           {  
               visit(p);  
               p = stack.pop();  
           }  
           visit(p);  
           if (!stack.empty())  
               p = stack.pop();  
           else  
               p = null;  
       }  
   }  

}