Add files via upload

Author: skjha1

Queue/01 Queue using array enqueue & dequeue .cpp

@@ -0,0 +1,59 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+struct Queue
+{
+	int size; // size of queue
+	int front; // front of queue // del is done from front
+	int rear; // last of queue // indertion is donr from rear
+	int* Q; // dynamically creatng Array 
+};
+
+void Create(struct Queue* q, int size)
+{
+	q->size = size;
+	q->front = q->rear = -1; // initially queue is empty
+	q->Q = (int*)malloc(q->size * sizeof(int)); // everytime taking creating in heap memory
+
+}
+void enqueue(struct Queue* q, int x)
+{
+	if (q->rear == q->size - 1)
+		printf("queue is full");
+	else
+	{
+		q->rear++;
+		q->Q[q->rear] = x;
+	}
+}
+int dequeue(struct Queue* q)
+{
+	int x = -1;
+	if (q->front == q->rear)
+		printf("Queue is empty");
+	else
+	{
+		q->front++;
+		x=q->Q[q->front];
+	}
+	return x;
+}
+void Display(struct Queue q)
+{
+	int i;
+	for (i = q.front + 1; i <= q.rear; i++)
+		printf("%d ",q.Q[i]);
+	printf("\n");
+}
+int main()
+{
+	struct Queue q;
+	Create(&q, 5);
+	enqueue(&q, 10);
+	enqueue(&q, 15);
+	enqueue(&q, 20);
+	enqueue(&q, 30);
+	Display(q);
+	printf("%d ",dequeue(&q));
+	return 0;
+}

Queue/02 C++ Queue using Array.cpp

@@ -0,0 +1,76 @@
+#include<iostream>
+#include<stdlib.h>
+using namespace std;
+
+class Queue
+{
+private:
+	int front;
+	int rear;
+	int size;
+	int* Q;
+public:
+	Queue()									//Non-parameterized constructor //front and rear are assigned as -1 //indicates Queue is empty
+	{
+		front = rear = -1;
+		size = 10;							//Default size of the Queue will be 10
+		Q = new int[size];					//Memory is allocated for the Queue in the HEAP
+	}
+	Queue(int size)							//Parameterized constructor with size as the parameter
+	{
+		front = rear = -1;
+		this->size = size;
+		Q = new int[this->size];
+	}
+	void enqueue(int x);
+	int dequeue();
+	void display();
+};
+
+void Queue::enqueue(int x)
+{
+	if (rear == size - 1)
+		cout << "Queue is Full" << endl;
+	else
+	{
+		rear++;
+		Q[rear] = x;
+	}
+}
+
+int Queue::dequeue()
+{
+	int x = -1;
+	if (front == rear)
+		cout << "Queue is Empty" << endl;
+	else
+	{
+		front++;
+		x = Q[front];
+	}
+	return x;
+}
+
+void Queue::display()
+{
+	int i;
+	for (i = front + 1; i <= rear; i++)
+		cout << Q[i] << " ";
+	cout << endl;
+}
+
+int main()
+{
+	Queue q(5);
+
+	q.enqueue(10);
+	q.enqueue(20);
+	q.enqueue(30);
+	q.enqueue(40);
+
+	q.display();
+	q.dequeue();
+	q.display();
+
+	return 0;
+}

Queue/03 Circular Queue using Array .cpp

