Merge branch 'main' of https://github.com/Yashi11/data-structures-and-algorithms

Author: Yashi11

Arrays/Dutch-national-flag.cpp

@@ -0,0 +1,53 @@
+
+// Given an array nums with n objects colored red, white, or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white, and blue.
+
+// We will use the integers 0, 1, and 2 to represent the color red, white, and blue, respectively.
+
+// Input: nums = [2,0,2,1,1,0]
+// Output: [0,0,1,1,2,2]
+
+// Time and space complexity of the solution
+
+// Time complexity: O(n)
+// Space complexity: O(1)
+
+
+
+
+#include <bits/stdc++.h>
+using namespace std;
+
+void sortColors(vector<int> &nums)
+{
+    // created 3 variables start , low and end which are pointing start and low which are pointing to first index , end is pointing to last index .
+
+    int start = 0, low = 0, end = nums.size() - 1;
+    while (low <= end)
+    {
+        if (nums[low] == 0) // checking if element of low is 0 . If yes then  swap to start and low .
+        {
+            swap(nums[low], nums[start]);
+            start++, low++;
+        }
+        else if (nums[low] == 1) // checking if element at low index is 1 , If yes then increase the index by 1 .
+        {
+            low++;
+        }
+        else // else swap the element of low index to end .
+        {
+            swap(nums[low], nums[end]);
+            end--;
+        }
+    }
+}
+int main()
+{
+    vector<int> nums{2, 0, 2, 1, 1, 0};
+    sortColors(nums);
+
+    // Printing array's elements ..
+    for (auto i : nums)
+    {
+        cout << i << " ";
+    }
+}

Arrays/find_first_duplicate_value.java

@@ -0,0 +1,53 @@
+/* Sure, here's a brief explanation of each solution:
+
+Solution 1 (O(n) time, O(1) space):
+This solution uses Floyd's Tortoise and Hare algorithm to find the first duplicate value in the array. 
+It initializes two pointers, a slow pointer and a fast pointer, to the first value in the array. 
+The slow pointer moves one step at a time, while the fast pointer moves two steps at a time. 
+When they meet at a certain point, it indicates that there is a cycle in the array. 
+Then, the slow pointer is reset to the first value, and both pointers move one step at a time until they meet again, 
+which is the start of the cycle (i.e., the first duplicate value in the array).
+
+Solution 2 (O(n) time, O(n) space):
+This solution uses a HashSet to keep track of the integers that have been seen so far in the array. 
+As the array is iterated over, each integer is checked to see if it is already in the set. 
+If it is, then it is returned as the first integer that appears more than once. 
+If no such integer is found, then -1 is returned. This solution has a time complexity of O(n) and a space complexity of O(n). */
+
+// Solution 1: O(n) time and O(1) space
+public static int findDuplicate(int[] nums) {
+    // iterate through the array
+    for (int i = 0; i < nums.length; i++) {
+        // calculate the absolute value of the current element
+        int val = Math.abs(nums[i]);
+        // check if the value at the calculated index is negative
+        if (nums[val - 1] < 0) {
+            // if it is, return the absolute value of the current element
+            return val;
+        }
+        // otherwise, negate the value at the calculated index
+        nums[val - 1] = -nums[val - 1];
+    }
+    // if no duplicate is found, return -1
+    return -1;
+}
+
+
+// Solution 2: O(n) time and O(n) space solution:
+public static int findDuplicate(int[] nums) {
+    // create a set to keep track of visited elements
+    Set<Integer> visited = new HashSet<>();
+    // iterate through the array
+    for (int num : nums) {
+        // check if the current element has already been visited
+        if (visited.contains(num)) {
+            // if it has, return the current element
+            return num;
+        }
+        // otherwise, add it to the set of visited elements
+        visited.add(num);
+    }
+    // if no duplicate is found, return -1
+    return -1;
+}
+

Linked List/Singly_linked_list_in_Python.py

@@ -0,0 +1,47 @@
+'''
+This is an implementation of a singly linked list in Python with a Node class and a LinkedList class. The Node class represents each element of the linked list and the LinkedList class has methods to manipulate the list, including append, prepend, delete_node, and print_list.
+'''
+
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None  # The next node in the list
+
+class LinkedList:
+    def __init__(self):
+        self.head = None  # The first node in the list
+
+    def append(self, data):
+        new_node = Node(data)
+        if not self.head:  # If the list is empty, set the new node as the head
+            self.head = new_node
+            return
+        curr_node = self.head
+        while curr_node.next:  # Traverse to the last node in the list
+            curr_node = curr_node.next
+        curr_node.next = new_node  # Set the next node of the last node to the new node
+
+    def prepend(self, data):
+        new_node = Node(data)
+        new_node.next = self.head  # Set the next node of the new node to the current head
+        self.head = new_node  # Set the new node as the new head
+
+    def delete_node(self, data):
+        if not self.head:  # If the list is empty, do nothing
+            return
+        if self.head.data == data:  # If the head is the node to delete, set the next node as the new head
+            self.head = self.head.next
+            return
+        curr_node = self.head
+        while curr_node.next:  # Traverse the list until the last node
+            if curr_node.next.data == data:  # If the next node is the node to delete, set the next node of the current node to the node after the next node
+                curr_node.next = curr_node.next.next
+                return
+            curr_node = curr_node.next
+
+    def print_list(self):
+        curr_node = self.head
+        while curr_node:  # Traverse the list and print each node's data
+            print(curr_node.data)
+            curr_node = curr_node.next
+

Linked List/middleOfTheLinkedList.cpp

