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

建立如图的二叉树并遍历：
[img]http://dl.iteye.com/upload/attachment/0072/3033/114e5346-bf3e-3bf5-b696-7bfbf260a382.gif[/img]

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

最后

以上就是优秀金鱼为你收集整理的二叉树的二叉链实现及遍历的全部内容，希望文章能够帮你解决二叉树的二叉链实现及遍历所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。