Untitled

mail@pastecode.io avatar
unknown
plain_text
7 months ago
32 kB
91
Indexable
Never
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
struct stackArray
{
    int top;
    int arr[MAX];
};
struct queue
{
    int front;
    int rear;
    int arr[MAX];
};
struct linkedList
{
    int data;
    struct linkedList *next;
};

struct Node
{
    int data;
    struct Node *next;
};

struct Stack
{
    struct Node *top;
};

struct QueueNode
{
    int Data;
    struct QueueNode *next;
};

struct Queue
{
    struct QueueNode *Front;
    struct QueueNode *Rear;
};

void stack_as_a_linked_list();
void displaylist(struct linkedList *h);

struct stacklist *popsl(struct stacklist *s);
void linear_search();
void binary_search();
void bubble_sort();
void selection_sort();
void merge_sort(int[], int, int);
void input();
void display(int[], int);
void input_q();
void display_q(int[], int);
void merge(int[], int, int, int);
int split(int[], int, int);
void quick_sort(int[], int, int);
void insertion_sort();
void radix_sort();
void insertion();
void deletion();
void stack_using_array();
void single_queue();
void double_queue();
void circular_queue();
struct linkedList *insertion_at_begin(struct linkedList *, int);
void insertion_at_end();
void insertion_at_position();
void deletion_at_begin();
void deletion_at_end();
void deletion_at_position();
void reversing();
int isEmpty(struct stackArray *h);
int isFull(struct stackArray *head);
void dequeue(struct queue *q);
void displayq(struct queue *h);
void single_queue(struct queue *q);
void pop(struct stackArray *hm);
void displaystack(struct stackArray *he);

void stack_using_array(struct stackArray *h);

int isFullq(struct queue *head);
int isEmptyq(struct queue *head);
void traversal(struct linkedList *m);
void displayList(struct linkedList *head);
struct linkedList *deleteFirstNode(struct linkedList *head);
struct linkedList *deleteLastNode(struct linkedList *head);
struct linkedList *deleteNodeByValue(struct linkedList *head, int value);
struct linkedList *inputList();
void displayStack(struct Stack *stack);
int popsll(struct Stack *stack);
void pushsll(struct Stack *stack, int value);
struct Stack *createStack();
struct Queue *createQueue();
void Enqueue(struct Queue *queue, int value);
int Dequeue(struct Queue *queue);
void DisplayQueue(struct Queue *queue);
void queue_using_linked_list();

