Reverse spiral traversal of a binary tree in swift

Swift program for Reverse spiral traversal of a binary tree. Here more information.

import Foundation
/*
  Swift 4 program for
  Reverse level order traversal in spiral form
*/
// Binary Tree Node
class TreeNode
{
	var data: Int;
	var left: TreeNode? ;
	var right: TreeNode? ;
	init(_ data: Int)
	{
		// Set node value
		self.data = data;
		self.left = nil;
		self.right = nil;
	}
}
// Stack node
class StackNode
{
	// Stack data
	var element: TreeNode? ;
	var next: StackNode? ;
	init(_ element: TreeNode? , _ top : StackNode? )
	{
		self.element = element;
		self.next = top;
	}
}
// Define a custom stack
class MyStack
{
	var top: StackNode? ;
	var size: Int;
	init()
	{
		self.top = nil;
		self.size = 0;
	}
	// Add node at the top of stack
	func push(_ element: TreeNode? )
	{
		self.top = StackNode(element, self.top);
		self.size += 1;
	}
	func isEmpty() -> Bool
	{
		if (self.size > 0 && self.top  != nil)
		{
			return false;
		}
		else
		{
			return true;
		}
	}
	// Remove top element of stack
	func pop()
	{
		if (self.size > 0 && self.top  != nil)
		{
			// Change top element of stack
			self.top = self.top!.next;
			self.size -= 1;
		}
	}
	// Return top element of stack
	func peek() -> TreeNode?
	{
		if (self.size == 0)
		{
			return nil;
		}
		return self.top!.element;
	}
}
class BinaryTree
{
	var root: TreeNode? ;
	init()
	{
		self.root = nil;
	}
	// Display tree element in reverse spiral level order traversal
	func reverseSpiral()
	{
		if (self.root == nil)
		{
			// Case
			// When empty
			print("Empty Tree");
			return;
		}
		// Empty stack
		let s1: MyStack = MyStack();
		let s2: MyStack = MyStack();
		let result: MyStack = MyStack();
		// Some auxiliary variable
		var status: Int = 1;
		var node: TreeNode? = self.root;
		// Add first node
		s1.push(node);
		while (node  != nil)
		{
			// Add node element into resultant stack
			result.push(node);
			if (status == 1)
			{
				// Add node from right to left
				// in s2 stack
				if (node!.right  != nil)
				{
					// Add right child
					s2.push(node!.right);
				}
				if (node!.left  != nil)
				{
					// Add left child
					s2.push(node!.left);
				}
			}
			else
			{
				// Add node from left to right
				// in s1 stack
				if (node!.left  != nil)
				{
					// Add left child
					s1.push(node!.left);
				}
				if (node!.right  != nil)
				{
					// Add right child
					s1.push(node!.right);
				}
			}
			if (status == 1)
			{
				// Case A
				// When execute s1 stack
				// Remove s1 element
				s1.pop();
				if (s1.isEmpty())
				{
					// When after remove s1 element
					// s1 stack empty.
					// Then change stack by s2
					status = 2;
					// Get first element of s2
					node = s2.peek();
				}
				else
				{
					// Otherwise get new top
					node = s1.peek();
				}
			}
			else
			{
				// Case B
				// When execute s2 stack
				// Remove s2 element
				s2.pop();
				if (s2.isEmpty())
				{
					// Here change stack
					status = 1;
					node = s1.peek();
				}
				else
				{
					node = s2.peek();
				}
			}
		}
		// Display final result
		while (result.isEmpty() == false)
		{
			// Get top element
			node = result.peek();
			// Display node value
			print("  ",node!.data, terminator: "");
			// Remove top of stack
			result.pop();
		}
	}
	static func main()
	{
		// Create new tree
		let tree: BinaryTree = BinaryTree();
		/*   Make A Binary Tree
		    ---------------
		       1
		      / \ 
		     /   \
		    2     3
		   /     / \
		  4     5   6
		   \    \    \
		    7    8    9
		        
		*/
		// Add node
		tree.root = TreeNode(1);
		tree.root!.left = TreeNode(2);
		tree.root!.right = TreeNode(3);
		tree.root!.right!.right = TreeNode(6);
		tree.root!.right!.left = TreeNode(5);
		tree.root!.left!.left = TreeNode(4);
		tree.root!.left!.left!.right = TreeNode(7);
		tree.root!.right!.left!.right = TreeNode(8);
		tree.root!.right!.right!.right = TreeNode(9);
		// Display reverse spiral level order element
		tree.reverseSpiral();
	}
}
BinaryTree.main();

Output

   9   8   7   4   5   6   3   2   1