Zig-Zag Traversal of Binary Tree in Python

We will understand how to solve the problem of getting a binary tree's zig-zag level order traversal in this tutorial.

Example:

We have a binary tree like

Tree:
                  1
                /   \
              /        \
            2           11
          /   \         /  \
        3      5     12    13
       /  \   / \    / \     /  \
       4  6  7   8  9   10  14  15

We will see different approaches to creating a function that will print the zig-zag traversal of the given binary tree. The zig-zag traversal of the above binary tree will be 1 11 2 3 5 12 13 15 14 10 9 8 7 6 4

Approach - 1

The first approach to solving this problem is by using two stacks.

We will assume that the two stacks represent the current_level and the next_level. We will also be required to keep tracking the zig-zag level order of the current level, i.e., whether the traversal of the current level should be from left to right or from right to left. We will pop the nodes from the current_level stack and print the values of those nodes. When the traversal order of the current level is from left to right, we will push the nodes in the left to right order. First, we will push the left child and then the right child of the node to the next_level stack. Since the stack data structure has LIFO (Last In First Out) property, when we pop the nodes in the next loop, they will be arranged in the reverse order.

On the contrary, when the traversal order of the current level is from right to left, we will push the nodes from right to left, i.e., firstly, the right child, then the left child in the next_level stack. The final step will be to swap the current_level and the next_level stacks when we reach the level's end. The level will be completed when the current_level stack is empty.

Code

# Python Program to get the zig-zag level order traversal of a binary tree

# Creating a constructor class for the node
class Node:
  # Defining the method to create a new node
  def __init__(self, val):
    self.val = val
    self.left = None
    self.right = None

# Defining the function which will return the zig-zag level order traversal of the input binary tree. It will take the root node of the binary tree.
# It is an iterative approach.
def zigzagtraversal(root):

  # Giving the base case condition
  if root is None:
    return

  # Initializing two stacks to store the nodes for the current and the next level
  current_level = []
  next_level = []

  # If the left_to_right order is set to boolean True, we will push the nodes from left to right in the next_level stack.
  # If it is set to False, we will push the nodes from right to left
  left_to_right = True

  # Starting by appending the root node to the current_level stack
  current_level.append(root)

  # Checking if the current_level stack is empty or not
  while len(current_level) > 0:
    # Popping the nodes from the stack (LIFO)
    temp_node = current_level.pop(-1)
    # printing the value of the node
    print(temp_node.val, end = " ")

    if left_to_right:
      # If the left_to_right order is true, push the left node and right node
      if temp_node.left:
        next_level.append(temp_node.left)
      if temp_node.right:
        next_level.append(temp_node.right)
    else:
      # else we will first push the right node, then the left
      if temp_node.right:
        next_level.append(temp_node.right)
      if temp_node.left:
        next_level.append(temp_node.left)

    if len(current_level) == 0:
      # Reversing the left_to_right order to push the node
      left_to_right = not left_to_right
      # swapping the two stacks
      current_level, next_level = next_level, current_level

# Creating a binary tree and printing the zig-zag level order traversal
root = Node(1)
root.left = Node(2)
root.right = Node(11)
root.left.left = Node(3)
root.left.right = Node(5)
root.right.left = Node(12)
root.right.right = Node(13)
print("The zig-zag level order traversal of the binary tree is:")
zigzagtraversal(root)

Output:

The zig-zag level order traversal of the binary tree is:
1 11 2 3 5 12 13

Time Complexity: This algorithm has O(N) time complexity. We have used a linear loop to traverse the binary tree

Space Complexity: This algorithm takes O(N) extra memory space hence, the space complexity is O(N). We have used linear space to store the stack

Approach - 2

We used an iterative approach to solve the problem in the above example. This time we will use a recursion function. The approach is similar to another problem known as Level Order Traversal. The only difference between these two problems is that we must create an extra variable. This variable will keep track of the left-to-right and right-to-left orders.

Below is the Python program to implement this approach.

Code

# Python program to solve the Zig-zag Level Order Traversal problem using the recursive approach

# Creating a constructor class to construct the node object
class Node:
  # We will store the data value, a pointer to the left child, and a pointer to the right child
  def __init__(self, val):
    self.val = val
    self.left = None
    self.right = None

# Defining a function to build the binary tree
def buildTree(string):
  # This is the base case condition
  if(len(string) == 0 or string[0] == "N"):
    return None

  # Creating a list of string objects from the given input string
  # But before creating the list, we need to split the input by space
  ls = list(map(str, string.split()))

  # Creating the root node of the tree using the Node() class and passing the first value of the input string as the data value of the root node
  root = Node(int(ls[0]))
  s = 0
  q = list()

  # Pushing the root node to the queue
  q.append(root)
  s = s + 1

  # Now, we will iterate through the list
  # Since we have already added the root node to the queue, we will start from the second interval
  i = 1
  while(s > 0 and i < len(ls)):
    # Getting and removing the first element of the queue
    curr_node = q[0]
    q.pop(0)
    s = s - 1

    # Getting the value of the current node from the lists of input string values
    curr_val = ls[i]

    # If the value of the left child of the node is not null
    if(curr_val != "N"):

      # Creating the left child node for the current root node
      curr_node.left = Node(int(curr_val))

      # Pushing the left child node to the queue
      q.append(curr_node.left)
      s = s + 1
    # For creating the right child
    i = i + 1
    if(i >= len(ls)):
      break
    curr_val = ls[i]

    # Checking that the value of the right child node is not null
    if(curr_val != "N"):

      # Creating the right child node for the current parent node
      curr_node.right = Node(int(curr_val))

      # Pushing the right child node to the queue
      q.append(curr_node.right)
      s = s + 1
    i = i + 1
  return root

