Reverse alternate ranges of an ideal binary tree


class Node {

 

    char knowledge;

    Node left, proper;

 

    Node(char merchandise) {

        knowledge = merchandise;

        left = proper = null;

    }

}

 

class Index {

 

    int index;

}

 

class BinaryTree {

 

    Node root;

    Index index_obj = new Index();

 

    

    void storeAlternate(Node node, char arr[],

                         Index index, int l)

    {

        

        if (node == null) {

            return;

        }

        

        storeAlternate(node.left, arr, index, l + 1);

 

        

        if (l % 2 != 0) {

            arr[index.index] = node.knowledge;

            index.index++;

        }

 

        storeAlternate(node.proper, arr, index, l + 1);

    }

 

    

    

    

    

    void modifyTree(Node node, char arr[],

                      Index index, int l)

    {

 

        

        if (node == null) {

            return;

        }

 

        

        modifyTree(node.left, arr, index, l + 1);

 

        

        

        if (l % 2 != 0) {

            node.knowledge = arr[index.index];

            (index.index)++;

        }

 

        

        modifyTree(node.proper, arr, index, l + 1);

    }

 

    

    

    void reverse(char arr[], int n) {

        int l = 0, r = n - 1;

        whereas (l < r) {

            char temp = arr[l];

            arr[l] = arr[r];

            arr[r] = temp;

            l++;

            r--;

        }

    }

 

    void reverseAlternate()

    {

        reverseAlternate(root);

    }

 

    

    

    void reverseAlternate(Node node)

    {

 

        

        

        char[] arr = new char[100];

 

        

        storeAlternate(node, arr, index_obj, 0);

 

        

         

        

        reverse(arr, index_obj.index);

 

        

        index_obj.index = 0;

        modifyTree(node, arr, index_obj, 0);

    }

 

    void printInorder() {

        printInorder(root);

    }

 

    

    

    

    void printInorder(Node node) {

        if (node == null) {

            return;

        }

        printInorder(node.left);

        System.out.print(node.knowledge + " ");

        printInorder(node.proper);

    }

 

    

    public static void major(String args[]) {

        BinaryTree tree = new BinaryTree();

        tree.root = new Node('a');

        tree.root.left = new Node('b');

        tree.root.proper = new Node('c');

        tree.root.left.left = new Node('d');

        tree.root.left.proper = new Node('e');

        tree.root.proper.left = new Node('f');

        tree.root.proper.proper = new Node('g');

        tree.root.left.left.left = new Node('h');

        tree.root.left.left.proper = new Node('i');

        tree.root.left.proper.left = new Node('j');

        tree.root.left.proper.proper = new Node('ok');

        tree.root.proper.left.left = new Node('l');

        tree.root.proper.left.proper = new Node('m');

        tree.root.proper.proper.left = new Node('n');

        tree.root.proper.proper.proper = new Node('o');

        System.out.println("Inorder Traversal of given tree");

        tree.printInorder();

 

        tree.reverseAlternate();

        System.out.println("");

        System.out.println("");

        System.out.println("Inorder Traversal of modified tree");

        tree.printInorder();

    }

}

 

Related Articles

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Latest Articles