二叉树的混合阶遍历

给定一个由N个节点组成的二叉树，任务是打印其混合顺序遍历。

Mix Order Traversal is a tree traversal technique, which involves any two of the existing traversal techniques like Inorder, Preorder and Postorder Traversal. Any two of them can be performed or alternate levels of given tree and a mix traversal can be obtained.

例子：

Input: N = 6

Output: 7 4 5 1 3 6 
Explanation: 
Inorder-Preorder Mix Traversal is applied to the given tree in the following order: 
Inorder Traversal is applied at level 0 
Preorder Traversal is applied at level 1 
Inorder Traversal at level 2.
 

Output: 4 5 7 1 6 3 
Explanation: 
Inorder-Postorder Mix Traversal is applied to the given tree in the following order: 
Inorder Traversal is applied at level 0 
Postorder Traversal is applied at level 1 
Inorder Traversal at level 2. 
 

方法：
可能的混合顺序遍历如下：

有序-预混混合遍历

inorder()的步骤将是：

• 在左侧子树上执行预遍历。
• 打印当前节点。
• 在右子树上执行预遍历。

preorder()的步骤将是：

• 打印当前节点。
• 在左子树(根->左)上执行有序遍历。
• 在右子树上执行有序遍历。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
void inOrder(struct node* root);
void preOrder(struct node* root);
 
// Node structure
struct node {
    char data;
    struct node *left, *right;
};
 
// Creates and initialize a new node
struct node* newNode(char ch)
{
    // Allocating memory to a new node
    struct node* n = (struct node*)
        malloc(sizeof(struct node));
    n->data = ch;
    n->left = NULL;
    n->right = NULL;
    return n;
}
 
// Perform Inorder Traversal
void inOrder(struct node* root)
{
    if (root) {
        preOrder(root->left);
        cout << root->data << " ";
        preOrder(root->right);
    }
}
 
// Perform Preorder Traversal
void preOrder(struct node* root)
{
    if (root) {
        cout << root->data << " ";
        inOrder(root->left);
        inOrder(root->right);
    }
}
 
// Driver Code
int main()
{
    // Given tree
    struct node* root = newNode('1');
    root->left = newNode('7');
    root->right = newNode('3');
    root->left->left = newNode('4');
    root->left->right = newNode('5');
    root->right->left = newNode('6');
 
    // Perform Mix order traversal
    inOrder(root);
 
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
// Node structure
static class node
{
    char data;
    node left, right;
};
 
// Creates and initialize a new node
static node newNode(char ch)
{
     
    // Allocating memory to a new node
    node n = new node();
    n.data = ch;
    n.left = null;
    n.right = null;
    return n;
}
 
// Perform Inorder Traversal
static void inOrder(node root)
{
    if (root != null)
    {
        preOrder(root.left);
        System.out.print(root.data + " ");
        preOrder(root.right);
    }
}
 
// Perform Preorder Traversal
static void preOrder(node root)
{
    if (root != null)
    {
        System.out.print(root.data + " ");
        inOrder(root.left);
        inOrder(root.right);
    }
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given tree
    node root = newNode('1');
    root.left = newNode('7');
    root.right = newNode('3');
    root.left.left = newNode('4');
    root.left.right = newNode('5');
    root.right.left = newNode('6');
 
    // Perform Mix order traversal
    inOrder(root);
}
}
 
// This code is contributed by 29AjayKumar

C#

// C# program to implement
// the above approach
using System;
class GFG{
 
// Node structure
class node
{
    public char data;
    public node left, right;
};
 
// Creates and initialize a new node
static node newNode(char ch)
{
     
    // Allocating memory to a new node
    node n = new node();
    n.data = ch;
    n.left = null;
    n.right = null;
    return n;
}
 
// Perform Inorder Traversal
static void inOrder(node root)
{
    if (root != null)
    {
        preOrder(root.left);
        Console.Write(root.data + " ");
        preOrder(root.right);
    }
}
 
// Perform Preorder Traversal
static void preOrder(node root)
{
    if (root != null)
    {
        Console.Write(root.data + " ");
        inOrder(root.left);
        inOrder(root.right);
    }
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given tree
    node root = newNode('1');
    root.left = newNode('7');
    root.right = newNode('3');
    root.left.left = newNode('4');
    root.left.right = newNode('5');
    root.right.left = newNode('6');
 
    // Perform Mix order traversal
    inOrder(root);
}
}
 
