new questions added

Author: arorarahul

README.md

@@ -22,22 +22,6 @@ 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.
-- Linked list questions mostly can be solved by making connections using ptrs, reversing, having multiple ptrs, using different data structures etc.
-- You can traverse a double linked list both ways having a single pointer using XOR operation (question18)
-
 # General hash functions
 - take mod with number of elements present
 
@@ -53,28 +37,6 @@ TODO:
 ## Note:
 **Questions statements are included in the file itself**
 
-### COMING SOON
-
-- merge sort using dynamic programming and hashmaps
-- duplicate elimination from an array
-- union, intersection and difference of two arrays
-- bucket sort
-- radix sort for d digit numbers
-- find maximum sum subarray from an array
-- find triplet that sums to given value using binary search technique
-- make a circular linked list with a sentinel
-- double linked list insertion all points and deletion
-- hash table implementation used in linked list after hashing is done
-- program to add, mult, subtract two numbers stored in two different linked list and store the result in another linked list
-- storing addresses of a linked list in hash table
-- storing addresses of a linked list in stack and doing operations
-- hash table implementation of question12 to be done
-- use a stack for question13
-- heap to solve question15 (merge k sorted linked lists into one)
--  question 15 linked list
-- merge sort on linked list
-- XOR operation double linked list
-
 ### General Questions
 
 - [question1.c](/general/question1.c)
@@ -155,14 +117,22 @@ TODO:
 -[Insertion and deletion in memory efficient double linked lists](/linked-lists/question18.c)
 
 
+### Hashing
+
+- [General question to understand linear probing](/hashing/general-question1.c)
+- [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)
+
+
 ## Some important concepts to solve algos better
 
 - `XOR` means taking sum of the bits and dividing by two, remainder will be the answer
 = 'XOR' is commutative
 - 'XOR' of a number with itself is 0
 - 'XOR' of zero with a number is the number itself
-= '1s compliment is number obtained by reversing all the bits in the binary representation of a number. o to 1 and 1 to 0'
-
+- '1s compliment is number obtained by reversing all the bits in the binary representation of a number. o to 1 and 1 to 0'
+- Linear hashing is (h(k) + i)modm (where m is the size of the hash table, h(k) is the hash function that takes the key k and returns a value i is the parameter that is incremented to get different values)
 
 # Topic1: Introduction
 

hashing/general-program1.c

