Initial Commit

Author: praharshjain

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Praharsh Jain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,14 @@
+Data Structures
+==========
+
+This repository contains my implementation of common data structures in C++.
+
+Will be updated periodically. You are free to use these codes wherever you want without permission. This comes without any warranties though!
+
+Pull requests
+----------------
+If you spot any errors in the implementation(s), please let me know by submitting a relevant pull request.
+
+License
+----------------
+MIT

linked_list.cpp

@@ -0,0 +1,218 @@
+#include <iostream>
+using namespace std;
+//generic implementation of Singly Linked List using templates
+template <class T>
+struct node
+{
+    T data;
+    struct node *next;
+};
+template <class T>
+class LinkedList
+{
+  private:
+    int size;
+    struct node<T> *start;
+
+  public:
+    LinkedList()
+    {
+        size = 0;
+        start = NULL;
+    }
+    struct node<T> *create_node(T value)
+    {
+        struct node<T> *temp = new (struct node<T>);
+        temp->next = NULL;
+        temp->data = value;
+        return temp;
+    }
+    // functions to insert values
+    void
+    insert_begin(T value)
+    {
+        struct node<T> *temp = create_node(value);
+        if (start != NULL)
+        {
+            temp->next = start;
+        }
+        start = temp;
+        size++;
+    }
+    void insert(T value)
+    {
+        struct node<T> *temp = start;
+        if (temp != NULL)
+        {
+            while (temp->next != NULL)
+                temp = temp->next;
+            temp->next = create_node(value);
+            size++;
+        }
+        else
+        {
+            insert_begin(value);
+        }
+    }
+    void insert_pos(T value, int pos)
+    {
+        if (pos == 1)
+        {
+            insert_begin(value);
+        }
+        else if (pos == size + 1)
+        {
+            insert(value);
+        }
+        else if (pos <= size)
+        {
+            struct node<T> *curr = create_node(value), *temp = start;
+            for (int i = 1; i < pos - 1; i++)
+            {
+                temp = temp->next;
+            }
+            curr->next = temp->next;
+            temp->next = curr;
+            size++;
+        }
+        else
+        {
+            cout << "\nInsertion at position " << pos << " is not possible\n";
+        }
+    }
+    // search the list
+    int search(T value)
+    {
+        struct node<T> *temp = start;
+        for (int pos = 1; temp != NULL; pos++)
+        {
+            if (temp->data == value)
+            {
+                return pos;
+            }
+            temp = temp->next;
+        }
+        return -1;
+    }
+    // delete from list
+    void remove_pos(int pos)
+    {
+        if (pos > 1 && pos <= size)
+        {
+            struct node<T> *curr = NULL, *temp = start;
+            for (int i = 1; i < pos - 1; i++)
+            {
+                temp = temp->next;
+            }
+            curr = temp->next;
+            temp->next = curr->next;
+            delete curr;
+            size--;
+        }
+        else if (pos == 1 && size >= pos)
+        {
+            struct node<T> *temp = start->next;
+            delete start;
+            start = temp;
+            size--;
+        }
+        else
+        {
+            cout << "\nNo such entry in list\n";
+        }
+    }
+    void remove(T value)
+    {
+        remove_pos(search(value));
+    }
+    void reverse()
+    {
+        if (start != NULL && start->next != NULL)
+        {
+            struct node<T> *p1 = NULL, *curr = start, *p2 = start->next;
+            while (p2 != NULL)
+            {
+                curr->next = p1;
+                p1 = curr;
+                curr = p2;
+                p2 = p2->next;
+            }
+            curr->next=p1;
+            start = curr;
+        }
+    }
+    void sort()
+    {
+        T x;
+        struct node<T>* p1=NULL,*p2=NULL,*last=NULL;
+        if(start!=NULL && start->next!=NULL)
+        {
+            for(p1=start;p1!=NULL;p1=p1->next)
+            {
+                for(p2=start;p2->next!=last;p2=p2->next)
+                {
+                    if(p2->data > p1->data)
+                    {
+                        x=p1->data;
+                        p1->data=p2->data;
+                        p2->data=x;
+                    }
+                    if(p2->next==last)
+                    {   last=p2;
+                    }
+                }
+            }
+
+        }
+    }
+    // getters
+    int getSize()
+    {
+        return size;
+    }
+    struct node<T> *getStart()
+    {
+        return start;
+    }
+};
+
+int main()
+{
+    LinkedList<int> ll;
+    ll.insert_begin(5);
+    ll.insert_begin(6);
+    ll.insert(78);
+    ll.insert_pos(54, 4);
+    ll.insert_pos(8, 4);
+    ll.insert_pos(7, 1);
+    ll.insert_pos(8888, 12);
+    //7 6 5 78 8 54
+    struct node<int> *temp = ll.getStart();
+    for (; temp != NULL; temp = temp->next)
+        cout << temp->data << "\n";
+    cout << "\nsize=" << ll.getSize() << "\n";
+    cout << "\n78 found at position: " << ll.search(78) << "\n";
+    ll.remove(78);
+    ll.remove_pos(5);
+    ll.remove_pos(1);
+    ll.remove_pos(10);
+    //6 5 8
+    temp = ll.getStart();
+    for (; temp != NULL; temp = temp->next)
+        cout << temp->data << "\n";
+    cout << "\nsize=" << ll.getSize() << "\n";
+    ll.reverse();
+    temp = ll.getStart();
+    for (; temp != NULL; temp = temp->next)
+        cout << temp->data << "\n";
+    cout << "\nsize=" << ll.getSize() << "\n";
+    ll.insert(-1);
+    ll.insert(34);
+    ll.sort();
+    //-1 5 6 8 34
+    temp = ll.getStart();
+    for (; temp != NULL; temp = temp->next)
+        cout << temp->data << "\n";
+    cout << "\nsize=" << ll.getSize() << "\n";
+    return 0;
+}

queue.cpp

@@ -0,0 +1,76 @@
+#include <iostream>
+#include <cstdlib>
+using namespace std;
+const int MAX_SIZE = 100;
+//generic implementation of standard Queue data structure using templates
+template <class T>
+class Queue
+{
+  private:
+    T data[MAX_SIZE];
+    int front;
+    int rear;
+
+  public:
+    Queue()
+    {
+        front = 0;
+        rear = 0;
+    }
+
+    void Enqueue(T element)
+    {
+        if (Size() == MAX_SIZE - 1)
+            cout << "Queue full\n";
+        data[rear] = element;
+        rear = ++rear % MAX_SIZE;
+    }
+
+    int Dequeue()
+    {
+        if (isEmpty())
+            cout << "Queue empty\n";
+        T ret = data[front];
+        front = ++front % MAX_SIZE;
+        return ret;
+    }
+
+    int Front()
+    {
+        if (isEmpty())
+            cout << "Queue empty\n";
+        return data[front];
+    }
+
+    int Size()
+    {
+        return abs(rear - front);
+    }
+
+    bool isEmpty()
+    {
+        return (front == rear) ? true : false;
+    }
+};
+
+int main()
+{
+    Queue<int> q;
+    if (q.isEmpty())
+    {
+        cout << "Queue is empty" << endl;
+    }
+    // Enqueue elements
+    q.Enqueue(100);
+    q.Enqueue(200);
+    q.Enqueue(300);
+    // Size of queue
+    cout << "Size of queue = " << q.Size() << endl;
+    // Front element
+    cout << q.Front() << endl;
+    // Dequeue elements
+    cout << q.Dequeue() << endl;
+    cout << q.Dequeue() << endl;
+    cout << q.Dequeue() << endl;
+    return 0;
+}