// This code is contributed by sapnasingh4991

输出：

7 4 5 1 3 6

预购-后购混合遍历

preorder()的步骤如下：

• 打印当前节点。
• 在左子树上执行Postorder遍历。
• 在右边的子树上执行后置遍历。

postorder()的步骤如下：

• 在左侧子树上执行预遍历。
• 在右子树上执行预遍历。
• 打印当前节点。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
void preOrder(struct node* root);
void postOrder(struct node* root);
 
// Node structure
struct node {
    char data;
    struct node *left, *right;
};
 
// Creates and initialize a new node
struct node* newNode(char ch)
{
    // Allocating memory to a new node
    struct node* n = (struct node*)
        malloc(sizeof(struct node));
    n->data = ch;
    n->left = NULL;
    n->right = NULL;
    return n;
}
 
// Perform Preorder Traversal
void preOrder(struct node* root)
{
    if (root) {
        cout << root->data << " ";
        postOrder(root->left);
        postOrder(root->right);
    }
}
 
// Perform Postorder Traversal
void postOrder(struct node* root)
{
    if (root) {
        preOrder(root->left);
        preOrder(root->right);
        cout << root->data << " ";
    }
}
 
// Driver Code
int main()
{
    // Given tree
    struct node* root = newNode('A');
    root->left = newNode('B');
    root->right = newNode('C');
    root->left->left = newNode('F');
    root->left->right = newNode('D');
    root->right->right = newNode('E');
 
    // Starting Mix order traversal
    preOrder(root);
 
    return 0;
}

Java

// Java Program to implement
// the above approach
class GFG{
 
// Node structure
static class node
{
    char data;
    node left, right;
};
 
// Creates and initialize a new node
static node newNode(char ch)
{
    // Allocating memory to a new node
    node n = new node();
      
    n.data = ch;
    n.left = null;
    n.right = null;
    return n;
}
 
// Perform Preorder Traversal
static void preOrder(node root)
{
    if (root != null)
    {
        System.out.print(root.data + " ");
        postOrder(root.left);
        postOrder(root.right);
    }
}
 
// Perform Postorder Traversal
static void postOrder(node root)
{
    if (root != null)
    {
        preOrder(root.left);
        preOrder(root.right);
        System.out.print(root.data + " ");
    }
}
 
// Driver Code
public static void main(String[] args)
{
    // Given tree
    node root = newNode('A');
    root.left = newNode('B');
    root.right = newNode('C');
    root.left.left = newNode('F');
    root.left.right = newNode('D');
    root.right.right = newNode('E');
 
    // Starting Mix order traversal
    preOrder(root);
}
}
 
// This code is contributed by Rajput-Ji

C＃

// C# Program to implement
// the above approach
using System;
class GFG{
 
// Node structure
class node
{
    public char data;
    public node left, right;
};
 
// Creates and initialize a new node
static node newNode(char ch)
{
    // Allocating memory to a new node
    node n = new node();
      
    n.data = ch;
    n.left = null;
    n.right = null;
    return n;
}
 
// Perform Preorder Traversal
static void preOrder(node root)
{
    if (root != null)
    {
        Console.Write(root.data + " ");
        postOrder(root.left);
        postOrder(root.right);
    }
}
 
// Perform Postorder Traversal
static void postOrder(node root)
{
    if (root != null)
    {
        preOrder(root.left);
        preOrder(root.right);
        Console.Write(root.data + " ");
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    // Given tree
    node root = newNode('A');
    root.left = newNode('B');
    root.right = newNode('C');
    root.left.left = newNode('F');
    root.left.right = newNode('D');
    root.right.right = newNode('E');
 
    // Starting Mix order traversal
    preOrder(root);
}
}
 
// This code is contributed by Rohit_ranjan

输出：

A F D B E C

有序-后序混合遍历

inorder()的步骤如下：

• 在左侧子树上执行后置遍历。
• 打印当前节点。
• 在右侧的子树上执行后置遍历。

postorder()的步骤将是：

• 在左子树上执行有序遍历。
• 在右子树上执行有序遍历。
• 打印当前节点。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
void inOrder(struct node* root);
void postOrder(struct node* root);
 
// Node structure
struct node {
    char data;
    struct node *left, *right;
};
 
// Creates and initialize a new node
struct node* newNode(char ch)
{
 