void linear_search()
{
    int size;
    printf("Enter the Size\n");
    scanf("%d", &size);
    int arr[size];
    int i;
    printf("Enter Elements\n");
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }
    printf("Enter Element to be Searched\n");
    int k, flag = 0;
    scanf("%d", &k);
    for (i = 0; i < size; i++)
    {
        if (arr[i] == k)
        {
            flag = 1;
            break;
        }
    }
    if (flag == 1)
    {
        printf("Element Found At index %d\n", i);
    }
    else
    {
        printf("Element Found\n");
    }
}
void binary_search()
{
    int size;
    printf("Enter the Size\n");
    scanf("%d", &size);
    int arr[size];
    printf("Enter Elements\n");
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }
    printf("Enter Element to be Searched\n");
    int k, flag = 0;
    int left = 0;
    int right = size - 1;
    while (left <= right)
    {
        int mid = (left + right) / 2;
        if (arr[mid] == k)
        {
            printf("Element Found\n");
            break;
        }
        else if (arr[mid] < k)
        {
            left = mid + 1;
        }
        else
        {
            right = mid - 1;
        }
    }
    printf("Element Not Found\n");
}
void bubble_sort()
{
    int size;
    printf("Enter the Size\n");
    scanf("%d", &size);
    int arr[size];
    printf("Enter Elements\n");
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < size - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    printf("After Sorting\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d\t", arr[i]);
    }
    printf("\n");
}
void selection_sort()
{
    int size;
    printf("Enter the Size\n");
    scanf("%d", &size);
    int arr[size];
    printf("Enter Elements\n");
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }
    for (int i = 0; i < size; i++)
    {
        int min = i;
        for (int j = i + 1; j < size; j++)
        {
            if (arr[min] > arr[j])
            {
                min = j;
            }
        }
        int temp = arr[min];
        arr[min] = arr[i];
        arr[i] = temp;
    }
    printf("After Sorting\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d\t", arr[i]);
    }
    printf("\n");
}
void input()
{
    int size;
    printf("Enter the Size\n");
    scanf("%d", &size);
    int arr[size];
    printf("Enter Elements\n");
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }
    merge_sort(arr, 0, size);
    display(arr, size);
}
void merge_sort(int arr[], int left, int right)
{
    if (left < right)
    {
        int mid = (left + right) / 2;
        merge_sort(arr, left, mid);
        merge_sort(arr, mid + 1, right);
        merge(arr, left, mid, right);
    }
}
void merge(int arr[], int left, int mid, int right)
{
    int i, j, k;
    int n1 = mid - left + 1;
    int n2 = right - mid;

    // Create temporary arrays
    int L[n1], R[n2];

    // Copy data to temporary arrays L[] and R[]
    for (i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];

    // Merge the temporary arrays back into arr[left..right]
    i = 0;    // Initial index of first subarray
    j = 0;    // Initial index of second subarray
    k = left; // Initial index of merged subarray
    while (i < n1 && j < n2)
    {
        if (L[i] <= R[j])
        {
            arr[k] = L[i];
            i++;
        }
        else
        {
            arr[k] = R[j];
            j++;
        }
        k++;
    }

    // Copy the remaining elements of L[], if there are any
    while (i < n1)
    {
        arr[k] = L[i];
        i++;
        k++;
    }

    // Copy the remaining elements of R[], if there are any
    while (j < n2)
    {
        arr[k] = R[j];
        j++;
        k++;
    }
}
void display(int arr[], int size)
{
    printf("After Sorting\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d\t", arr[i]);
    }
    printf("\n");
}
void insertion_sort()
{
    int size;
    printf("Enter the Size\n");
    scanf("%d", &size);
    int arr[size];
    printf("Enter Elements\n");
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }

    for (int i = 1; i < size; i++)
    {
        int j = i - 1;
        int key = arr[i];
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
    printf("After Sorting\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d\t", arr[i]);
    }
    printf("\n");
}
void input_q()
{
    int size;
    printf("Enter the Size\n");
    scanf("%d", &size);
    int arr[size];
    printf("Enter Elements\n");
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }
    quick_sort(arr, 0, size - 1);
    display_q(arr, size);
}

int split(int arr[], int left, int right)
{
    int pivotgreater = right;
    int pivotless = left + 1;
    int pivot = arr[left];
    while (pivotgreater >= pivotless)
    {
        while (arr[pivotgreater] > pivot)
        {
            pivotgreater--;
        }
        while (arr[pivotless] < pivot)
        {
            pivotless++;
        }
        if (pivotgreater > pivotless)
        {
            int temp = arr[pivotgreater];
            arr[pivotgreater] = arr[pivotless];
            arr[pivotless] = temp;
        }
    }
    int temp = arr[left];
    arr[left] = arr[pivotgreater];
    arr[pivotgreater] = temp;
    return pivotgreater;
}
void quick_sort(int arr[], int left, int right)
{
    if (left < right)
    {
        int i = split(arr, left, right);
        quick_sort(arr, left, i - 1);
        quick_sort(arr, i + 1, right);
    }
}

void display_q(int arr[], int size)
{
    printf("After Sorting\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d\t", arr[i]);
    }
    printf("\n");
}

void insertion()
{
    int size;
    printf("Enter the Size\n");
    scanf("%d", &size);
    int arr[size];
    printf("Enter Elements\n");
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }
    printf("Enter Position\n");
    int pos;
    scanf("%d", &pos);
    printf("Enter the Element\n");
    int ele;
    scanf("%d", &ele);
    for (int i = size - 1; i >= pos; i--)
    {
        arr[i + 1] = arr[i];
    }
    arr[pos] = ele;
    printf("After Sorting\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d\t", arr[i]);
    }
    printf("\n");
}
void deletion()
{
    int size;
    printf("Enter the Size\n");
    scanf("%d", &size);
    int arr[size];
    printf("Enter Elements\n");
    for (int i = 0; i < size; i++)
    {
        scanf("%d", &arr[i]);
    }
    printf("Enter the Element to be deleted\n");
    int del;
    int index;
    scanf("%d", &del);
    for (int i = 0; i < size; i++)
    {
        if (arr[i] == del)
        {
            index = i;
        }
    }
    for (int i = index; i < size; i++)
    {
        arr[i] = arr[i + 1];
    }
    size--;
    printf("Updated Array\n");
    for (int i = 0; i < size; i++)
    {
        printf("%d\t", arr[i]);
    }
}
void push(struct stackArray *hm, int value)
{
    if (isFull(hm))
    {
        printf("Stack Overflow\n");
        return;
    }
    hm->top++;
    hm->arr[hm->top] = value;
    while (1)
    {
        printf("Do u Want To add more Elements?\n");
        int chs;
        printf("1.Enter Elements\n");
        printf("2.Pop\n");
        printf("3.Display\n");
        printf("4.Quit\n");
        scanf("%d", &chs);
        if (chs == 1)
        {
            int es;
            scanf("%d", &es);
            hm->top++;
            hm->arr[hm->top] = es;
        }
        else if (chs == 2)
        {
            pop(hm);
        }
        else if (chs == 3)
        {
            displaystack(hm);
        }
        else
        {
            break;
        }
    }
}

void pop(struct stackArray *hm)
{
    if (isEmpty(hm))
    {
        printf("Stack Underflow\n");
        return;
    }
    int data = hm->arr[hm->top];
    hm->top--;
    printf("Popped element: %d\n", data);
}

void displaystack(struct stackArray *he)
{
    if (isEmpty(he))
    {
        printf("Stack Underflow\n");
        return;
    }
    // printf("");
    printf("Stack Elements\n\n");
    for (int i = he->top; i >= 0; i--)
    {
        printf("%d\t", he->arr[i]);
    }
    printf("\n");
    printf("\n");
}

int isFull(struct stackArray *head)
{
    if (head->top == MAX - 1)
    {
        return 1;
    }
    return 0;
}

int isEmpty(struct stackArray *head)
{
    if (head->top == -1)
    {
        return 1;
    }
    return 0;
}

void stack_using_array(struct stackArray *h)
{
    printf("1.Push\n");
    printf("2.Pop\n");
    printf("3.Display\n");
    int chs;
    printf("Enter Choice\n");
    scanf("%d", &chs);
    if (chs == 1)
    {
        int elem;
        printf("Enter element to push: ");
        scanf("%d", &elem);
        push(h, elem);
    }
    else if (chs == 2)
    {
        pop(h);
    }
    else if (chs == 3)
    {
        displaystack(h);
    }
    else
    {
        printf("Invalid Choice\n");
    }
}

int isFullq(struct queue *h)
{
    if (h->rear == MAX - 1)
    {
        return 1;
    }
    return 0;
}
void enqueue(struct queue *q, int value)
{
    if (isFullq(q))
    {
        printf("Queue is full\n");
        return;
    }
    q->rear++;
    q->arr[q->rear] = value;
    while (1)
    {
    }
}
int isEmptyq(struct queue *h)
{
    if (h->front == -1 && h->rear == -1)
    {
        return 1;
    }
    return 0;
}
void dequeue(struct queue *q)
{
    if (isEmptyq(q))
    {
        printf("Queue is empty\n");
        return;
    }
    q->front++;
    int data = q->arr[q->front];
    printf("Dequeued = %d\n", data);
}
void displayq(struct queue *h)
{
    if (isEmptyq(h))
    {
        printf("Queue is empty\n");
        return;
    }
    for (int i = h->front; i <= h->rear; i++)
    {
        printf("%d\t", h->arr[i]);
    }
    printf("\n");
}
void single_queue(struct queue *q)
{
    printf("1.Enqueue\n");
    printf("2.Dequeue\n");
    printf("3.Display\n");
    int ch;
    printf("Enter Choice\n");
    scanf("%d", &ch);
    if (ch == 1)
    {
        int el;
        printf("Enter Element\n");
        scanf("%d", &el);
        enqueue(q, el);
    }
    else if (ch == 2)
    {
        dequeue(q);
    }
    else
    {
        displayq(q);
    }
}

struct linkedList *inputl()
{
    struct linkedList *head = NULL;
    struct linkedList *newNode;
    int value, choice, position;

    while (1)
    {
        printf("Enter a number (-0 to exit): ");
        scanf("%d", &value);

        if (value == -0)
        {
            break;
        }

        // Create a new node and populate it with data
        newNode = (struct linkedList *)malloc(sizeof(struct linkedList));
        if (newNode == NULL)
        {
            printf("Memory allocation failed.\n");
            exit(1);
        }
        newNode->data = value;
        newNode->next = NULL;

        // If the list is empty, set the new node as the head
        if (head == NULL)
        {
            head = newNode;
        }
        else
        {
            // Otherwise, traverse the list to the end and add the new node
            struct linkedList *temp = head;
            while (temp->next != NULL)
            {
                temp = temp->next;
            }
            temp->next = newNode;
        }

        // Display the updated list
        displaylist(head);
    }

    // Provide insertion options
    while (1)
    {
        printf("\nOptions:\n");
        printf("1. Insert at beginning\n");
        printf("2. Insert at end\n");
        printf("3. Insert at specific position\n");
        printf("Enter your choice (1, 2, 3) or -0 to exit: ");
        scanf("%d", &choice);

        if (choice == -0)
        {
            break;
        }

        // Handle insertion based on user choice
        printf("Enter the number to insert: ");
        scanf("%d", &value);

        // Create a new node and populate it with data
        newNode = (struct linkedList *)malloc(sizeof(struct linkedList));
        if (newNode == NULL)
        {
            printf("Memory allocation failed.\n");
            exit(1);
        }
        newNode->data = value;
        newNode->next = NULL;

        // Handle insertion based on user choice
        switch (choice)
        {
        case 1:
            // Insert at the beginning
            newNode->next = head;
            head = newNode;
            break;
        case 2:
            // Insert at the end
            if (head == NULL)
            {
                head = newNode;
            }
            else
            {
                struct linkedList *temp = head;
                while (temp->next != NULL)
                {
                    temp = temp->next;
                }
                temp->next = newNode;
            }
            break;
        case 3:
            // Insert at specific position
            printf("Enter the position to insert: ");
            scanf("%d", &position);
            if (position <= 0)
            {
                printf("Invalid position.\n");
                free(newNode);
            }
            else if (position == 1)
            {
                // Insert at the beginning
                newNode->next = head;
                head = newNode;
            }
            else
            {
                // Traverse the list to the specified position and insert the new node
                struct linkedList *temp = head;
                for (int i = 1; i < position - 1 && temp != NULL; ++i)
                {
                    temp = temp->next;
                }
                if (temp == NULL)
                {
                    printf("Invalid position.\n");
                    free(newNode);
                }
                else
                {
                    newNode->next = temp->next;
                    temp->next = newNode;
                }
            }
            break;
        default:
            printf("Invalid choice. Please enter 1, 2, 3, or -0.\n");
            break;
        }

        // Display the updated list
        displaylist(head);
    }

    // Return the head of the list
    return head;
}
void displaylist(struct linkedList *head)
{
    struct linkedList *current = head;
    printf("Linked List: ");
    while (current != NULL)
    {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

void displayList(struct linkedList *d)
{
    struct linkedList *current = d;
    printf("Linked List: ");
    while (current != NULL)
    {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

struct linkedList *deleteFirstNode(struct linkedList *d)
{
    if (d == NULL)
    {
        printf("List is empty. Cannot delete.\n");
    }
    else
    {
        struct linkedList *temp = d;
        d = d->next;
        free(temp);
        printf("First node deleted.\n");
    }
    return d;
}

struct linkedList *deleteLastNode(struct linkedList *d)
{
    if (d == NULL)
    {
        printf("List is empty. Cannot delete.\n");
    }
    else if (d->next == NULL)
    {
        free(d);
        d = NULL;
        printf("Last node deleted.\n");
    }
    else
    {
        struct linkedList *temp = d;
        while (temp->next->next != NULL)
        {
            temp = temp->next;
        }
        free(temp->next);
        temp->next = NULL;
        printf("Last node deleted.\n");
    }
    return d;
}

struct linkedList *deleteNodeByValue(struct linkedList *d, int value)
{
    if (d == NULL)
    {
        printf("List is empty. Cannot delete.\n");
    }
    else
    {
        if (d->data == value)
        {
            struct linkedList *temp = d;
            d = d->next;
            free(temp);
            printf("Node with value %d deleted.\n", value);
            return d;
        }

        struct linkedList *temp = d;
        while (temp->next != NULL && temp->next->data != value)
        {
            temp = temp->next;
        }

        if (temp->next == NULL)
        {
            printf("Node with value %d not found.\n", value);
        }
        else
        {
            struct linkedList *nodeToDelete = temp->next;
            temp->next = temp->next->next;
            free(nodeToDelete);
            printf("Node with value %d deleted.\n", value);
        }
    }
    return d;
}

struct linkedList *inputList()
{
    struct linkedList *d = NULL;
    struct linkedList *newNode;
    int value;

    while (1)
    {
        printf("Enter a number (-0 to stop input): ");
        scanf("%d", &value);

        if (value == -0)
        {
            break;
        }

        // Create a new node and populate it with data
        newNode = (struct linkedList *)malloc(sizeof(struct linkedList));
        if (newNode == NULL)
        {
            printf("Memory allocation failed.\n");
            exit(1);
        }
        newNode->data = value;
        newNode->next = NULL;

        // If the list is empty, set the new node as the head
        if (d == NULL)
        {
            d = newNode;
        }
        else
        {
            // Otherwise, traverse the list to the end and add the new node
            struct linkedList *temp = d;
            while (temp->next != NULL)
            {
                temp = temp->next;
            }
            temp->next = newNode;
        }

        // Display the updated list
        displayList(d);
    }

    return d;
}

void reverse(struct linkedList *r)
{
    if (r == NULL)
        return;
    reverse(r->next);
    printf("%d\t", r->data);
}

void stack_using_linked_list()
{
    struct Stack *stack = createStack();
    int value;

    while (1)
    {
        printf("Enter a number (-0 to stop input): ");
        scanf("%d", &value);

        if (value == -0)
        {
            break;
        }

        pushsll(stack, value);
        displayStack(stack);
    }

    int choice;
    while (1)
    {
        printf("\nOptions:\n");
        printf("1. Pop element\n");
        printf("2. Display stack\n");
        printf("3. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);

        switch (choice)
        {
        case 1:
            value = popsll(stack);
            if (value != -1)
            {
                printf("Popped element: %d\n", value);
            }
            displayStack(stack);
            break;
        case 2:
            displayStack(stack);
            break;
        case 3:
            // Free the memory (optional, depending on your requirements)
            while (stack->top != NULL)
            {
                struct Node *temp = stack->top;
                stack->top = stack->top->next;
                free(temp);
            }
            free(stack);
            printf("Program exited successfully.\n");
            return;
        default:
            printf("Invalid choice. Please enter 1, 2, or 3.\n");
            break;
        }
    }
}

void displayStack(struct Stack *stack)
{
    struct Node *current = stack->top;
    printf("Stack: ");
    while (current != NULL)
    {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}
int popsll(struct Stack *stack)
{
    if (stack->top == NULL)
    {
        printf("Stack is empty.\n");
        return -1; // Return -1 to indicate stack underflow
    }
    struct Node *temp = stack->top;
    int value = temp->data;
    stack->top = temp->next;
    free(temp);
    return value;
}

void pushsll(struct Stack *stack, int value)
{
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    if (newNode == NULL)
    {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    newNode->data = value;
    newNode->next = stack->top;
    stack->top = newNode;
}
struct Stack *createStack()
{
    struct Stack *stack = (struct Stack *)malloc(sizeof(struct Stack));
    if (stack == NULL)
    {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    stack->top = NULL;
    return stack;
}
void queue_using_linkedlist()
{
    struct Queue *queue = createQueue();
    int Value;
    int Choice;

    while (1)
    {
        printf("Enter a number (-0 to stop input): ");
        scanf("%d", &Value);

        if (Value == -0)
        {
            break;
        }

        Enqueue(queue, Value);
    }

    while (1)
    {
        printf("Options:\n");
        printf("1. Dequeue\n");
        printf("2. Display Queue\n");
        printf("3. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &Choice);

        switch (Choice)
        {
        case 1:
        {
            int DequeuedValue = Dequeue(queue);
            if (DequeuedValue != -1)
            {
                printf("Dequeued element: %d\n", DequeuedValue);
            }
            DisplayQueue(queue);
            break;
        }
        case 2:
            DisplayQueue(queue);
            break;
        case 3:
            // Free the memory (optional, depending on your requirements)
            while (queue->Front != NULL)
            {
                struct QueueNode *Temp = queue->Front;
                queue->Front = queue->Front->next;
                free(Temp);
            }
            free(queue);
            printf("Program exited successfully.\n");
            return;
        default:
            printf("Invalid choice. Please enter 1, 2, or 3.\n");
            break;
        }
    }
}
void DisplayQueue(struct Queue *queue)
{
    if (queue->Front == NULL)
    {
        printf("Queue is empty.\n");
        return;
    }
    struct QueueNode *current = queue->Front;
    printf("Queue: ");
    while (current != NULL)
    {
        printf("%d -> ", current->Data);
        current = current->next;
    }
    printf("NULL\n");
}

struct Queue *createQueue()
{
    struct Queue *queue = (struct Queue *)malloc(sizeof(struct Queue));
    if (queue == NULL)
    {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    queue->Front = NULL;
    queue->Rear = NULL;
    return queue;
}

int Dequeue(struct Queue *queue)
{
    if (queue->Front == NULL)
    {
        printf("Queue is empty.\n");
        return -1; // Return -1 to indicate queue underflow
    }
    struct QueueNode *temp = queue->Front;
    int Value = temp->Data;
    queue->Front = temp->next;
    if (queue->Front == NULL)
    {
        queue->Rear = NULL;
    }
    free(temp);
    return Value;
}
void Enqueue(struct Queue *queue, int Value)
{
    struct QueueNode *newNode = (struct QueueNode *)malloc(sizeof(struct QueueNode));
    if (newNode == NULL)
    {
        printf("Memory allocation failed.\n");
        exit(1);
    }
    newNode->Data = Value;
    newNode->next = NULL;
    if (queue->Rear == NULL)
    {
        queue->Front = newNode;
        queue->Rear = newNode;
    }
    else
    {
        queue->Rear->next = newNode;
        queue->Rear = newNode;
    }
}
int main()
{
    printf("1.Searching\n");
    printf("2.Sorting\n");
    printf("3.Array Operation\n");
    printf("4.Stack\n");
    printf("5.Queue\n");
    printf("6.Linked List\n");
    int ch;
    printf("Enter Your Choice\n");
    scanf("%d", &ch);
    struct linkedList *d;

    struct stackArray *s;
    s->top = -1;
    struct queue *head = (struct queue *)malloc(sizeof(struct queue));
    head->front = -1;
    head->rear = -1;
    struct stacklist *sl;
    struct linkedList *h;
    struct linkedList *rem;

    switch (ch)
    {
    case 1:
        printf("1.Linear Search\n");
        printf("1.Binary Search\n");
        int ch2;
        printf("Enter Your Choice\n");
        scanf("%d", &ch2);
        switch (ch2)
        {
        case 1:
            linear_search();
            break;
        case 2:
            binary_search();
            break;
        default:
            printf("Wrong Choice\n");
            break;
        }
        break;
    case 2:
    {
        int ch3;
        printf("1.Bubble Sort\n");
        printf("2.Selection Sort\n");
        printf("3.Merge Sort\n");
        printf("4.Insertion Sort\n");
        printf("5.Quick Sort\n");
        printf("6.Radix Sort\n");
        scanf("%d", &ch3);
        switch (ch3)
        {
        case 1:
            bubble_sort();
            break;
        case 2:
            selection_sort();
            break;
        case 3:
            input();
            // merge_sort();

            break;
        case 4:
            insertion_sort();
            break;
        case 5:
            input_q();
            // quick_sort();
            break;

        default:
            printf("Enter Correct Choice\n");
            break;
        }
        break;
    }
    case 3:
        printf("1.Insertion\n");
        printf("2.Deletion\n");
        int ch4;
        printf("Enter Your Choice\n");
        scanf("%d", &ch4);
        switch (ch4)
        {
        case 1:
            insertion();
            break;
        case 2:
            deletion();
            break;

        default:
            printf("Enter Correct Choice\n");
            break;
        }
        break;
    case 4:
        printf("1.Stack Using Array\n");
        printf("2.Stack Using Linked List\n");
        int ch5;
        printf("Enter Your Choice\n");
        scanf("%d", &ch5);
        switch (ch5)
        {
        case 1:
            stack_using_array(s);
            break;
        case 2:
            stack_using_linked_list();

            break;
        default:
            printf("Enter Correct Choice\n");
            break;
        }
        break;
    case 5:
        printf("1.Single Ended Queue\n");
        printf("2.Queue Using Linked_List\n");

        int ch6;
        printf("Enter Your Choice\n");
        scanf("%d", &ch6);
        switch (ch6)
        {
        case 1:
            single_queue(head);
            break;
        case 2:
            queue_using_linkedlist();
            break;

        default:
            printf("Enter Correct Choice\n");
            break;
        }
        break;
    case 6:

        printf("1.Insertion\n");
        printf("2.Deletion\n");
        printf("3.Reverse Linked List\n");
        int ch7;
        printf("Enter Your Choice\n");
        scanf("%d", &ch7);
        switch (ch7)
        {
        case 1:
            printf("1.Insertion At Beginning\n");
            printf("2.Insertion At End\n");
            printf("3.Insertion At Specific Position\n");
            int ch71;
            scanf("%d", &ch71);
            printf("Enter Your Choice\n");
            switch (ch71)
            {
            case 1:
                h = inputl();
                displaylist(h);
                break;
            default:
                printf("Enter Correct Choice\n");
                break;
            }
            break;
        case 2:
            d = inputList();
            int choice, valueToDelete;
            while (1)
            {
                printf("\nDeletion Options:\n");
                printf("1. Delete first node\n");
                printf("2. Delete last node\n");
                printf("3. Delete a specific node by value\n");
                // printf("4. Exit\n");
                printf("Enter your choice: ");
                int ch72;
                scanf("%d", &ch72);

                switch (ch72)
                {
                case 1:
                    d = deleteFirstNode(d);
                    displayList(d);
                    break;
                case 2:
                    d = deleteLastNode(d);
                    displayList(d);
                    break;
                case 3:
                    printf("Enter the value to delete: ");
                    scanf("%d", &valueToDelete);
                    d = deleteNodeByValue(d, valueToDelete);
                    displayList(d);
                    break;
                }
                break;
            }
            break;
        case 3:
            rem = inputList();
            printf("Before Reversing : \n");
            displayList(rem);
            printf("After Reversing : \n");
            reverse(rem);
            break;
        default:
            printf("Enter Correct Choice\n");
            break;
        }
    }
}