@@ -0,0 +1,132 @@
+/*
+C program to implement linear probing
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#define LIMIT 30
+enum record_status {EMPTY,DELETED,OCCUPIED};
+
+struct Employee{
+	int employee_id;
+	int employee_age;
+	char employee_name[30];
+};
+
+struct Record{
+	struct Employee info;
+	enum record_status status;
+};
+
+int hash_function(int key){
+	return key%LIMIT;
+}
+
+int search_records(int key, struct Record hash_table[]){
+	int count, temp, position;
+	temp = hash_function(key);
+	position = temp;
+	for(count = 1; count != LIMIT-1; count++){
+		if(hash_table[position].status == EMPTY){
+			return -1;
+		}
+		if(hash_table[position].info.employee_id == key){
+			return position;
+		}
+		position = (temp + count)%LIMIT;
+	}
+	return -1;
+}
+
+void delete_records(int key, struct Record hash_table[]){
+	int position = search_records(key, hash_table);
+	if(position == -1){
+		printf("Key not found\n");
+	}else{
+		hash_table[position].status = DELETED;
+	}
+};
+
+void display_records(struct Record hash_table[]){
+	int count;
+	printf("Hash table\n");
+	for(count = 0; count<LIMIT; count++){
+		printf("[%d]:\t", count);
+		if(hash_table[count].status == OCCUPIED){
+			printf("Occupied - ID: %d Name: %s Age: %d",hash_table[count].info.employee_id, hash_table[count].info.employee_name, hash_table[count].info.employee_age);
+		}else if(hash_table[count].status == DELETED){
+			printf("Position is deleted\n");
+		}else{
+			printf("EMPTY\n");
+		}
+
+	}
+}
+
+void insert_records(struct Employee emprec, struct Record hash_table[]){
+	int count, position, temp;
+	int key = emprec.employee_id;
+	temp = hash_function(key);
+	position = temp;
+	for(count = 1; count != LIMIT-1; count++){
+		if(hash_table[position].status == EMPTY || hash_table[position].status == DELETED){
+			hash_table[position].info = emprec;
+			hash_table[position].status = OCCUPIED;
+			printf("record inserted into hash table\n");
+			return;
+		}
+		if(hash_table[position].info.employee_id == key){
+			printf("Duplicate record cannot be inserted\n");
+			return;
+		}
+		position = (temp + count)%LIMIT;
+	}
+	printf("hash table limited exceeded\n");
+}
+
+int main(){
+	int count, key, option;
+	struct Record hash_table[LIMIT];
+	struct Employee emprec;
+	for(count = 0;count<LIMIT;count++){
+		hash_table[count].status = EMPTY;
+	}
+	while(1){
+		printf("1. Insert a Record\n");
+		printf("2. Delete a Record\n");
+		printf("3. Search a Record\n");
+		printf("4. Display all Record\n");
+		printf("5. Exit\n");
+		printf("Enter your option\n");
+		scanf("%d",&option);
+		switch(option){
+			case 1: printf("Enter employee ID\n");
+				scanf("%d",&emprec.employee_id);
+				printf("Enter employee name\n");
+				scanf("%s",emprec.employee_name);
+				printf("Enter employee age\n");
+				scanf("%d",&emprec.employee_age);
+				insert_records(emprec,hash_table);
+				break;
+
+			case 2: printf("Enter the key to delete\n");
+				scanf("%d", &key);
+				delete_records(key, hash_table);
+				break;
+
+			case 3: printf("Enter the key to search\n");
+				scanf("%d",&key);
+				count = search_records(key, hash_table);
+				if(count == -1){
+					printf("Record not found\n");
+				}else{
+					printf("Record found at Index %d ", count);
+				}
+				break;
+
+			case 4: display_records(hash_table);
+				break;
+			case 5: exit(1);
+		}
+	}
+	return 0;
+}

hashing/general-program2.c

@@ -0,0 +1,107 @@
+/*
+C program to implement hashing using chaining
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct hash *hashTable = NULL;
+int eleCount = 0;
+
+struct node{
+	int key,age;
+	char name[100];
+	struct node *next;
+};
+
+struct hash{
+	int count;
+	struct node *head;
+};
+
+void printHash(struct hash *hashTable, int n){
+	//array of structures since its contiguous.
+	//hashTable is a pointer to this contiguous memory so it can access it randomly.
+}
+
+struct node *createNode(int key, char *name, int age){
+	struct node *newnode;
+	newnode = (struct node *)malloc(sizeof(struct node));
+	newnode->key = key;
+	newnode->age = age;
+	strcpy(newnode->name, name);
+	newnode->next = NULL;
+	return newnode;
+}
+
+void insertToHash(int key, char *name, int age){
+	int hashIndex = key%eleCount;
+	struct node *newnode = createNode(key,name,age);
+	if(!hashTable[hashIndex].head){
+		hashTable[hashIndex].head = newnode;
+		hashTable[hashIndex].count = 1;
+		return;
+	}
+	newnode->next = (hashTable[hashIndex].head);
+	hashTable[hashIndex].head = newnode;
+	hashTable[hashIndex].count++;
+	return;
+}
+
+void searchInHash(int key){
+	int hashIndex = key%eleCount, flag=0;
+	if(!hashTable[hashIndex].head){
+		printf("element not found\n");
+		return;
+	}
+	struct node *t = hashTable[hashIndex].head;
+	while(t){
+		if(t->key==key){
+			flag =1;
+		  	printf("VoterID  : %d\n", t->key);
+            printf("Name     : %s\n", t->name);
+            printf("Age      : %d\n", t->age);
+            break;
+		}
+		t=t->next;
+	}
+	if (!flag)
+        printf("Search element unavailable in hash table\n");
+    return;
+}
+
+int main(){
+
+	int n,ch,key,age;
+	char name[100];		
+	printf("Enter the number of elements\n");
+	scanf("%d", &n);
+	eleCount = n;
+	/*create hash table with n number of buckets*/
+	hashTable = (struct hash *)calloc(n,sizeof(struct hash));
+	while(1){
+		printf("1. Insertion\n 2.Deletion\n 3.Searching \n 4. Display\n 5. Exit\n");
+		printf("Enter your choice\n");
+		scanf("%d",&ch);
+		switch(ch){
+			case 1: printf("Enter the key value:\n");
+				scanf("%d", &key);
+				getchar();
+				printf("Name:\n");
+				fgets(name, 100, stdin);
+				name[strlen(name) - 1] = '\0';
+				printf("AGE\n");
+				scanf("%d", &age);
+				insertToHash(key,name,age);
+				break;
+			case 3: 
+				printf("Enter the key to search\n");
+				scanf("%d",&key);
+				searchInHash(key);
+				break;
+		}
+	}
+	printHash(hashTable, n);
+	return 0;
+}

hashing/question1.c

@@ -0,0 +1,74 @@
+/*
+Check whether given array contains duplicates in k-distance or not
+
+METHOD1:
+For every element in the array you can traverse the next k elements and find if there are any duplicates
+Suppose array has N elements
+Time complexity: O(kN)
+Space complexity: O(1)
+
+METHOD2:
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+struct hash{
+	int count;
+	struct node *head;
+};
+
+struct node{
+	int value;
+	struct node *next;
+};
+
+int searchInHash(struct hash *hashTable, int key, int size){
+	int hashIndex = key%size;
+	if(!hashTable[hashIndex].head){
+		return 0;
+	}
+
+	struct node *t = hashTable[hashIndex].head;
+	while(t){
+		if(t->value==key){
+			return 1;
+		}
+		t=t->next;
+	}
+
+	return 0;
+}
+
+void insertNewElement(int key,struct node *hashTable, int oldKey, int size){
+	
+	int hashIndex = key%size;
+	//search and then delete
+	//and then insert new one
+
+}	
+
+int findDuplicates(int arr[],int size, int k){
+	struct hash *hashTable = (struct hash *)calloc(k,sizeof(struct hash));
+	for(int i=2; i<size;i++){
+		if(searchInHash(hashTable, arr[i],k)){
+			return 1;
+			break;
+		}
+		insertNewElement(arr[i], hashTable, arr[i-2],k);
+	}
+	return 0;
+}
+
+int main(){
+	int arr[] = {1,1,2,3,4,5};
+	int size= sizeof(arr)/sizeof(arr[0]);
+	int k=2;
+	if(!findDuplicates(arr, siz, k)){
+		printf("no duplicates were found\n");
+	}else{
+		printf("duplicates present\n");
+	}
+	return 0;
+}