@@ -0,0 +1,72 @@
+#include<stdio.h>
+#include<stdlib.h>
+
+struct Queue
+{
+	int size;						//size for the fixed size array which is going to be the Queue
+	int front;						//index pointer for deletion from Queue
+	int rear;						//index pointer for insertion in Queue
+	int* Q;							//pointer to create the Queue dynamically in the HEAP
+};
+
+void create(struct Queue* q, int size)
+{
+	q->size = size;											//size of array assigned
+	q->front = q->rear = -1;								    //front and rear are initialised with 0 //it is done for Circular Queue in order to use Mod operations to achieve Circular Mechanism
+	q->Q = (int*)malloc(q->size * sizeof(int));			//Array is created dynamically in HEAP of size equal to q->size
+}
+
+void enqueue(struct Queue* q, int x)						//Function to insert element in the Queue
+{
+	if ((q->rear + 1) % q->size == q->front)								//Condition to check Queue is full or not //This is the condition to achieve the circular mechanism for adopting Circular Queue
+		printf("Queue is Full\n");
+	else
+	{
+		q->rear = (q->rear + 1) % q->size;						//rear is assigned as (rear+1)%size //it is a mechanism to obtain circular and repeating values in the array //for circular queue
+		q->Q[q->rear] = x;									//value is inserted in Q[rear]
+	}
+}
+
+int dequeue(struct Queue* q)								//Function to delete element from the queue
+{
+	int x = -1;												//x will store the deleted value //initialised with -1 //if queue is empty the function will return -1
+
+	if (q->front == q->rear)									//Condtion to check if Queue is empty or not //Queue is empty when front equals rear
+		printf("Queue is Empty\n");
+	else
+	{
+		q->front = (q->front + 1) % q->size;					//front is assigned as (front+1)%size //it is a mechanism to obtain circular and repeating values in the array //for circular queue
+		x = q->Q[q->front];									//x is assigned with the value of Q[front]
+	}
+	return x;												//return x
+}
+
+void display(struct Queue q)
+{
+	int i = (q.front + 1) % q.size;								//Since, front points the index just before the first element, i should start from front+1 //rear points exactly to the previous element of front in a Circular Queue																
+
+	do
+	{
+		printf("%d ", q.Q[i]);
+		i = (i + 1) % q.size;										//i is incremented as (i+1)%size //algorithm to obtain circular and repeating values
+	} while (i != (q.rear + 1) % q.size);								//Here, terminating condition of the do while loop is when i equals to (q.rear+1)%q.size //Since, it is a Circular Queue the terminating condition must follow the same mechanism of circularity
+
+	printf("\n");
+}
+
+int main()
+{
+	struct Queue q;
+	create(&q, 5);
+
+	enqueue(&q, 10);
+	enqueue(&q, 20);
+	enqueue(&q, 30);
+	enqueue(&q, 40);
+
+	//dequeue(&q);
+
+	display(q);
+
+	return 0;
+}

Queue/04 C++ Circular Queue.cpp

@@ -0,0 +1,107 @@
+#include <iostream>
+
+using namespace std;
+
+class CircularQueue {
+private:
+    int size;
+    int front;
+    int rear;
+    int* Q;
+public:
+    CircularQueue(int size);
+    ~CircularQueue();
+    bool isFull();
+    bool isEmpty();
+    void enqueue(int x);
+    int dequeue();
+    void display();
+};
+
+CircularQueue::CircularQueue(int size) {
+    this->size = size;
+    front = 0;
+    rear = 0;
+    Q = new int[size];
+}
+
+CircularQueue::~CircularQueue() {
+    delete[] Q;
+}
+
+bool CircularQueue::isEmpty() {
+    if (front == rear) {
+        return true;
+    }
+    return false;
+}
+
+bool CircularQueue::isFull() {
+    if ((rear + 1) % size == front) {
+        return true;
+    }
+    return false;
+}
+
+void CircularQueue::enqueue(int x) {
+    if (isFull()) {
+        cout << "Queue Overflow" << endl;
+    }
+    else {
+        rear = (rear + 1) % size;
+        Q[rear] = x;
+    }
+}
+
+int CircularQueue::dequeue() {
+    int x = -1;
+    if (isEmpty()) {
+        cout << "Queue Underflow" << endl;
+    }
+    else {
+        front = (front + 1) % size;
+        x = Q[front];
+    }
+    return x;
+}
+
+void CircularQueue::display() {
+    int i = front + 1;
+    do {
+        cout << Q[i] << flush;
+        if (i < rear) {
+            cout << " <- " << flush;
+        }
+        i = (i + 1) % size;
+    } while (i != (rear + 1) % size);
+}
+
+
+int main() {
+
+    int A[] = { 1, 3, 5, 7, 9 };
+
+    CircularQueue cq(sizeof(A) / sizeof(A[0]) + 1);
+
+    // Enqueue
+    for (int i = 0; i < sizeof(A) / sizeof(A[0]); i++) {
+        cq.enqueue(A[i]);
+    }
+
+    // Display
+    cq.display();
+    cout << endl;
+
+    // Overflow
+    cq.enqueue(10);
+
+    // Dequeue
+    for (int i = 0; i < sizeof(A) / sizeof(A[0]); i++) {
+        cq.dequeue();
+    }
+
+    // Underflow
+    cq.dequeue();
+
+    return 0;
+}