# Defining the function to determine the height of the tree
def Height(root):
  if not root:
    return 0
  lh = Height(root.left)
  rh = Height(root.right)
  return max(lh, rh) + 1
 
# Creating a function to traverse in level order
# We will call this function recursively to execute the traversal
def zigZagTraversalU(root, h, order, res):
  # If the height of the given tree is 1, that means the tree has only one node
  if h <= 1:
    if root:
      res.append(root.val)
  # If the height is greater than 1
  else:
    if not order:
      if root.left:
        zigZagTraversalU(root.left, h - 1, order, res)
      if root.right:
        zigZagTraversalU(root.right, h - 1, order, res)
    else:
      if root.right:
        zigZagTraversalU(root.right, h - 1, order, res)
      if root.left:
        zigZagTraversalU(root.left, h - 1, order, res)

# Defining the function that will traverse the tree in a zig-zag manner
def zigZagTraversal(root):
  res = []
  # If the order is False, that means the level order should be from right to left, and if the order is True, the level order will be from left to right
  order = False
  h = Height(root)
  for i in range(1, h + 1):
    zigZagTraversalU(root, i, order, res)
    # After the completion of the level order traversal, we will switch the order
    order = not order
  return res
# Tree:
      #             1
      #           /   \
      #          /     \
      #         /       \
      #       2          11
      #     /   \       /  \
      #   3      5    12    13
      #  / \    / \  / \   /  \
      # 4   6  7   8 9 10 14  15

 
string = "1 2 11 3 5 12 13 4 6 7 8 9 10 14 15"

# Building the tree
root = buildTree(string)
res = zigZagTraversal(root)

print("The Zig-Zag Level Order traversal of the given binary tree is:")
for i in range(len(res)):
    print(res[i], end = " ")

Output:

The Zig-Zag Level Order traversal of the given binary tree is:
1 11 2 3 5 12 13 15 14 10 9 8 7 6 4

Approach - 3

Here is another approach to solving this problem. We will use the queue data structure. For a quick introduction, the queue data structure follows the LIFO principle, i.e., Last In, First Out. We can use the deque class in the collections module to create the queue data structure, or we can simply create a Python list and apply the LIFO principle to the list. We will use the push and pop commands differently based on the traversal level. Below is the implementation of this approach.

Code

# Python program to implement the Zig-zag Level Order Traversal using the queue data structure

# Creating a constructor class to construct the node object
class Node:
  # We will store the data value, a pointer pointing towards the left child, and a pointer pointing towards the right child
  def __init__(self, data):
    self.data = data
    self.left = None
    self.right = None

# Defining a function to build the binary tree
def buildTree(string):
  # This is the base case condition
  if(len(string) == 0 or string[0] == "N"):
    return None

  # Creating a list of string objects from the given input string
  # But before creating the list, we need to split the input by space
  ls = list(map(str, string.split()))

  # Creating the root node of the tree using the Node() class and passing the first value of the input string as the data value of the root node
  root = Node(int(ls[0]))
  s = 0
  q = list()

  # Pushing the root node to the queue
  q.append(root)
  s = s + 1

  # Now, we will iterate through the list
  # Since we have already added the root node to the queue, we will start from the second interval
  i = 1
  while(s > 0 and i < len(ls)):
    # Getting and removing the first element of the queue
    curr_node = q[0]
    q.pop(0)
    s = s - 1

    # Getting the value of the current node from the lists of input string values
    curr_val = ls[i]

    # If the left child of the node does not have null value
    if(curr_val != "N"):

      # Creating the left child node for the current root node
      curr_node.left = Node(int(curr_val))

      # Pushing the left child node to the queue
      q.append(curr_node.left)
      s = s + 1
    # For creating the right child
    i = i + 1
    if(i >= len(ls)):
      break
    curr_val = ls[i]

    # Checking that the value of the right child node is not null
    if(curr_val != "N"):

      # Creating the right child node for the current parent node
      curr_node.right = Node(int(curr_val))

      # Pushing the right child node to the queue
      q.append(curr_node.right)
      s = s + 1
    i = i + 1
  return root

