Merge pull request #458 from ishriayush/main

Add files via upload

Author: Sirajmolla

aa_tree.cpp

@@ -0,0 +1,238 @@
+
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+using namespace std;
+/*
+ * Node Declaration
+ */
+struct node
+{
+    int count, level;
+    string key; 
+    node *right;
+    node *left;
+    node *parent;
+    node *root;
+}*root;
+ 
+/*
+ * Class Declaration
+ */
+class AATree
+{
+    public:
+        int lookup(string &);
+        void skew(node *);
+        bool split(node *);
+        void rebal(node *);
+        node *insert(node *,node *);
+        void print(node *);
+        int countnode(node *);
+        AATree()
+    {
+            root = NULL;
+        }
+};
+ 
+/*
+ * Main: Contains Menu
+ */
+int main()
+{
+    AATree at;
+    int ch;
+    string x;
+    ifstream fin ("test.txt");
+    while (1)
+    {
+        cout<<"\n---------------------"<<endl;
+        cout<<"\nOperations on AA Tree"<<endl;
+        cout<<"\n---------------------"<<endl;
+        cout<<"1.Insert String into the Tree"<<endl;
+        cout<<"2.Print Tree Data"<<endl;
+        cout<<"3.Total Tree Nodes"<<endl;
+        cout<<"4.Exit"<<endl;
+        cout<<"Enter Your Choice: ";
+        cin>>ch;
+        switch (ch)
+        {
+        case 1:
+            if (fin.is_open())
+            {
+                while (fin>>x)
+                {
+                    at.lookup(x);
+                }
+                fin.close();
+            }
+        break;
+        case 2:
+            cout<<"Elemets of AA Tree"<<endl;
+            at.print(root);
+            break;
+        case 3:
+            cout<<"Total number of nodes"<<endl;
+            cout<<at.countnode(root)<<endl;
+            break;
+        case 4:
+            cout<<"Exiting"<<endl;
+            exit(1);
+            break;
+        default:
+            cout<<"Wrong Choice"<<endl;
+        }
+    }
+    return 0;
+}
+/*
+ * Insert String into the Tree
+ */
+int AATree::lookup(string &key)
+{
+    node *temp = new node;
+    temp->key = key;
+    temp->level = 1;
+    temp->count = 0;
+    temp->left = NULL;
+    temp->right = NULL;
+    temp->parent = NULL;
+    temp = insert(root, temp);
+    return temp->count;
+}
+ 
+/*
+ * Skew Tree
+ */
+ 
+void AATree::skew(node *temp)
+{
+    node *ptr = temp->left;
+    if (temp->parent->left == temp)
+        temp->parent->left = ptr;
+    else
+        temp->parent->right = ptr;
+    ptr->parent = temp->parent;
+    temp->parent = ptr;
+    temp->left = ptr->right;
+    if (temp->left != NULL)
+        temp->left->parent = temp;
+    ptr->right = temp;
+    temp->level = (temp->left ? temp->left->level + 1 : 1);
+}
+ 
+/*
+ * Splitting of AA Tree
+ */
+bool AATree::split(node *temp)
+{
+    node* ptr = temp->right;
+    if (ptr && ptr->right && (ptr->right->level == temp->level))
+    {
+        if (temp->parent->left == temp)
+            temp->parent->left = ptr;
+        else
+            temp->parent->right = ptr;
+        ptr->parent = temp->parent;
+        temp->parent = ptr;
+        temp->right = ptr->left;
+        if (temp->right != NULL)
+            temp->right->parent = temp;
+        ptr->left = temp;
+        ptr->level = temp->level + 1;
+        return true;
+    }
+    return false;
+}
+ 
+/*
+ * Rebalancing of AA Tree
+ */
+void AATree::rebal(node* temp)
+{
+    temp->left = NULL;
+    temp->right = NULL;
+    temp->level = 1;
+    for (temp = temp->parent; temp != root; temp = temp->parent)
+    {
+        if (temp->level != (temp->left ? temp->left->level + 1 : 1 ))
+        {
+            skew(temp);
+            if (temp->right == NULL)
+                temp = temp->parent;
+            else if (temp->level != temp->right->level)
+                temp = temp->parent;
+        }
+        if (temp->parent != root)
+        {
+            if (split(temp->parent) == false)
+                break;
+        }
+    }
+}
+ 
+/*
+ * Insert Function to insert string into the tree
+ */
+node* AATree::insert(node* temp, node* ins)
+{
+    if (root == NULL)
+    {
+        ins->count = 1;
+        ins->parent = NULL;
+        ins->left = NULL;
+        ins->right = NULL;
+        root = ins;
+        return root;
+    }
+    if (ins->key < temp->key)
+    {
+        if (temp->left)
+            return insert(temp->left, ins);
+        temp->left = ins;
+        ins->parent = temp;
+        ins->count = 1;
+        rebal(ins);
+        return ins;
+    }
+    if (ins->key > temp->key)
+    {
+        if (temp->right)
+            return insert(temp->right, ins);
+        temp->right = ins;
+        ins->parent = temp;
+        ins->count = 1;
+        rebal(ins);
+        return ins;
+    }
+    temp->count++;
+    delete ins;
+    return temp;
+}
+ 
+/*
+ * Display Tree Elements
+ */
+void AATree::print(node* temp)
+{
+    if (!temp)
+        return;
+    print(temp->left);
+    cout <<"Value: "<<temp->key << "  Count:" << temp->count;
+    cout<<"  Level: "<<temp->level<<endl;
+    print(temp->right);
+}
+ 
+/*
+ * Count number of nodes in AA Tree
+ */
+int AATree::countnode(node* temp)
+{
+    if (!temp)
+        return 0;
+    int count = 1;
+    count = count + countnode(temp->left);
+    count = count + countnode(temp->right);
+    return count;
+}

