二叉树的二叉链实现及遍历

建立如图的二叉树并遍历：

import java.util.*;   
  
public class BinaryTree {   
    protected Node root;   
  
    public BinaryTree(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;// root   
    }   
  
    /** 访问节点 */  
    public static void visit(Node p) {   
        System.out.print(p.getKey() + " ");   
    }   
  
    /** 递归实现前序遍历 */  
     static void preorder(Node p) {   
        if (p != null) {   
            visit(p);   
            preorder(p.getLeft());   
            preorder(p.getRight());   
        }   
    }   
  
    /** 递归实现中序遍历 */  
     static void inorder(Node p) {   
        if (p != null) {   
            inorder(p.getLeft());   
            visit(p);   
            inorder(p.getRight());   
        }   
    }   
  
    /** 递归实现后序遍历 */  
     static void postorder(Node p) {   
        if (p != null) {   
            postorder(p.getLeft());   
            postorder(p.getRight());   
            visit(p);   
        }   
    }   

   /** 层次遍历*/
   static void levelorder(Node p){   
        if(p==null) return;   
        Queue<Node> queue=new LinkedList<Node>();   
        queue.offer(p);   
        while(queue.size()>0){   
            Node temp=queue.poll();   
            visit(temp); 
            if(temp.getLeft()!=null){   
                queue.offer(temp.getLeft());   
            }   
            if(temp.getRight()!=null){   
                queue.offer(temp.getRight());   
            }   
        }   
       
    }   

  
    /** 非递归实现前序遍历 */  
    static void iterativePreorder(Node p) {   
        Stack<Node> stack = new Stack<Node>();   
        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());   
            }   
        }   
    }   
  
  
  
    /** 非递归实现后序遍历 单栈法*/  
     static void iterativePostorder(Node p) {   
        Stack<Node> stack = new Stack<Node>();   
        Node node = p, prev = p;   
        while (node != null || stack.size() > 0) {   
            while (node != null) {   
                stack.push(node);   
                node = node.getLeft();   
            }   
            if (stack.size() > 0) {   
                Node temp = stack.peek().getRight();   
                if (temp == null || temp == prev) {   
                    node = stack.pop();   
                    visit(node);   
                    prev = node;   
                    node = null;   
                } else {   
                    node = temp;   
                }   
            }   
  
        }   
    }   
  
   
  
   
  
    /** 非递归实现中序遍历 */  
     static void iterativeInorder(Node p) {   
        Stack<Node> stack = new Stack<Node>();   
        Node node = p;   
        while (node != null || stack.size() > 0) {   
            while (node != null) {   
                stack.push(node);   
                node = node.getLeft();   
            }   
            if (stack.size() > 0) {   
                node = stack.pop();   
                visit(node);   
                node = node.getRight();   
            }   
        }   
    }   
  
    // 求二叉树的高度
 static int height(Node tree) {
    if (tree == null)
	return 0;
    else {
	int leftTreeHeight = height(tree.getLeft());
	int rightTreeHeight = height(tree.getRight());;
	return leftTreeHeight > rightTreeHeight ? leftTreeHeight + 1: rightTreeHeight + 1;
    }
}

// 求二叉树的结点总数
  static int nodes(Node tree) {
   if (tree == null)
	return 0;
   else {
	int left = nodes(tree.getLeft());
	int right = nodes(tree.getRight());
	return left + right + 1;
  }
}


// 求二叉树叶子节点的总数
 static int leaf(Node tree) {
   if (tree == null)
	return 0;
   else {
	int left = leaf(tree.getLeft());
	int right = leaf(tree.getRight());
	if (tree.getLeft() == null && tree.getRight() == null)
		return left + right + 1;
	else
		return left + right;
    }
 }


    /**  
     * @param args  
     */  
    public static void main(String[] args) {   
        BinaryTree tree = new BinaryTree(init());   
        System.out.print(" 前序遍历:");   
        preorder(tree.getRoot());   
        System.out.println();   
        System.out.print(" 中序遍历:");   
        inorder(tree.getRoot());   
        System.out.println();   
        System.out.print(" 后序遍历:");   
        postorder(tree.getRoot());   
        System.out.println(); 
        System.out.println(); 

        System.out.print(" 非递归前序遍历:");   
        iterativePreorder(tree.getRoot());   
        System.out.println();   
        System.out.print(" 非递归中序遍历:");   
        iterativeInorder(tree.getRoot());   
        System.out.println();   
       
       
        System.out.print(" 非递归后序遍历:");   
        iterativePostorder(tree.getRoot());   
        System.out.println();   
       
        System.out.println("层次遍历");
        levelorder(tree.getRoot());
        System.out.println();   
        System.out.println();   

         System.out.println("叶子结点数");
         System.out.println(leaf(tree.getRoot()));
         System.out.println("总结点数");
         System.out.println(nodes(tree.getRoot()));
         System.out.println("树的高度");
         System.out.println(height(tree.getRoot()));


     
    }    
  
}  

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;   
    }   
} 

运行：
前序遍历:H D B A C G F E
中序遍历:B A D C H G E F
后序遍历:A B C D E F G H

非递归前序遍历:H D B A C G F E
非递归中序遍历:B A D C H G E F
非递归后序遍历:A B C D E F G H
层次遍历
H D G B C F A E

叶子结点数
3
总结点数
8
树的高度
4

下载源码：