reverse the values of the binary tree from the alternate levels

Author: danrusei

README.md

@@ -1,15 +1,15 @@
 # GO - Data Structures and Algorithms
 
-Inspired by the **[Geeksforgeeks - Top 10 Algorithms in Interview Questions](https://www.geeksforgeeks.org/top-10-algorithms-in-interview-questions/amp/)** article, the intent of this repository is to solve these questions using the **Go Language**.  GO is a great language choice for technical interviews and hopefully you can find the solutions to the common algorithms/problems easy to understand. 
+Inspired by the **[Geeksforgeeks - Top 10 Algorithms in Interview Questions](https://www.geeksforgeeks.org/top-10-algorithms-in-interview-questions/amp/)** article, the intent of this repository is to solve these questions using the **Go Language**. GO is a great language choice for technical interviews and hopefully you can find these solutions to the common algorithms/problems easy to understand. 
 
-Although this is an introductory course to algorithms and data structures, it assumes that you are familiar with GO programming language syntax and basic concepts. 
+Although this is an introductory material to algorithms and data structures, it assumes that you are familiar with GO programming language syntax and basic concepts. 
 
 WIP, the descriptions of the below `unsolved yet` problems can be found in the [orginal article](https://www.geeksforgeeks.org/top-10-algorithms-in-interview-questions/amp/).  
 
-> ***Contributions are welcomed - submit a PR***.  
+> ***Contributions are welcomed - solve a problem and submit a PR***.  
 > ***Contribution guidelines***
 > * keep the consistency and document the code
-> * keep it simple, easy to read and understand (not over-engineered, best performance is not in scope)
+> * optimize for readability and simplicity (not over-engineered, best performance is not in scope)
 
 ## [Graph](https://github.com/danrusei/algorithms_with_Go/tree/main/graph)
 
@@ -74,7 +74,7 @@ WIP, the descriptions of the below `unsolved yet` problems can be found in the [
 - [x] [Remove nodes on root to leaf paths of length < K](https://github.com/danrusei/algorithms_with_Go/tree/main/binary_tree/remove_nodes)
 - [] Lowest Common Ancestor in a Binary Search Tree
 - [] Check if a binary tree is subtree of another binary tree
-- [] Reverse alternate levels of a perfect binary tree
+- [x] [Reverse alternate levels of a perfect binary tree](https://github.com/danrusei/algorithms_with_Go/tree/main/binary_tree/reverse_alternate)
 
 ## [Number Theory](https://github.com/danrusei/algorithms_with_Go/tree/main/numbers)
 

binary_tree/reverse_alternate/README.md

@@ -0,0 +1,45 @@
+# Reverse alternate levels of a perfect binary tree
+
+Problem description: [GeeksforGeeks](https://www.geeksforgeeks.org/reverse-alternate-levels-binary-tree/amp/)
+
+Given a Perfect Binary Tree, reverse the alternate level nodes of the binary tree. 
+
+## Example
+
+```bash
+Given tree: 
+               11
+            /     \
+          12       13
+         /  \     /  \
+       14    15   16  17
+       / \  / \  / \  / \
+      1   2 3  4 5  6 7  8 
+
+Modified tree:
+              11
+            /     \
+          13       12
+         /  \     /  \
+       14    15  16   17
+       / \  / \  / \  / \
+      8  7 6  5 4  3  2  1 
+
+
+```
+
+## Algorithm
+
+* traverse the given tree in inorder fashion and store all odd level values in a slice
+* reverse the slice
+* traverse the tree again inorder fashion, take elements from the slice and store the values to every odd level traversed node.
+
+## Result
+
+```bash
+$ go run main.go 
+In order traversal of the original tree:
+((((1) 14 (2)) 12 ((3) 15 (4))) 11 (((5) 16 (6)) 13 ((7) 16 (8))))
+In order traversal of the modified tree:
+((((8) 14 (7)) 13 ((6) 15 (5))) 11 (((4) 16 (3)) 12 ((2) 16 (1))))
+```

binary_tree/reverse_alternate/main.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"fmt"
+
+	binarytree "github.com/danrusei/algorithms_with_go/binary_tree"
+)
+
+// traverse tree and store odd level elements
+func storeAlternate(tree *binarytree.Tree, store *[]int, level int) {
+	if tree == nil {
+		return
+	}
+
+	// Inorder traverse the tree and store only the values from alternate levels
+	storeAlternate(tree.Left, store, level+1)
+
+	if level%2 != 0 {
+		*store = append(*store, tree.Value)
+	}
+
+	storeAlternate(tree.Right, store, level+1)
+}
+
+// traverse the tree and take the elements from the slice and store in odd level nodes
+func modifyTree(tree *binarytree.Tree, store []int, index int, level int) int {
+
+	if tree == nil {
+		return index
+	}
+
+	// Inorder traverse the tree and update level values from the store if the level is odd
+	index = modifyTree(tree.Left, store, index, level+1)
+
+	if level%2 != 0 {
+		tree.Value = store[index]
+		index++
+	}
+
+	index = modifyTree(tree.Right, store, index, level+1)
+
+	return index
+}
+
+func reverseAlternate(tree *binarytree.Tree) {
+
+	//store all alternate levels nodes
+	store := []int{}
+
+	// inorder traverse and store the values from alternate levels
+	storeAlternate(tree, &store, 0)
+
+	// reverse the slice
+	for i, j := 0, len(store)-1; i < j; i, j = i+1, j-1 {
+		store[i], store[j] = store[j], store[i]
+	}
+
+	index := 0
+	_ = modifyTree(tree, store, index, 0)
+}
+
+func main() {
+
+	tree := binarytree.NewTree(11)
+	tree.Left = binarytree.NewTree(12)
+	tree.Right = binarytree.NewTree(13)
+	tree.Left.Left = binarytree.NewTree(14)
+	tree.Left.Left.Left = binarytree.NewTree(1)
+	tree.Left.Left.Right = binarytree.NewTree(2)
+	tree.Left.Right = binarytree.NewTree(15)
+	tree.Left.Right.Left = binarytree.NewTree(3)
+	tree.Left.Right.Right = binarytree.NewTree(4)
+	tree.Right.Left = binarytree.NewTree(16)
+	tree.Right.Left.Left = binarytree.NewTree(5)
+	tree.Right.Left.Right = binarytree.NewTree(6)
+	tree.Right.Right = binarytree.NewTree(16)
+	tree.Right.Right.Left = binarytree.NewTree(7)
+	tree.Right.Right.Right = binarytree.NewTree(8)
+
+	fmt.Println("In order traversal of the original tree:")
+	fmt.Println(tree)
+
+	reverseAlternate(tree)
+
+	fmt.Println("In order traversal of the modified tree:")
+	fmt.Println(tree)
+
+}