folder of set structured, not implemented

Author: CarlosAlegreUr

Algorithms/Graphs Algorithms/graph.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <vector>
+#include <list>
+
+class Graph
+{
+public:
+    Graph(int V) : V(V)
+    {
+        adj = new std::list<int>[V];
+    }
+
+    ~Graph()
+    {
+        delete[] adj;
+    }
+
+    void addEdge(int v, int w)
+    {
+        adj[v].push_back(w);
+    }
+
+    std::list<int> getAdj(int v) const
+    {
+        return adj[v];
+    }
+
+    int getV() const
+    {
+        return V;
+    }
+
+private:
+    int V;               // No. of vertices
+    std::list<int> *adj; // Pointer to an array containing adjacency lists
+};

Algorithms/Graphs Algorithms/weightedGraph.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <vector>
+#include <list>
+
+class Graph
+{
+public:
+    Graph(int V) : V(V)
+    {
+        adj = new std::list<std::pair<int, int>>[V];
+    }
+
+    ~Graph()
+    {
+        delete[] adj;
+    }
+
+    void addEdge(int v, int w, int weight)
+    {
+        adj[v].push_back(std::make_pair(w, weight));
+    }
+
+    std::list<std::pair<int, int>> getAdj(int v) const
+    {
+        return adj[v];
+    }
+
+    int getV() const
+    {
+        return V;
+    }
+
+private:
+    int V;                               // No. of vertices
+    std::list<std::pair<int, int>> *adj; // Pointer to an array containing adjacency lists
+};

Data Structures/Sets/Set/README.md

@@ -0,0 +1,31 @@
+# Set Implementation in C++
+
+This project provides an implementation of the Set data structure in C++. The Set is a container that stores unique elements in no particular order. 
+
+## Set Implementation Details
+
+Our Set data structure is implemented using a combination of a Hash Map (std::unordered_map) and a Vector of keys. This combination allows for efficient insert, delete, and find operations, while also maintaining the insertion order of the elements. 
+
+## Basic Operations of a Set
+
+This implementation supports the following basic operations:
+* Insert: Add an element to the set.
+* Remove: Remove an element from the set.
+* Contains: Check if an element is in the set.
+* Size: Returns the number of elements in the set.
+
+## Alternative Set Implementations
+
+Sets can be implemented with different data structures, each with its own trade-offs:
+
+* **Vector**: A simple array or vector can be used to implement a set. The elements can be kept sorted or unsorted. The advantage of using a vector is its simplicity and support for random access. However, insertion and deletion operations can be slow, especially for large sets.
+
+* **Linked List**: A linked list can also be used to implement a set. This provides efficient insertion and deletion operations but slower search times.
+
+* **Hashmap / Hashtable**: A hashmap can provide average-case constant time, O(1), for insert, delete, and find operations. This is a significant improvement over vector and linked list implementations. However, hashmaps do not preserve any order of elements, and they can be more space-inefficient due to the need to handle potential hash collisions.
+
+* **Balanced Binary Search Tree (e.g., AVL tree, Red-Black tree)**: These can provide a good trade-off between the speed of operations and the preservation of the order of elements. Insertion, deletion, and find operations can all be performed in O(log n) time, and they can also provide ordered traversal of elements.
+
+* **Bit Vector**: If the set elements are from a limited integer range, a bit vector can be used. Each bit in the bit vector represents whether an element is in the set.
+
+* **Trie**: If the set elements are strings, a Trie can be an efficient data structure for a set. A Trie can check if a string is in a set in O(m) time, where m is the length of the string. This can be faster than other data structures if the strings are long and the set is large.

Data Structures/Sets/Set/main.cpp