@@ -0,0 +1,75 @@
+// Given the head of a singly linked list, return the middle node of the linked list.
+// If there are two middle nodes, return the second middle node.
+
+//  Input: head = [1,2,3,4,5]
+// Output: [3,4,5]
+// Explanation: The middle node of the list is node 3.
+
+// TIME ANS SPACE COMPLEXITY OF THE SOLUTION IS :: 
+// Time complexity: O(n)
+// Space complexity: O(1)
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// creating Node manualy
+class Node
+{
+public:
+    int data;
+    Node *next;
+
+    Node()
+    {
+        this->data = 0;
+        this->next = NULL;
+    }
+    Node(int data)
+    {
+        this->data = data;
+        this->next = NULL;
+    }
+};
+
+Node *middleNode(Node *head)
+{
+
+    Node *slow = head;
+    Node *fast = head;
+
+    // Move slow pointer by one node at a time and fast pointer two nodes at a time.
+    // While fast pointer reaches the end, slow pointer must have reached the middle node.
+
+    while (fast != NULL)
+    {
+        fast = fast->next;
+        if (fast != NULL)
+        {
+            fast = fast->next;
+            slow = slow->next;
+        }
+    }
+    return slow; // return slow as ans
+}
+
+int main()
+{
+    // creating nodes.
+    Node *first = new Node(1);
+    Node *second = new Node(2);
+    Node *third = new Node(3);
+    Node *fourth = new Node(4);
+    Node *fifth = new Node(5);
+
+    // head of linked list
+    Node *head = first;
+
+    // Creating connection of nodes
+    first->next = second;
+    second->next = third;
+    third->next = fourth;
+    fourth->next = fifth;
+
+    cout << "The middle node of the list is node " << middleNode(head)->data << endl;
+    return 0;
+}

Math/Find_Hamming_dis.cpp

@@ -0,0 +1,52 @@
+/*
+Example:
+Input: nums = [4,14,2]
+Output: 6
+
+Explanation: 
+In binary representation, the 4 is 0100, 14 is 1110, and 2 is 0010 (just
+showing the four bits relevant in this case).
+The answer will be:
+HammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6.
+
+Detailed Explanation:
+The totalHammingDistance function takes a reference to a vector of integers nums, and returns the total Hamming distance between all possible pairs of elements in the vector.
+
+In the function, we initialize the answer ans to 0, and the size of the vector n is obtained using the size() method of the vector. We then loop through all 32 bits (since we are dealing with 32-bit integers), and for each bit position i, we count the number of elements in nums with the i-th bit set by looping through all elements and checking if the bit is set using bitwise AND operator &.
+
+The count c is then multiplied by (n-c), which gives the number of pairs with different bits at the i-th position. This count is added to the answer ans. Finally, the function returns the total Hamming distance.
+The main function is just an example usage, where we create a vector nums and call the totalHammingDistance method of a Solution object to get the total Hamming distance between all possible pairs of elements in nums.
+*/
+// code:
+
+#include<iostream>
+#include <vector>
+
+using namespace std;
+
+class Solution {
+public:
+    int totalHammingDistance(vector<int>& nums) {
+        int ans = 0;
+        int n = nums.size();
+        for(int i = 0; i < 32; i++) {
+            int c = 0;
+            for(int j = 0; j < n; j++) {
+                if((nums[j] & (1 << i))) {
+                    c++;
+                }
+            }
+            ans += (c * (n - c));
+        }
+        return ans;
+    }
+};
+
+int main() {
+    // Example usage
+    vector<int> nums = {4, 14, 2};
+    Solution s;
+    int result = s.totalHammingDistance(nums);
+    return 0;
+}
+

Searching/linear_search_first_duplicate_value.js

@@ -0,0 +1,60 @@
+/*  PROBLEM STATEMENT  */
+
+/*  Given an array of integers between 1 and n, inclusive, where n is the length of the array, 
+    write a function that returns the first integer that appears more than once (when the array
+    is read from left to right). 
+*/
+
+
+
+/*  The difference between the two solutions provided is that the first solution has a space complexity
+    of 0(1), meaning constant space complexity, while the second solution has a space complexity of 0(n),
+    meaning linear space complexity. finally both solutions has a time complexity of 0(n), meaning linear
+    time complexity.
+*/
+
+
+
+//  Big-O = O(n) time complexity
+//  Big-O = O(1) space complexity
+const firstDuplicate1 = arr => {
+    
+    // firstly iterate/loop through the given array
+    for(let i = 0; i < arr.length; i++){
+        // then use the Array.prototype.lastIndexOf() method to check for duplicates.
+        // finally return the first number that appers more than once.
+        if(arr.lastIndexOf(arr[i]) !== i) return arr[i];
+    };
+
+    // return the message No duplicate found, if no dupliacte is found after the iteration process.
+    return "No duplicate found!";
+}
+
+console.log(firstDuplicate1([2, 1, 5, 2, 3, 3, 4]));
+
+
+
+
+// Big-O = O(n) time complexity
+// Big-O = O(n) space complexity
+const firstDuplicate2 = arr => {
+
+    // first off, let's create our Set object
+    // this Set object will allow us to store each element from the given array as a unique value
+    let elementSet = new Set();
+    
+    // then iterate/loop through the given array
+    for (let i = 0; i < arr.length; i++) {
+        // we'll check to see if the Set already contains the element that we're currently on in our loop
+        // if it exists, then we've found our first duplicate! We'll return that value and be done
+        if (elementSet.has(arr[i])) return arr[i];
+        // if the element isn't in our Set yet, then we add it to the Set and move on to the next element in the array.
+        elementSet.add(arr[i]);
+    }
+
+    // return the message No duplicate found, if no dupliacte is found after the iteration process.
+    return "No duplicates found!";
+}
+
+console.log(firstDuplicate2([2, 1, 5, 2, 3, 3, 4]));
+