Skip to main content

Sum of alternate leaf nodes in bst in swift

Sum of alternate leaf nodes

Swift program for Sum of alternate leaf nodes in bst. Here more solutions.

import Foundation
// Swift 4 program for
// Sum of alternate leaf nodes in bst
class TreeNode
{
	var data: Int;
	var left: TreeNode? ;
	var right: TreeNode? ;
	init(_ data: Int)
	{
		self.data = data;
		self.left = nil;
		self.right = nil;
	}
}
class BinarySearchTree
{
	var root: TreeNode? ;
	var alternate: Bool;
	init()
	{
		self.root = nil;
		self.alternate = false;
	}
	// Insert a new node element
	func addNode(_ data: Int)
	{
		// Create a new node
		let node: TreeNode? = TreeNode(data);
		if (self.root == nil)
		{
			// When add first node in bst
			self.root = node;
		}
		else
		{
			var find: TreeNode? = self.root;
			// Add new node to proper position
			while (find  != nil)
			{
				if (find!.data >= data)
				{
					if (find!.left == nil)
					{
						// When left child empty
						// So add new node here
						find!.left = node;
						return;
					}
					else
					{
						// Otherwise
						// Visit to left sub-tree
						find = find!.left;
					}
				}
				else
				{
					if (find!.right == nil)
					{
						// When right child empty
						// So add new node here.
						find!.right = node;
						return;
					}
					else
					{
						// Visit to right sub-tree
						find = find!.right;
					}
				}
			}
		}
	}
	func leafSum(_ node: TreeNode? ) -> Int
	{
		if (node  != nil)
		{
			if (node!.left == nil && 
                node!.right == nil)
			{
				// Case A
				// When node is leaf node.
				// Change status.
				self.alternate = !self.alternate;
				// Check node is alternate or not.
				if (self.alternate)
				{
					// When get alternate node.
					return node!.data;
				}
			}
			else
			{
				// Case B
				// When node is internal
				// Visit left and right subtree and
				// Find alternate node.
				return self.leafSum(node!.left) + 
                  self.leafSum(node!.right);
			}
		}
		return 0;
	}
	func alternateLeafSum() -> Int
	{
		// Reset alternate leaf node status
		self.alternate = false;
		return self.leafSum(self.root);
	}
	static func main()
	{
		let tree: BinarySearchTree = BinarySearchTree();
		/*
			Binary search tree
		    -------------------
		       5
		      /  \  
		     /    \ 
		    /      \
		   3        19
		  / \     /   \
		 2   4   8     31
		       / \    / \
		      7   15 25  50  
		*/
		// Add tree node
		tree.addNode(5);
		tree.addNode(3);
		tree.addNode(19);
		tree.addNode(2);
		tree.addNode(4);
		tree.addNode(8);
		tree.addNode(31);
		tree.addNode(7);
		tree.addNode(25);
		tree.addNode(15);
		tree.addNode(50);
		// Test
		print(tree.alternateLeafSum());
	}
}
BinarySearchTree.main();

Output

34




Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment