main.cpp

#include <iostream>
#include "LinkedList.h"
#include "Stack.h"
#include "Queue.h"
using namespace std;

int main() {

    // ── Linked List ──────────────────────────────────────────
    cout << "=== Linked List ===\n";

    LinkedList list;
    list.insertAtHead(30);
    list.insertAtHead(20);
    list.insertAtHead(10);   // insert at head 3 times
    list.insertAtEnd(40);
    list.insertAtEnd(50);    // insert at end 2 times
    list.display();          // 10 -> 20 -> 30 -> 40 -> 50 -> NULL

    // delete from middle
    cout << "Delete middle (30):\n";
    list.deletedata(30);
    list.display();          // 10 -> 20 -> 40 -> 50 -> NULL

    // delete from head
    cout << "Delete head (10):\n";
    list.deletedata(10);
    list.display();          // 20 -> 40 -> 50 -> NULL

    // delete from tail
    cout << "Delete tail (50):\n";
    list.deletedata(50);
    list.display();          // 20 -> 40 -> NULL

    // delete value not found
    cout << "Delete not found (99):\n";
    list.deletedata(99);     // error: data not found

    // ── Stack Array ──────────────────────────────────────────
    cout << "\n=== Stack (Array) ===\n";

    StackArray sa(3);
    sa.pop();                // underflow (empty)
    sa.push(1);
    sa.push(2);
    sa.push(3);
    sa.push(4);              // overflow (full)
    cout << "peek: " << sa.peek() << "\n";   // 3
    cout << "pop:  " << sa.pop() << "\n";   // 3
    cout << "pop:  " << sa.pop() << "\n";   // 2
    cout << "pop:  " << sa.pop() << "\n";   // 1
    sa.pop();                // underflow (empty again)

    // ── Stack Linked List ─────────────────────────────────────
    cout << "\n=== Stack (Linked List) ===\n";

    StackLL sl;
    sl.pop();                // underflow (empty)
    sl.push(100);
    sl.push(200);
    sl.push(300);
    cout << "peek: " << sl.peek() << "\n";   // 300
    cout << "pop:  " << sl.pop() << "\n";   // 300
    cout << "pop:  " << sl.pop() << "\n";   // 200
    cout << "pop:  " << sl.pop() << "\n";   // 100
    sl.pop();                // underflow (empty again)
    // Note: StackLL has NO overflow — linked list grows dynamically

    // ── Queue Circular Array ──────────────────────────────────
    cout << "\n=== Queue (Circular Array) — capacity 3 ===\n";

    QueueArray qa(3);

    // underflow on empty
    qa.dequeue();            // error: queue empty

    // fill queue: slots [0]=1, [1]=2, [2]=3
    qa.enqueue(1);
    qa.enqueue(2);
    qa.enqueue(3);
    qa.enqueue(4);           // overflow (full)

    // dequeue 2 from front → front moves forward (wrapping test setup)
    cout << "dequeue: " << qa.dequeue() << "\n";  // 1  (front was 0, now 1)
    cout << "dequeue: " << qa.dequeue() << "\n";  // 2  (front was 1, now 2)

    // enqueue 2 more → rear wraps around from index 2 back to index 0 and 1
    qa.enqueue(4);   // rear wraps to index 0  ← CIRCULAR WRAP (rear)
    qa.enqueue(5);   // rear wraps to index 1  ← CIRCULAR WRAP (rear)
    qa.enqueue(6);   // overflow (full again)

    // now dequeue all — proves front also wraps
    cout << "dequeue: " << qa.dequeue() << "\n";  // 3  (front at index 2)
    cout << "dequeue: " << qa.dequeue() << "\n";  // 4  (front wraps to index 0) ← CIRCULAR WRAP (front)
    cout << "dequeue: " << qa.dequeue() << "\n";  // 5  (front at index 1)
    qa.dequeue();    // underflow (empty again)

    // ── Queue Linked List ─────────────────────────────────────
    cout << "\n=== Queue (Linked List) ===\n";

    QueueLinkedList ql;
    ql.dequeue();            // underflow (empty)
    ql.enqueue(10);
    ql.enqueue(20);
    ql.enqueue(30);
    cout << "dequeue: " << ql.dequeue() << "\n";  // 10  FIFO
    cout << "dequeue: " << ql.dequeue() << "\n";  // 20
    cout << "dequeue: " << ql.dequeue() << "\n";  // 30
    ql.dequeue();            // underflow (empty again)

    return 0;
}