给定一个由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() 的步骤将是:
- 打印当前节点。
- 在左子树(root->left)上执行中序遍历。
- 对右子树执行中序遍历。
下面是上述方法的实现:
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
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
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
7 4 5 1 3 6
前序-后序混合遍历
preorder() 的步骤如下:
- 打印当前节点。
- 对左子树执行后序遍历。
- 在右子树上执行后序遍历。
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)
如果您想与行业专家一起参加直播课程,请参阅Geeks Classes Live