Separate Chaining in C++

Author: Deepali-Srivastava

hashing/separate-chaining/Demo.cpp

@@ -0,0 +1,70 @@
+/*
+Copyright (C) Deepali Srivastava - All Rights Reserved
+This code is part of DSA course available on CourseGalaxy.com    
+*/
+
+#include<iostream>
+#include<string>
+#include"hashtable.h"
+
+using namespace std;
+
+int main()
+{
+	int id, choice, size;
+	string name;
+		
+	cout << "Enter initial size of table : ";
+    cin >> size;
+			
+	HashTable table(size);
+		
+	while(true)
+	{
+	   cout << "1.Insert a record \n";
+	   cout << "2.Search a record \n";
+	   cout << "3.Delete a record \n";
+	   cout << "4.Display table  \n";
+	   cout << "5.Exit \n";
+	   cout << "Enter your choice : ";
+       cin >> choice;
+
+	   if( choice == 5 )
+		   break;
+	   
+	   switch( choice )
+	   {
+			case 1 : 
+				cout << "Enter student id : ";
+                cin >> id;
+				cout << "Enter student name : ";
+                cin >> name;
+				table.insertRecord(StudentRecord(id,name));
+				break;
+			case 2 : 
+			    cout << "Enter a key to be searched : ";
+			    cin >> id; 
+			  				   
+			    if( table.searchRecord(id) )
+				    cout << "Key found \n";
+				else
+					cout << "Key not found \n";
+				break;
+			case 3: 
+			    cout << "Enter a key to be deleted : ";
+			    cin >> id;
+			    table.deleteRecord(id);
+			    break;
+			case 4:
+			    table.displayTable();
+			    break;
+			case 5:
+			    exit(1);
+				break;
+			default:
+				cout << "Wrong choice : \n";
+		  }
+	 }
+}
+    
+

hashing/separate-chaining/HashTable.cpp

@@ -0,0 +1,76 @@
+/*
+Copyright (C) Deepali Srivastava - All Rights Reserved
+This code is part of DSA course available on CourseGalaxy.com    
+*/
+
+#include<iostream>
+#include"hashtable.h"
+
+using namespace std;
+
+HashTable :: HashTable(int tableSize)
+{
+	m = tableSize;
+	n = 0;
+    arr = new SingleLinkedList[m];
+}
+
+HashTable :: ~HashTable()
+{
+	delete[] arr;
+}
+
+int HashTable :: hash(int key)
+{
+	return key % m;
+}
+
+bool HashTable :: searchRecord(int key)
+{
+	int h = hash(key);
+
+	Node *p = arr[h].search(key);
+
+	if ( p != NULL )
+	{
+		cout << p->info;
+		return true;
+	}
+	return false;
+}
+
+void HashTable :: insertRecord(StudentRecord newRecord)
+{
+	int key = newRecord.getstudentId();
+    int h = hash(key);
+	
+	if( searchRecord(key) )
+	{
+		cout << " Duplicate key\n";
+		return;
+	}
+	arr[h].insertAtBeginning(newRecord);
+    n++;
+}
+
+void HashTable :: deleteRecord(int key)
+{
+	int h = hash(key);
+	
+	arr[h].deleteNode(key);
+    n--;
+}
+
+void HashTable :: displayTable()
+{
+	for( int i=0; i<m; i++ )
+    {
+		cout << "[" << i << "]  -->  ";
+
+		if( ! arr[i].isEmpty() )
+			arr[i].displayList() ;
+        else
+           cout << "___" << "\n";
+     }
+}
+

hashing/separate-chaining/SingleLinkedList.cpp