    // Allocating memory to a new node
    struct node* n = (struct node*)
        malloc(sizeof(struct node));
    n->data = ch;
    n->left = NULL;
    n->right = NULL;
    return n;
}
 
// Perform Inorder Traversal
void inOrder(struct node* root)
{
    if (root) {
        postOrder(root->left);
        cout << root->data << " ";
        postOrder(root->right);
    }
}
 
// Perform Postorder Traversal
void postOrder(struct node* root)
{
    if (root) {
        inOrder(root->left);
        inOrder(root->right);
        cout << root->data << " ";
    }
}
 
// Driver Code
int main()
{
    // Given tree
    struct node* root = newNode('A');
    root->left = newNode('B');
    root->right = newNode('C');
    root->left->left = newNode('F');
    root->left->right = newNode('D');
    root->right->right = newNode('E');
 
    // Starting Mix order traversal
    inOrder(root);
 
    return 0;
}

Java

// Java Program to implement
// the above approach
import java.util.*;
class GFG{
 
// Node structure
static class node
{
    char data;
    node left, right;
};
 
// Creates and initialize a new node
static node newNode(char ch)
{
 
    // Allocating memory to a new node
    node n = new node();
    n.data = ch;
    n.left = null;
    n.right = null;
    return n;
}
 
// Perform Inorder Traversal
static void inOrder(node root)
{
    if (root != null)
    {
        postOrder(root.left);
        System.out.print(root.data + " ");
        postOrder(root.right);
    }
}
 
// Perform Postorder Traversal
static void postOrder(node root)
{
    if (root != null)
    {
        inOrder(root.left);
        inOrder(root.right);
        System.out.print(root.data + " ");
    }
}
 
// Driver Code
public static void main(String[] args)
{
    // Given tree
    node root = newNode('A');
    root.left = newNode('B');
    root.right = newNode('C');
    root.left.left = newNode('F');
    root.left.right = newNode('D');
    root.right.right = newNode('E');
 
    // Starting Mix order traversal
    inOrder(root);
}
}
 
// This code is contributed by sapnasingh4991

C＃

// C# Program to implement
// the above approach
using System;
class GFG{
 
// Node structure
class node
{
    public char data;
    public node left, right;
};
 
// Creates and initialize a new node
static node newNode(char ch)
{
 
    // Allocating memory to a new node
    node n = new node();
    n.data = ch;
    n.left = null;
    n.right = null;
    return n;
}
 
// Perform Inorder Traversal
static void inOrder(node root)
{
    if (root != null)
    {
        postOrder(root.left);
        Console.Write(root.data + " ");
        postOrder(root.right);
    }
}
 
// Perform Postorder Traversal
static void postOrder(node root)
{
    if (root != null)
    {
        inOrder(root.left);
        inOrder(root.right);
        Console.Write(root.data + " ");
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    // Given tree
    node root = newNode('A');
    root.left = newNode('B');
    root.right = newNode('C');
    root.left.left = newNode('F');
    root.left.right = newNode('D');
    root.right.right = newNode('E');
 
    // Starting Mix order traversal
    inOrder(root);
}
}
 
// This code is contributed by sapnasingh4991

输出：

F D B A E C

时间复杂度： O(N)
辅助空间： O(N)