refactor

Author: goel4ever

src/data-structure/array/implementation.md

@@ -0,0 +1,62 @@
+# Implementation
+
+### Example
+
+Here is a simple example of how arrays are used in C++:
+
+```cpp
+#include <iostream>
+using namespace std;
+
+int main() {
+    // Declare and initialize an array
+    int arr[5] = {1, 2, 3, 4, 5};
+
+    // Access elements
+    cout << "Element at index 2: " << arr[2] << endl; // Output: 3
+
+    // Insert an element (inefficient)
+    int n = 5; // Current size of the array
+    int newArr[6];
+    for (int i = 0; i < n; i++) {
+        newArr[i] = arr[i];
+    }
+    newArr[2] = 10; // Inserting 10 at index 2
+    for (int i = 2; i < n; i++) {
+        newArr[i + 1] = arr[i];
+    }
+    n++;
+    cout << "Array after insertion: ";
+    for (int i = 0; i < n; i++) {
+        cout << newArr[i] << " ";
+    }
+    cout << endl;
+
+    // Delete an element (inefficient)
+    for (int i = 2; i < n - 1; i++) {
+        newArr[i] = newArr[i + 1];
+    }
+    n--;
+    cout << "Array after deletion: ";
+    for (int i = 0; i < n; i++) {
+        cout << newArr[i] << " ";
+    }
+    cout << endl;
+
+    // Traverse the array
+    cout << "Traversing the array: ";
+    for (int i = 0; i < n; i++) {
+        cout << newArr[i] << " ";
+    }
+    cout << endl;
+
+    return 0;
+}
+```
+
+In this example:
+- We declare and initialize an array.
+- We access an element using its index.
+- We insert a new element at a specific index, which requires shifting elements.
+- We delete an element, which also requires shifting elements.
+- We traverse the array and print each element.

src/data-structure/array/index.md

@@ -0,0 +1,68 @@
+# Array
+
+### What is an Array?
+
+An array is a data structure that consists of a collection of elements, each identified by at least one array index or key. Arrays are one of the simplest and most widely used data structures in programming. They store elements of the same type in contiguous memory locations, allowing efficient access to any element using its index.
+
+### Key Characteristics
+
+1. **Fixed Size**: The size of an array is determined at the time of its creation and cannot be changed dynamically.
+2. **Homogeneous Elements**: All elements in an array are of the same data type.
+3. **Contiguous Memory Allocation**: Elements are stored in consecutive memory locations, allowing for efficient index-based access.
+4. **Indexed Access**: Elements can be accessed directly using their index, typically starting from 0 in most programming languages.
+
+### Types of Arrays
+
+1. **One-Dimensional Array**: A linear array where elements are accessed using a single index.
+   - Example: `int arr[5] = {1, 2, 3, 4, 5};`
+
+2. **Multi-Dimensional Array**: Arrays with more than one dimension, such as two-dimensional arrays (matrices).
+   - Example: `int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};`
+
+3. **Dynamic Arrays**: Arrays that can change size dynamically during runtime, such as vectors in C++ or ArrayList in Java.
+
+### Operations on Arrays
+
+1. **Accessing Elements**
+    - Elements are accessed using their index.
+    - Example: `arr[2]` accesses the third element in the array `arr`.
+
+2. **Insertion**
+    - Adding an element at a specific index requires shifting elements to make space.
+    - Example: To insert an element at index 2, shift elements from index 2 onwards and then place the new element.
+
+3. **Deletion**
+    - Removing an element requires shifting elements to fill the gap.
+    - Example: To delete an element at index 2, shift elements from index 3 onwards one position to the left.
+
+4. **Traversal**
+    - Visiting each element of the array for processing.
+    - Example: Using a loop to print all elements of the array.
+
+5. **Searching**
+    - Finding the index of an element in the array.
+    - Linear Search: O(n) time complexity.
+    - Binary Search: O(log n) time complexity (requires sorted array).
+
+6. **Sorting**
+    - Arranging elements in a specific order (ascending or descending).
+    - Example: Using sorting algorithms like Quick Sort, Merge Sort, or Bubble Sort.
+
+### Advantages of Arrays
+
+1. **Constant-Time Access**: Elements can be accessed in O(1) time using their index.
+2. **Memory Efficiency**: Arrays have a low memory overhead compared to other data structures like linked lists.
+3. **Cache-Friendly**: Contiguous memory allocation makes arrays more cache-friendly, leading to better performance in terms of memory access speed.
+
+### Disadvantages of Arrays
+
+1. **Fixed Size**: The size of the array is fixed and cannot be changed after its creation, leading to potential wastage of memory or insufficient space.
+2. **Inefficient Insertion/Deletion**: Inserting or deleting elements, especially in the middle, can be inefficient as it requires shifting elements.
+3. **Homogeneous Data**: Arrays can only store elements of the same type, limiting flexibility.
+
+### Applications of Arrays
+
+1. **Storing and Accessing Data**: Arrays are used to store data that needs to be accessed quickly using indices.
+2. **Implementation of Other Data Structures**: Arrays are the foundation for implementing other data structures like stacks, queues, and hash tables.
+3. **Mathematical Computations**: Arrays are used in scientific computations and matrix operations.
+4. **Graphics and Image Processing**: Arrays are used to store pixel values and manipulate images.