@@ -0,0 +1,94 @@
+/*
+Copyright (C) Deepali Srivastava - All Rights Reserved
+This code is part of DSA course available on CourseGalaxy.com    
+*/
+
+#include<iostream>
+#include "single.h"
+
+using namespace std;
+
+SingleLinkedList::SingleLinkedList()
+{
+	start = NULL;
+}
+
+SingleLinkedList::~SingleLinkedList()
+{
+	Node *p;
+	while( start != NULL )
+	{
+		p = start->link;
+		delete start;
+		start = p;
+	}
+}
+
+inline bool SingleLinkedList::isEmpty() const
+{
+	return start == NULL;
+}
+
+void SingleLinkedList::displayList() const
+{
+	if( isEmpty() )
+		return;
+		
+	Node *p = start;
+	while( p != NULL )
+	{
+		cout << p->info << "  ";
+		p = p->link;
+	}
+	cout << "\n";
+}
+
+Node* SingleLinkedList::search(int x) const
+{
+	Node *p = start;
+	
+	while( p != NULL )
+	{
+		if( p->info.getstudentId() == x )
+			break;
+		p = p->link;
+	}
+	return p;
+}
+
+void SingleLinkedList::insertAtBeginning(StudentRecord data)
+{
+	Node *temp = new Node(data);
+	temp->link = start;
+	start = temp;
+} 
+
+void SingleLinkedList :: deleteNode(int x)
+{
+	if(start == NULL)
+	{
+		cout << "Value " << x << " not present\n";
+		return;
+	}
+		
+	/*Deletion of first node*/
+	if( start->info.getstudentId() == x )
+	{
+		start = start->link;
+		return;
+	}
+		
+	/*Deletion in between or at the end*/
+	Node *p = start;
+	while( p->link != NULL )
+	{
+		if( p->link->info.getstudentId() == x )   
+			break;	
+		p = p->link;
+	}
+		
+	if( p->link == NULL )
+		cout << "Value " << x << " not present\n";
+	else
+	    p->link = p->link->link;
+}

hashing/separate-chaining/StudentRecord.cpp

@@ -0,0 +1,35 @@
+/*
+Copyright (C) Deepali Srivastava - All Rights Reserved
+This code is part of DSA course available on CourseGalaxy.com    
+*/
+
+#include<iostream>
+#include<string>
+#include"student.h"
+
+using namespace std;
+
+StudentRecord :: StudentRecord()
+{ }
+
+StudentRecord :: StudentRecord(int i, string name)
+{
+	studentId = i;
+    studentName = name;
+}
+
+int StudentRecord :: getstudentId()
+{
+	return studentId;
+}
+
+void StudentRecord :: setstudentId(int i)
+{
+	studentId = i;
+}
+        
+ostream& operator<<(ostream& out, const StudentRecord& st)
+{
+	out << " " << st.studentId << " " << st.studentName <<"  ";
+	return out;
+}

hashing/separate-chaining/hashtable.h

@@ -0,0 +1,24 @@
+/*
+Copyright (C) Deepali Srivastava - All Rights Reserved
+This code is part of DSA course available on CourseGalaxy.com    
+*/
+
+#include<iostream>
+#include"single.h"
+using namespace std;
+
+class HashTable
+{
+	 SingleLinkedList *arr;
+     int m;  //size of the array
+     int n;  //number of records
+	 int hash(int key);
+  
+  public:
+	 ~HashTable();
+	 HashTable(int tableSize=11);
+     void insertRecord(StudentRecord newRecord);
+	 bool searchRecord(int key);
+	 void deleteRecord(int key);
+     void displayTable();
+};

hashing/separate-chaining/node.h

@@ -0,0 +1,19 @@
+/*
+Copyright (C) Deepali Srivastava - All Rights Reserved
+This code is part of DSA course available on CourseGalaxy.com    
+*/
+
+#include "student.h"
+
+class Node
+{
+	public:
+		StudentRecord info;
+		Node *link;
+
+		Node(StudentRecord i) 
+		{
+			info = i;
+			link = NULL;
+		}
+};

hashing/separate-chaining/single.h

@@ -0,0 +1,22 @@
+/*
+Copyright (C) Deepali Srivastava - All Rights Reserved
+This code is part of DSA course available on CourseGalaxy.com    
+*/
+
+
+#include "node.h"
+
+class SingleLinkedList
+{
+	    Node *start;
+	
+	public:
+		SingleLinkedList();
+		~SingleLinkedList();
+		bool isEmpty() const;
+		void displayList() const;
+		Node* search(int x) const;
+		void insertAtBeginning(StudentRecord data);
+		void deleteNode(int data);
+};
+

hashing/separate-chaining/student.h

@@ -0,0 +1,20 @@
+/*
+Copyright (C) Deepali Srivastava - All Rights Reserved
+This code is part of DSA course available on CourseGalaxy.com    
+*/
+
+#include<iostream>
+using namespace std;
+
+class StudentRecord
+{
+	  int studentId;
+      string studentName;
+	
+   public:
+	  StudentRecord();
+	  StudentRecord(int i, string name);
+      int getstudentId();
+      void setstudentId(int i);
+      friend ostream& operator<<(ostream& out, const StudentRecord& st);
+};