JavaScript में बाइनरी ट्री को उल्टा करना

मान लीजिए, हमारे पास एक बाइनरी ट्री है जिसे इस तरह दर्शाया गया है -

    4
   / \
  2   7
 / \ / \
1  3 6  9

हमें एक JavaScript फ़ंक्शन लिखना है जो इस बाइनरी ट्री की जड़ लेता है और इसे उल्टा करता है।

उपरोक्त बाइनरी ट्री का उल्टा संस्करण इस तरह दिखेगा -

    4
    / \
   7   2
  / \ / \
 9  6 3  1

उदाहरण

इसके लिए कोड होगा -

// बाइनरी ट्री के लिए एकल ट्री नोड की क्लास
class Node{
    constructor(val){
        this.val = val;
        this.left = null;
        this.right = null;
    };
};
// बाइनरी ट्री के लिए क्लास
class BinaryTree{
    constructor(){
        // बाइनरी ट्री की जड़
        this.root = null;
    };
    insert = (data) => {
        // डेटा के साथ एक नया नोड बनाना
        const newNode = new Node(data);
        // यदि जड़ शून्य है, तो यह नोड जड़ होगा
        if(this.root === null){
            this.root = newNode;
        }else{
            // अन्यथा हम इस नोड को डालने के लिए सही स्थिति ढूंढते हैं
            this.insertData(this.root, newNode);
        };
    };
    insertData = (node, newNode) => {
        if(newNode.val < node.val){
            if(node.left === null){
                node.left = newNode;
            }else{
                this.insertData(node.left, newNode);
            }
        }else{
            if(node.right === null){
                node.right = newNode;
            }else{
                this.insertData(node.right, newNode);
            }
        }
    };
    // बाइनरी ट्री को उल्टा करने का फ़ंक्शन
    invert = (node) => {
        if(node === null){
            return;
        };
        [node.left, node.right] = [node.right, node.left];
        this.invert(node.right);
        this.invert(node.left);
    }
    traverse = (node) => {
        if(node === null){
            return;
        };
        this.traverse(node.right);
        console.log(node.val);
        this.traverse(node.left);
    };
};
const Tree = new BinaryTree();
Tree.insert(2);
Tree.insert(7);
Tree.insert(4);
Tree.insert(1);
Tree.insert(9);
Tree.insert(3);
Tree.insert(6);
// मूल दाएं से बाएं ट्रैवर्सल
Tree.traverse(Tree.root);
Tree.invert(Tree.root);
console.log('after inversion');
// उल्टा करने के बाद ट्रैवर्सल दाएं से बाएं
Tree.traverse(Tree.root);

आउटपुट

कंसोल में आउटपुट होगा -

9 7 6 4 3 2 1 after inversion 1 2 3 4 6 7 9