binary-space-partitioning.cpp

@@ -0,0 +1,66 @@
+// Language: cpp
+// Path: Tree/binary-space-partitioning.cpp
+// Implementation of the binary space partitioning tree.
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// A node of the tree.
+struct Node {
+    int x, y;
+    Node *left, *right;
+    Node(int x, int y) : x(x), y(y), left(NULL), right(NULL) {}
+};
+
+// A comparator for sorting the points by x-coordinate.
+struct XComparator {
+    bool operator()(const Node *a, const Node *b) {
+        return a->x < b->x;
+    }
+};
+
+// A comparator for sorting the points by y-coordinate.
+struct YComparator {
+    bool operator()(const Node *a, const Node *b) {
+        return a->y < b->y;
+    }
+};
+
+// Builds a binary space partitioning tree for the given points.
+Node *build(vector<Node *> &points, int depth) {
+    if (points.empty()) return NULL;
+    if (points.size() == 1) return points[0];
+    if (depth % 2 == 0) {
+        sort(points.begin(), points.end(), XComparator());
+    } else {
+        sort(points.begin(), points.end(), YComparator());
+    }
+    int mid = points.size() / 2;
+    Node *node = points[mid];
+    vector<Node *> left(points.begin(), points.begin() + mid);
+    vector<Node *> right(points.begin() + mid + 1, points.end());
+    node->left = build(left, depth + 1);
+    node->right = build(right, depth + 1);
+    return node;
+}
+
+// Prints the tree in the inorder traversal order.
+void print(Node *node) {
+    if (node == NULL) return;
+    print(node->left);
+    printf("(%d, %d), ", node->x, node->y);
+    print(node->right);
+}
+
+int main() {
+    vector<Node *> points;
+    points.push_back(new Node(2, 3));
+    points.push_back(new Node(5, 4));
+    points.push_back(new Node(9, 6));
+    points.push_back(new Node(4, 7));
+    points.push_back(new Node(8, 1));
+    points.push_back(new Node(4, 2));
+    Node *root = build(points, 0);
+    print(root);
+    return 0;
+}