1. 前序遍历

前序遍历是先输出根节点，再输出左子树，最后输出右子树。

2. 中序遍历

中序遍历，左子树，根节点，右子树

3. 后序遍历

左子树，右子树，根节点

4. 代码实现（递归形式）

下面是Java代码示例，分别实现了这三种遍历方式：

// 定义二叉树节点  
class TreeNode {  
    int val;  
    TreeNode left;  
    TreeNode right;  
  
    TreeNode(int x) {  
        val = x;  
    }  
}  
  
public class BinaryTreeTraversal {  
  
    // 前序遍历（根-左-右）  
    public void preorderTraversalRecursive(TreeNode root) {  
        if (root == null) {  
            return;  
        }  
        // 访问根节点  
        System.out.print(root.val + " ");  
        // 递归遍历左子树  
        preorderTraversalRecursive(root.left);  
        // 递归遍历右子树  
        preorderTraversalRecursive(root.right);  
    }  
  
    // 中序遍历（左-根-右）  
    public void inorderTraversalRecursive(TreeNode root) {  
        if (root == null) {  
            return;  
        }  
        // 递归遍历左子树  
        inorderTraversalRecursive(root.left);  
        // 访问根节点  
        System.out.print(root.val + " ");  
        // 递归遍历右子树  
        inorderTraversalRecursive(root.right);  
    }  
  
    // 后序遍历（左-右-根）  
    public void postorderTraversalRecursive(TreeNode root) {  
        if (root == null) {  
            return;  
        }  
        // 递归遍历左子树  
        postorderTraversalRecursive(root.left);  
        // 递归遍历右子树  
        postorderTraversalRecursive(root.right);  
        // 访问根节点  
        System.out.print(root.val + " ");  
    }  
  
    // 主函数，用于测试  
    public static void main(String[] args) {  
        // 构建一个简单的二叉树  
        TreeNode root = new TreeNode(1);  
        root.left = new TreeNode(2);  
        root.right = new TreeNode(3);  
        root.left.left = new TreeNode(4);  
        root.left.right = new TreeNode(5);  
  
        BinaryTreeTraversal traversal = new BinaryTreeTraversal();  
  
        System.out.println("前序遍历结果：");  
        traversal.preorderTraversalRecursive(root); // 输出: 1 2 4 5 3  
  
        System.out.println("\n中序遍历结果：");  
        traversal.inorderTraversalRecursive(root); // 输出: 4 2 5 1 3  
  
        System.out.println("\n后序遍历结果：");  
        traversal.postorderTraversalRecursive(root); // 输出: 4 5 2 3 1  
    }  
}

在上面的代码中，我们定义了preorderTraversalRecursive、inorderTraversalRecursive和postorderTraversalRecursive三个方法，分别用于前序、中序和后序遍历。每个方法都接收一个TreeNode类型的参数root，表示当前遍历的节点。

对于前序遍历，我们先访问根节点，然后递归遍历左子树，最后递归遍历右子树。

对于中序遍历，我们先递归遍历左子树，然后访问根节点，最后递归遍历右子树。

对于后序遍历，我们先递归遍历左子树，然后递归遍历右子树，最后访问根节点。