src/data-structure/graph/implementation.md

@@ -0,0 +1,225 @@
+# Implementation
+
+### Java Implementation of a Graph
+
+Here’s a simple implementation of a graph in Java using an adjacency list representation.
+
+#### Graph Class
+
+```java
+import java.util.*;
+
+class Graph {
+    private int numVertices;
+    private LinkedList<Integer>[] adjLists;
+
+    // Constructor
+    public Graph(int vertices) {
+        numVertices = vertices;
+        adjLists = new LinkedList[vertices];
+        for (int i = 0; i < vertices; i++) {
+            adjLists[i] = new LinkedList<>();
+        }
+    }
+
+    // Add edge
+    public void addEdge(int src, int dest) {
+        adjLists[src].add(dest);
+        adjLists[dest].add(src); // For undirected graph, add both connections
+    }
+
+    // Print the graph
+    public void printGraph() {
+        for (int i = 0; i < numVertices; i++) {
+            System.out.print("Vertex " + i + ":");
+            for (Integer node : adjLists[i]) {
+                System.out.print(" -> " + node);
+            }
+            System.out.println();
+        }
+    }
+
+    // Depth First Search (DFS) traversal
+    public void DFS(int vertex) {
+        boolean[] visited = new boolean[numVertices];
+        DFSUtil(vertex, visited);
+    }
+
+    private void DFSUtil(int vertex, boolean[] visited) {
+        visited[vertex] = true;
+        System.out.print(vertex + " ");
+
+        for (int adj : adjLists[vertex]) {
+            if (!visited[adj]) {
+                DFSUtil(adj, visited);
+            }
+        }
+    }
+
+    // Breadth First Search (BFS) traversal
+    public void BFS(int startVertex) {
+        boolean[] visited = new boolean[numVertices];
+        LinkedList<Integer> queue = new LinkedList<>();
+
+        visited[startVertex] = true;
+        queue.add(startVertex);
+
+        while (queue.size() != 0) {
+            int vertex = queue.poll();
+            System.out.print(vertex + " ");
+
+            for (int adj : adjLists[vertex]) {
+                if (!visited[adj]) {
+                    visited[adj] = true;
+                    queue.add(adj);
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        Graph graph = new Graph(5);
+
+        graph.addEdge(0, 1);
+        graph.addEdge(0, 4);
+        graph.addEdge(1, 2);
+        graph.addEdge(1, 3);
+        graph.addEdge(1, 4);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 4);
+
+        graph.printGraph();
+
+        System.out.println("Depth First Search starting from vertex 0:");
+        graph.DFS(0);
+
+        System.out.println("\nBreadth First Search starting from vertex 0:");
+        graph.BFS(0);
+    }
+}
+```
+
+### Explanation
+
+**Graph Class:**
+
+```java
+class Graph {
+    private int numVertices;
+    private LinkedList<Integer>[] adjLists;
+
+    // Constructor
+    public Graph(int vertices) {
+        numVertices = vertices;
+        adjLists = new LinkedList[vertices];
+        for (int i = 0; i < vertices; i++) {
+            adjLists[i] = new LinkedList<>();
+        }
+    }
+}
+```
+
+The `Graph` class represents a graph with a specified number of vertices. The adjacency list is used to store the graph, with each vertex having a linked list of its adjacent vertices.
+
+**Add Edge Function:**
+
+```java
+public void addEdge(int src, int dest) {
+    adjLists[src].add(dest);
+    adjLists[dest].add(src); // For undirected graph, add both connections
+}
+```
+
+This function adds an edge between two vertices in the graph. For an undirected graph, edges are added in both directions.
+
+**Print Graph Function:**
+
+```java
+public void printGraph() {
+    for (int i = 0; i < numVertices; i++) {
+        System.out.print("Vertex " + i + ":");
+        for (Integer node : adjLists[i]) {
+            System.out.print(" -> " + node);
+        }
+        System.out.println();
+    }
+}
+```
+
+This function prints the graph's adjacency list representation.
+
+**Depth First Search (DFS) Function:**
+
+```java
+public void DFS(int vertex) {
+    boolean[] visited = new boolean[numVertices];
+    DFSUtil(vertex, visited);
+}
+
+private void DFSUtil(int vertex, boolean[] visited) {
+    visited[vertex] = true;
+    System.out.print(vertex + " ");
+
+    for (int adj : adjLists[vertex]) {
+        if (!visited[adj]) {
+            DFSUtil(adj, visited);
+        }
+    }
+}
+```
+
+The DFS function recursively traverses the graph starting from a given vertex. It uses a boolean array to keep track of visited vertices.
+
+**Breadth First Search (BFS) Function:**
+
+```java
+public void BFS(int startVertex) {
+    boolean[] visited = new boolean[numVertices];
+    LinkedList<Integer> queue = new LinkedList<>();
+
+    visited[startVertex] = true;
+    queue.add(startVertex);
+
+    while (queue.size() != 0) {
+        int vertex = queue.poll();
+        System.out.print(vertex + " ");
+
+        for (int adj : adjLists[vertex]) {
+            if (!visited[adj]) {
+                visited[adj] = true;
+                queue.add(adj);
+            }
+        }
+    }
+}
+```
+
+The BFS function iteratively traverses the graph starting from a given vertex using a queue to manage the traversal.
+
+**Main Method:**
+
+```java
+public static void main(String[] args) {
+    Graph graph = new Graph(5);
+
+    graph.addEdge(0, 1);
+    graph.addEdge(0, 4);
+    graph.addEdge(1, 2);
+    graph.addEdge(1, 3);
+    graph.addEdge(1, 4);
+    graph.addEdge(2, 3);
+    graph.addEdge(3, 4);
+
+    graph.printGraph();
+
+    System.out.println("Depth First Search starting from vertex 0:");
+    graph.DFS(0);
+
+    System.out.println("\nBreadth First Search starting from vertex 0:");
+    graph.BFS(0);
+}
+```
+
+### Conclusion
+
+This example demonstrates how to implement a graph in Java using an adjacency list. The `Graph` class includes methods to add edges, print the graph, and perform both Depth First Search (DFS) and Breadth First Search (BFS) traversals. This basic implementation can be extended to handle more complex operations and types of graphs, such as weighted and directed graphs.

src/data-structure/graph/index.md

@@ -0,0 +1,8 @@
+### Understanding Graphs
+
+A graph is a collection of nodes (also called vertices) and edges that connect pairs of nodes. Graphs can be:
+- **Directed or Undirected:** In a directed graph, edges have a direction, while in an undirected graph, edges do not.
+- **Weighted or Unweighted:** In a weighted graph, edges have weights or costs associated with them. In an unweighted graph, all edges are considered equal.
+- **Sparse or Dense:** A sparse graph has relatively few edges compared to the number of nodes, while a dense graph has many edges.
+
+Graphs are used to represent various real-world systems such as social networks, transportation networks, and communication networks.