new question to be added

Author: arorarahul

README.md

@@ -22,6 +22,27 @@ only if there is one number that repeats odd number of times
 which has to be returned
 - Sometimes if the algo seems to be complicated move to a generalized format where the result is assumed to be N and you are solving it for some x by going from solution to problem, and then try to figure out the algo. (refer question 28.c for more clarification)
 
+### For Linked Lists: (methods that can be applied)
+- Use multiple variables to not loose track of the linked list and keep moving them ahead in a manner such that various operations can be done on a linked list
+- If you dont want a function to return a value of something, just send that value to the address of the variable by passing the address of variable as argument and accessing it has **
+- maintain hash table of addresses of the different nodes (first node has this address and so on) to access the value later without traversing
+- maintain multiple pointers. The pointers can be moved at different speeds as per requirements.
+- sometimes linked list while designed can have flags to make an algo possible
+- If linked list has a loop, and two pointers are taken one moving at double the speed of other, they will meet at some point inside the loop. The distance from the start of the list to the first node where the loop starts is equal to the distance from where they meet to the first node.
+- Linked list is generally is used to store large numbers which cannot be stored in an int or is used to store polynomials. If numbers are stored in linked list, you will have to apply your own operations (add, subt and so on for that)
+- Use general Data structures like stacks and queues or arrays to sometimes solve the algo.
+- Try connecting the end of the linked list to the front or make a loop to solve an algo.
+- To make games like snakes & ladders, we can use a linked list with a random pointer, next pointer and data.
+Whenever there is a ladder or snake, the random pointer will point there else it will be NULL.
+- Consider making additional connections (links to the new list or old list) for traversing or reference point of view when there are multiple things involved (random node eg:). New node sometimes can be added in the middle of the two nodes to maintain a connection and so on.
+
+### For Hashing: (methods that can be applied)
+-  When solving questions divide value with the size of the hashTable. Keep the size of the hash table one
+greater than size of elements to be stored.
+- Solve using chaining or linear probing
+- Heap, BBST-AVL are some popular data structures that can be also used for questions involving hash table.
+- Binary search is very widely used. Can only be applied if the length of array is known and if array is sorted.
+
 # General hash functions
 - take mod with number of elements present
 
@@ -123,6 +144,7 @@ TODO:
 - [General question to understand chaining](/hashing/general-question2.c)
 - [Check whether given array contains duplicates in k-distance or not](/hashing/question1.c)
 - [Check whether two sets given are disjoint or not](/hashing/question2.c)
+- [Group all the occurences of the elements order by their first occurence](/hashing/question3.c)
 
 
 ## Some important concepts to solve algos better

hashing/question2.c

@@ -31,7 +31,7 @@ Space complexity: O(m) OR O(n)
 */
 
 //METHOD2 will be done later
-===============================================================================================
+//===============================================================================================
 //METHOD3
 #include <stdio.h>
 #include <stdlib.h>

hashing/question3.c

@@ -0,0 +1,82 @@
+/*
+Group all the occurences of the elements order by their first occurence
+
+METHOD1:
+Just like quick sort, make an outer for loop to pick one element and then make an inner one to find the
+same element again. Once the element is found, shift all the elements to the right till the place where
+the element was found to make space for this element to group it. Repeat these steps for all elements
+Time complexity: O(n^2)
+Space complexity: O(1)
+
+METHOD2:
+Make a BBST-AVL. This tree will contain value of the element, and its frequency (no of times it has occured). Mkae
+this tree by traversing the array. Now we will make a new array by visiting the binary search tree.
+Now we will traverse the array, search value in the tree and basis the frequency we will repeat that element
+in the new array that number of times and delete the element from the BBST. Deleting is imp so next time
+when you visit this element in the array you do not repeat it as it has been grouped already
+Time complexity: O(n) + O(nlogn) + O(nlogn) = O(nlogn)
+Space complexity: O(n) (extra space for hashtable and output)
+
+METHOD3: 
+Applying the above method using a hashtable
+Time complexity: O(n)
+Space complexity: O(n) (for hashTable and output array)
+*/
+
+//METHOD2  to be done later
+//================================================================================================
+//METHOD3
+
+#include <stdio.h>
+#include <stdlib.h>
+
+struct hash{
+	int count;
+	struct node *head;
+};
+
+struct node{
+	int key;
+	struct node *next;
+}
+
+struct hash *hashTable = NULL;
+
+struct node *createNode(int key){
+	struct node *newnode = (struct node *)malloc(sizeof(struct node));
+	newnode->next = NULL;
+	newnode->key = key;
+	return newnode;	
+}
+
+void insertInHash(int key, int size){
+	int hashIndex = key%size;
+	struct node *newnode = createNode(key);
+	if(!hashTable[hashIndex].head){
+		hashTable[hashIndex].head = newnode;
+		return;
+	}
+	newnode->next = hashTable[hashIndex].head;
+	hashTable[hashIndex].head = newnode;
+	return;
+}
+
+void groupByElements(int arr[], int size){
+	hashTable = (struct hash *)calloc(size+1,sizeof(struct hash));
+	int hashSize = size+1;
+	for(int i=0;i<size;i++){
+		insertInHash(arr[i], hashSize);
+	}
+
+	//create a new empty array and search in hash and make elements as per that TODO
+
+}
+
+int main(){
+	int arr[] = {3,2,4,5,6,2,3,5,6,5};
+	int size = sizeof(arr)/sizeof(arr[0]);
+
+	groupByElements(arr,size);
+
+	return 0;
+}

nextquestions.md

@@ -21,4 +21,6 @@
 - XOR operation double linked list
 - question1 on hashing
 - binary search method to be done on hashing for question2
-- BBST for question2 hashing
+- BBST for question2 hashing
+- BBST for question3 hashing and first method to be done
+- how to accurately find the size of the hashTable