.

Author: Dipto1971

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "files.associations": {
+        "iostream": "cpp",
+        "ostream": "cpp",
+        "new": "cpp"
+    }
+}

.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: g++.exe build active file",
+            "command": "C:\\MinGW\\bin\\g++.exe",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}\\${fileBasenameNoExtension}.exe"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "Task generated by Debugger."
+        }
+    ],
+    "version": "2.0.0"
+}

Assignments/7_BST_Menu.cpp

@@ -162,7 +162,7 @@ int main()
         }
         case 2:
             {
-                cout << "Enter the key to search: ";
+            cout << "Enter the key to search: ";
             cin >> data;
             struct node *result = search(root, data);
             if (result == NULL)

Final/Max_Heap.txt

@@ -0,0 +1,59 @@
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+// Returns true if arr[i..n-1] represents a max-heap
+bool isHeap(int arr[], int i, int n)
+{
+    // Base case: If a node is a leaf node, return true
+    if (i >= (n - 2) / 2)
+        return true;
+
+    // Compare the current node with its children
+    // If the current node is greater than or equal to its children
+    // and the left and right subtrees are also max-heaps, return true
+    if (arr[i] >= arr[2 * i + 1] &&
+        arr[i] >= arr[2 * i + 2] &&
+        isHeap(arr, 2 * i + 1, n) &&
+        isHeap(arr, 2 * i + 2, n))
+        return true;
+
+    // If any of the above conditions fails, return false
+    return false;
+}
+
+int main()
+{
+    int arr[] = {90, 15, 10, 7, 12, 2, 7, 3};
+    int n = sizeof(arr) / sizeof(int) - 1;
+
+    isHeap(arr, 0, n) ? printf("Yes") : printf("No");
+
+    return 0;
+}
+
+1. Initially, `isHeap(arr, 0, n)` is called with `i` as 0 and `n` as 7 (since `n` is the size of the array minus 1).
+2. In the first recursive call, it checks the condition for the root node (index 0):
+
+   - `arr[0]` is 90
+   - `arr[2 * 0 + 1]` is 15
+   - `arr[2 * 0 + 2]` is 10
+
+   Since 90 is greater than or equal to both its children, it proceeds to check the left and right subtrees.
+3. In the left subtree (`isHeap(arr, 2 * 0 + 1, n)`), it checks the condition for the node at index 1:
+
+   - `arr[1]` is 15
+   - `arr[2 * 1 + 1]` is 7
+   - `arr[2 * 1 + 2]` is 12
+
+   Since 15 is greater than or equal to both its children, it proceeds to check their subtrees.
+4. The recursion continues in a similar manner for the left subtree and then the right subtree.
+
+Now, let's calculate the output:
+
+- All nodes satisfy the max-heap property, so it returns `true`.
+
+As a result, the program will print "Yes" because the given array represents a binary max-heap.
+
+The output of the program is: "Yes".

Syntax & Operations/08_Graph/BFS_DFS.pdf

@@ -0,0 +1,138 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+class RadixTreeNode {
+public:
+    std::unordered_map<char, RadixTreeNode*> children;
+    bool isEndOfWord;
+
+    RadixTreeNode() : isEndOfWord(false) {}
+
+    ~RadixTreeNode() {
+        for (auto& pair : children) {
+            delete pair.second;
+        }
+    }
+};
+
+class RadixTree {
+private:
+    RadixTreeNode* root;
+
+public:
+    RadixTree() {
+        root = new RadixTreeNode();
+    }
+
+    ~RadixTree() {
+        delete root;
+    }
+
+    // Insert a string into the radix tree
+    void insert(const std::string& key) {
+        RadixTreeNode* node = root;
+
+        for (char c : key) {
+            if (node->children.find(c) == node->children.end()) {
+                node->children[c] = new RadixTreeNode();
+            }
+            node = node->children[c];
+        }
+
+        node->isEndOfWord = true;
+    }
+
+    // Search for a string in the radix tree
+    bool search(const std::string& key) {
+        RadixTreeNode* node = root;
+
+        for (char c : key) {
+            if (node->children.find(c) == node->children.end()) {
+                return false; // Character not found in the tree
+            }
+            node = node->children[c];
+        }
+
+        return node->isEndOfWord; // Return true if it's an end-of-word node
+    }
+
+    // Delete a string from the radix tree
+    void remove(const std::string& key) {
+        removeHelper(root, key, 0);
+    }
+
+private:
+    // Recursive helper function for deletion
+    bool removeHelper(RadixTreeNode* node, const std::string& key, int depth) {
+        if (node == nullptr) {
+            return false; // Key not found
+        }
+
+        if (depth == key.length()) {
+            if (node->isEndOfWord) {
+                node->isEndOfWord = false; // Mark as non-end-of-word
+                return true; // Key found and marked as deleted
+            }
+            return false; // Key not found
+        }
+
+        char currentChar = key[depth];
+        if (removeHelper(node->children[currentChar], key, depth + 1)) {
+            // If child node is marked as deleted, check if it can be removed
+            if (node->children[currentChar]->children.empty() && !node->children[currentChar]->isEndOfWord) {
+                delete node->children[currentChar];
+                node->children.erase(currentChar);
+            }
+            return true;
+        }
+        return false;
+    }
+};
+
+int main() {
+    RadixTree tree;
+    std::string choice;
+
+    while (true) {
+        std::cout << "\nRadix Tree Menu:\n";
+        std::cout << "1. Insert a string\n";
+        std::cout << "2. Delete a string\n";
+        std::cout << "3. Search for a string\n";
+        std::cout << "4. Exit\n";
+        std::cout << "Enter your choice: ";
+        std::cin >> choice;
+
+        if (choice == "1") {
+            std::string key;
+            std::cout << "Enter a string to insert: ";
+            std::cin >> key;
+            tree.insert(key);
+            std::cout << "'" << key << "' inserted into the tree.\n";
+        } else if (choice == "2") {
+            std::string key;
+            std::cout << "Enter a string to delete: ";
+            std::cin >> key;
+            if (tree.search(key)) {
+                tree.remove(key);
+                std::cout << "'" << key << "' deleted from the tree.\n";
+            } else {
+                std::cout << "'" << key << "' not found in the tree.\n";
+            }
+        } else if (choice == "3") {
+            std::string key;
+            std::cout << "Enter a string to search: ";
+            std::cin >> key;
+            if (tree.search(key)) {
+                std::cout << "'" << key << "' found in the tree.\n";
+            } else {
+                std::cout << "'" << key << "' not found in the tree.\n";
+            }
+        } else if (choice == "4") {
+            break; // Exit the program
+        } else {
+            std::cout << "Invalid choice. Please try again.\n";
+        }
+    }
+
+    return 0;
+}