java算法 树总结

树遍历的四种方式

• 先序遍历
• 中序遍历
• 后序遍历
• 层次遍历

二叉树

package tree;

public class treeNode {
	 int element;  
	 treeNode left;  
	 treeNode right;  
	 public treeNode(int element, treeNode left, treeNode right){  
		 this.element = element;  
		 this.left = left;  
		 this.right = right;  
	 }  
}

遍历

package tree;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class treeTraverse {
	
	 /**
     * 前序遍历
     * 递归
     */
    public static void preOrder(treeNode Node)
    {
        if (Node != null)
        {
            System.out.print(Node.element + " ");
            preOrder(Node.left);
            preOrder(Node.right);
        }
    }

    /**
     * 中序遍历
     * 递归
     */
    public static void midOrder(treeNode Node)
    {
        if (Node != null)
        {
            midOrder(Node.left);
            System.out.print(Node.element + " ");
            midOrder(Node.right);
        }
    }

    /**
     * 后序遍历
     * 递归
     */
    public static void posOrder(treeNode Node)
    {
        if (Node != null)
        {
            posOrder(Node.left);
            posOrder(Node.right);
            System.out.print(Node.element + " ");
        }
    }
    
    /**
     * 层序遍历
     * 递归
     */
    public static void levelOrder(treeNode Node) {
        if (Node == null) {
            return;
        }

        int depth = depth(Node);

        for (int i = 1; i <= depth; i++) {
            levelOrder(Node, i);
        }
    }

    private static void levelOrder(treeNode Node, int level) {
        if (Node == null || level < 1) {
            return;
        }

        if (level == 1) {
            System.out.print(Node.element + "  ");
            return;
        }

        // 左子树
        levelOrder(Node.left, level - 1);

        // 右子树
        levelOrder(Node.right, level - 1);
    }

    public static int depth(treeNode Node) {
        if (Node == null) {
            return 0;
        }

        int l = depth(Node.left);
        int r = depth(Node.right);
        if (l > r) {
            return l + 1;
        } else {
            return r + 1;
        }
    }
    
    /**
     * 前序遍历
     * 通过栈实现
     */
    public static void preOrder1(treeNode Node)
    {
        Stack<treeNode> stack = new Stack<>();
        while(Node != null || !stack.isEmpty()){
        	 while (Node != null)
             {
        		 System.out.println(Node.element);
                 stack.push(Node);
                 Node = Node.left;
             }
        	 if(!stack.empty())
        	 {
        		 Node = stack.pop();
        		 Node = Node.right;
        	 }
        }
    }
    
    /**
     * 中序遍历
     * 通过栈实现
     */
    public static void midOrder1(treeNode Node)
    {
        Stack<treeNode> stack = new Stack<>();
        while(Node != null || !stack.empty())
        {
            while (Node != null)
            {
                stack.push(Node);
                Node = Node.left;
            }
            if(!stack.empty())
            {
                Node = stack.pop();
                System.out.print(Node.element + " ");
                Node = Node.right;
            }
        }
    }
    
    /**
     * 后序遍历
     * 非递归
     */
    public static void posOrder1(treeNode Node)
    {
        Stack<treeNode> stack1 = new Stack<>();
        Stack<Integer> stack2 = new Stack<>();
        int i = 1;
        while(Node != null || !stack1.empty())
        {
            while (Node != null)
            {
                stack1.push(Node);
                stack2.push(0);
                Node = Node.left;
            }

            while(!stack1.empty() && stack2.peek() == i)
            {
                stack2.pop();
                System.out.print(stack1.pop().element + " ");
            }

            if(!stack1.empty())
            {
                stack2.pop();
                stack2.push(1);
                Node = stack1.peek();
                Node = Node.right;
            }
        }
    }

    /*
     * 层序遍历
     * 非递归
     */
    public static void levelOrder1(treeNode Node) {
        if (Node == null) {
            return;
        }

        treeNode binaryNode;
        Queue<treeNode> queue = new LinkedList<>();
        queue.add(Node);

        while (queue.size() != 0) {
            binaryNode = queue.poll();

            System.out.print(binaryNode.element + " ");

            if (binaryNode.left != null) {
                queue.offer(binaryNode.left);
            }
            if (binaryNode.right != null) {
                queue.offer(binaryNode.right);
            }
        }
    }
    public static void main(String[] args){
		treeNode root = init();
	      System.out.print("递归前序遍历 ：");
	      preOrder(root);
	      System.out.print("\n非递归前序遍历：");
	      preOrder1(root);
	      System.out.print("\n递归中序遍历 ：");
	      midOrder(root);
	      System.out.print("\n非递归中序遍历 ：");
	      midOrder1(root);
	      System.out.print("\n递归后序遍历 ：");
	      posOrder(root);
	      System.out.print("\n非递归后序遍历 ：");
	      posOrder1(root);
	      System.out.print("\n递归层序遍历：");
	      levelOrder(root);
	      System.out.print("\n非递归层序遍历 ：");
	      levelOrder1(root);
	}
	
	public static treeNode init() {//注意必须逆序建立，先建立子节点，再逆序往上建立，因为非叶子结点会使用到下面的节点，而初始化是按顺序初始化的，不逆序建立会报错  
        treeNode J = new treeNode(8, null, null);  
        treeNode H = new treeNode(4, null, null);  
        treeNode G = new treeNode(2, null, null);  
        treeNode F = new treeNode(7, null, J);  
        treeNode E = new treeNode(5, H, null);  
        treeNode D = new treeNode(1, null, G);  
        treeNode C = new treeNode(9, F, null);  
        treeNode B = new treeNode(3, D, E);  
        treeNode A = new treeNode(6, B, C);  
        return A;   //返回根节点  
    }
}