# Creating the function to print the zig-zag order traversal
def zigZagTraversal(root):
  queue = []
  ans = []
  queue.append(root)
  ans.append(root.data)
  
  # setting the initial order level as 1 because the root node is already added to the ans list.
  # The order of the even levels will be from left to right
  # The order of the odd levels will be from right to left
  l = 1

  # We will use an iterative approach  
  while len(queue) > 0:
    n = len(queue)
    for i in range(n):
      # We will pop from the end if the current level is even
      if (l % 2 == 0):
        t = queue[-1]
        queue.pop()
      # Otherwise, we will pop from the beginning of the queue
      else:
        t = queue[0]
        queue.pop(0)
 
      # We will push the nodes in the queue in different manners based on the level at which we are
      # If the current level is odd
      if (l % 2 != 0):
        # First, we will push the right node and then the left node
        if (t.right):
          queue.append(t.right)
          ans.append(t.right.data)
        if (t.left):
          queue.append(t.left)
          ans.append(t.left.data)
      # If the current level is even
      elif (l % 2 == 0):
        # We will push the nodes in the queue from left to right
        # Although we will push these nodes at the beginning of the queue
        if (t.left):
          queue.insert(0, t.left)
          ans.append(t.left.data)
        if (t.right):
          queue.insert(0, t.right)
          ans.append(t.right.data)
    l += 1 # Incrementing the level by one
  return ans

string = "1 2 11 3 5 12 13 4 6 7 8 9 10 14 15"

# Building the tree
root = buildTree(string)
ans = zigZagTraversal(root)
print("The Zig-Zag Level Order traversal of the given binary tree is:")
for i in range(len(ans)):
  print(ans[i], end = " ")

Output:

The Zig-Zag Level Order traversal of the given binary tree is:
1 11 2 3 5 12 13 15 14 10 9 8 7 6 4

Time Complexity: This algorithm has O(N) time complexity. N symbolizes the number of nodes present in the binary tree.

Auxiliary Space: The queue data structure takes O(N) space; hence the space complexity of this approach is O(N).

Approach - 4

This approach will use a ubiquitous algorithm called Depth First Search (DFS).

Below is the algorithmic approach of this program:

We will start by defining a Python function that will take the input as the pointer pointing towards the root node of the binary tree, and it will return the zig-zag level order traversal of the given tree.
Inside this function, we will initialize an empty Python list. This list will contain the nodes at every level of the tree.
We will execute a modified version of the pre-order traversal of a binary tree using the Depth First Search algorithm. To execute this approach, we need to create another function which will be called recursively. This recursive function will take in the current node, the level of this node, and the ans array. In this function, if the level of the current node is either greater than or equal to the length of the ans array, then it will create a new array for the level of the current node in the ans array and append the current node to this array. Else, it will simply append the current node to the array for the current input level in the ans array. Then, this function will be called recursively first on the left subtree and then on the right subtree of the current input node. We will also increment the level by 1 for both subtrees while calling this function.
When the traversal is over, we will reverse the order of the array present at the odd indices of the ans array. The list of these nodes is at the odd level of the binary tree and needs to follow right-to-left order. This way, we will get the zig-zag order level order traversal.

Below is the Python code that shows how to implement this approach.

Code

# Python program to implement Depth First Search to print the zig-zag level order traversal

# Creating a constructor class to construct the node object
class Node:
  # We will store the data value, a pointer pointing towards the left child, and another pointer pointing towards the right child
  def __init__(self, val):
    self.val = val
    self.left = None
    self.right = None

# Defining the function that will perform the Depth First Search Algorithm
def dfs(root, level_order, res):
  if not root:
    return
  # If the current value of level is not yet traversed and stored in the resultant list, we will create a new list inside the resultant list
  if level_order >= len(res):
    res.append([])
  # Storing the values of the current node in its level
  res[level_order].append(root.val)
  # Recursively traversing the left subtree of the current node
  dfs(root.left, level_order + 1, res)
  # Recursively traversing the right subtree of the current node
  dfs(root.right, level_order + 1, res)

# Defining the function that will print the zig-zag order traversal of the given binary tree
def zigzagOrder(root):
  res = []
  # Executing the modified pre-order traversal
  dfs(root, 0, res)
  # Reversing the order of the list of nodes whose indices are odd values
  for i in range(1, len(res), 2):
    res[i] = res[i][: : -1]
  return res
""" Tree is:
                  1
                /  \
             /        \
            2          11
          /   \        /  \
        3      5     12    13
"""
# Creating a binary tree and printing the zig-zag level order traversal
root = Node(1)
root.left = Node(2)
root.right = Node(11)
root.left.left = Node(3)
root.left.right = Node(5)
root.right.left = Node(12)
root.right.right = Node(13)
print("The zig-zag level order traversal of the binary tree is:")

res = zigzagOrder(root)

# Printing the zig-zag level order traversal
for i in range(len(res)):
    for j in range(len(res[i])):
        print(res[i][j], end = ' ')

Output:

The zig-zag level order traversal of the binary tree is:
1 11 2 3 5 12 13

Time Complexity: This algorithm has O(N) time complexity. N symbolizes the total number of non-null nodes present in the binary tree.

Auxiliary Space: This program takes O(H) extra memory space. H symbolizes the height of the given binary tree. O(H) space complexity is because we store the node values at each level in a different list.

Next TopicCount occurrences of items in Python List

← prev next →