http://blog.csdn.net/kangojian/article/details/3990206


 

java 二叉树算法(一)       

      

算法定义  http://baike.baidu.com/view/88806.htm

构造树如下:


其中二叉树节点类

/** 二叉树节点 */
public class BTNode {
   
private char key;
   
private BTNode left, right;

   
public BTNode( char key) {
       
this (key, null , null );
    }

   
public BTNode( char key, BTNode left, BTNode right) {
       
this .key = key;
       
this .left = left;
       
this .right = right;
    }

   
public char getKey() {
       
return key;
    }

   
public void setKey( char key) {
       
this .key = key;
    }

   
public BTNode getLeft() {
       
return left;
    }

   
public void setLeft(BTNode left) {
       
this .left = left;
    }

   
public BTNode getRight() {
       
return right;
    }

   
public void setRight(BTNode right) {
       
this .right = right;
    }
}


遍历二叉树

/** 二叉树遍历 */
public class BinTree {
   
protected BTNode root;

   
public BinTree(BTNode root) {
       
this .root = root;
    }

   
public BTNode getRoot() {
       
return root;
    }

   
/** 构造树 */
   
public static BTNode init() {
        BTNode a =
new BTNode('A');
        BTNode b =
new BTNode('B', null , a);
        BTNode c =
new BTNode('C');
        BTNode d =
new BTNode('D', b, c);
        BTNode e =
new BTNode('E');
        BTNode f =
new BTNode('F', e, null );
        BTNode g =
new BTNode('G', null , f);
        BTNode h =
new BTNode('H', d, g);
       
return h; // root
    }

   
/** 访问节点 */
   
public static void visit(BTNode p) {
System.out.print(p.getKey() +
" " );
    }

   
/** 递归实现前序遍历 */
   
protected static void preorder(BTNode p) {
       
if (p != null ) {
            visit(p);
            preorder(p.getLeft());
            preorder(p.getRight());
        }
    }

   
/** 递归实现中序遍历 */
   
protected static void inorder(BTNode p) {
       
if (p != null ) {
            inorder(p.getLeft());
            visit(p);
            inorder(p.getRight());
        }
    }

   
/** 递归实现后序遍历 */
   
protected static void postorder(BTNode p) {
       
if (p != null ) {
            postorder(p.getLeft());
            postorder(p.getRight());
            visit(p);
        }
    }

   
/** 非递归实现前序遍历 */
   
protected static void iterativePreorder(BTNode p) {
        Stack<BTNode> stack =
new Stack<BTNode>();
       
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(BTNode p) {
        BTNode q = p;
        Stack<BTNode> stack =
new Stack<BTNode>();
       
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(BTNode p) {
        Stack<BTNode> stack =
new Stack<BTNode>();
       
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 ;
        }
    }

   
public static void main(String[] args) {
        BinTree tree =
new BinTree(init());
        System.out.print(
" Pre-Order:" );
        preorder(tree.getRoot());
        System.out.println();
        System.out.print(
"  In-Order:" );
        inorder(tree.getRoot());
        System.out.println();
        System.out.print(
"Post-Order:" );
        postorder(tree.getRoot());
        System.out.println();
        System.out.print(
" Pre-Order:" );
        iterativePreorder(tree.getRoot());
        System.out.println();
        System.out.print(
"  In-Order:" );
        iterativeInorder(tree.getRoot());
        System.out.println();
        System.out.print(
"Post-Order:" );
        iterativePostorder(tree.getRoot());
        System.out.println();
    }
}


输出结果
Pre-Order:H D B A C G F E
  In-Order:B A D C H G E F
Post-Order:A B C D E F G H
Pre-Order:H D B A C G F E
  In-Order:B A D C H G E F
Post-Order:A B C D E F G H

 

  • 0
    点赞
  • 0
    收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值