@@ -0,0 +1,47 @@
+#include <iostream>
+#include "set.h"
+#include "testSet.h"
+
+void interactWithUser() {
+    Set set;
+    char option = ' ';
+    int val = 0;
+
+    while (true) {
+        std::cout << "Please choose an option (i = insert, r = remove, c = contains, s = size, q = quit): ";
+        std::cin >> option;
+        switch (option) {
+            case 'i':
+                std::cout << "Enter a value to insert: ";
+                std::cin >> val;
+                set.insert(val);
+                break;
+            case 'r':
+                std::cout << "Enter a value to remove: ";
+                std::cin >> val;
+                set.remove(val);
+                break;
+            case 'c':
+                std::cout << "Enter a value to check: ";
+                std::cin >> val;
+                if (set.contains(val))
+                    std::cout << "The set contains " << val << ".\n";
+                else
+                    std::cout << "The set does not contain " << val << ".\n";
+                break;
+            case 's':
+                std::cout << "The set contains " << set.size() << " elements.\n";
+                break;
+            case 'q':
+                return;
+            default:
+                std::cout << "Unknown option: " << option << '\n';
+        }
+    }
+}
+
+int main() {
+    run_tests();
+    interactWithUser();
+    return 0;
+}

Data Structures/Sets/Set/makefile

@@ -0,0 +1,5 @@
+# Makefile
+all: main
+
+main: main.cpp set.cpp testSet.cpp
+    g++ -o main main.cpp set.cpp testSet.cpp

Data Structures/Sets/Set/set.cpp

@@ -0,0 +1,21 @@
+#include "set.h"
+
+Set::Set() {}
+
+Set::~Set() {}
+
+bool Set::insert(int val) {
+    // implementation goes here
+}
+
+bool Set::remove(int val) {
+    // implementation goes here
+}
+
+bool Set::contains(int val) {
+    // implementation goes here
+}
+
+std::size_t Set::size() const {
+    // implementation goes here
+}

Data Structures/Sets/Set/set.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <vector>
+#include <unordered_map>
+
+class Set {
+    std::vector<int> keys;
+    std::unordered_map<int, bool> hash_map;
+
+public:
+    Set();
+    ~Set();
+
+    bool insert(int val);
+    bool remove(int val);
+    bool contains(int val);
+    std::size_t size() const;
+};

Data Structures/Sets/Set/testSet.cpp

@@ -0,0 +1,36 @@
+#include "set.h"
+#include "testSet.h"
+#include <cassert>
+
+void test_insert_and_contains() {
+    Set set;
+    assert(set.insert(1) == true);
+    assert(set.contains(1) == true);
+    assert(set.insert(1) == false);
+    assert(set.contains(1) == true);
+}
+
+void test_remove() {
+    Set set;
+    assert(set.insert(1) == true);
+    assert(set.remove(1) == true);
+    assert(set.contains(1) == false);
+    assert(set.remove(1) == false);
+}
+
+void test_size() {
+    Set set;
+    assert(set.size() == 0);
+    assert(set.insert(1) == true);
+    assert(set.size() == 1);
+    assert(set.insert(2) == true);
+    assert(set.size() == 2);
+    assert(set.remove(1) == true);
+    assert(set.size() == 1);
+}
+
+void run_tests() {
+    test_insert_and_contains();
+    test_remove();
+    test_size();
+}

Data Structures/Sets/Set/testSet.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void run_tests();

Design Patterns/Structural/Adapter/README.md

@@ -0,0 +1,20 @@
+# Adapter Design Pattern
+
+The Adapter pattern is a structural design pattern that allows objects with incompatible interfaces to collaborate. It's often used when you want to make your own classes work with others without modifying their source code.
+
+## Structure
+
+The Adapter pattern involves a single class, the 'Adapter', which is responsible for communication between the existing ('Adaptee') and the new ('Target') systems.
+
+1. **Target**: This is the domain-specific interface that Client is expected to work with.
+2. **Adapter**: This adapts the interface Adaptee to the Target interface.
+3. **Adaptee**: This is the existing interface that needs adapting.
+4. **Client**: This collaborates with objects conforming to the Target interface.
+
+## When to use
+
+Use the Adapter pattern when you want to use some existing class, but its interface isn’t compatible with the rest of your code. The Adapter pattern lets you create a middle-layer class that serves as a translator between your code and a legacy class, a 3rd-party class or any other class with a weird interface.
+
+## Example
+
+An example can be a card reader acting as an adapter between a memory card and a laptop. The laptop's USB interface is not compatible with the memory card's interface. Therefore, the card reader adapts the memory card's interface to the laptop's interface.