How do I redo this program for the queue into a program for a circular singly linked list?

Since you obviously didn't write the source code yourself and don't seem to understand it, it doesn't make much sense to continue working on it. You also wanted a C++ solution. The shown program framework is completely C except for cout and new and uses neither containers nor classes. If you search a bit you will find better examples. How about this one?

Implement a Circular Linked List Data Structure in C++
https://www.delftstack.com/howto/cpp/circular-linked-list-in-cpp/

This is really not C++ code. It's C with streaming input and output. There isn't a class or method to be seen.

Also - it usually is recommended to NOT recurse on the main function. In this code, you actually want to just loop - NOT recurse.

This code is not too far away from what is needed for a singly-linked list. You have a pointer to the next item and a piece of data. You just have to adapt it so the tail of the list points to the head so it is circular. The code that manipulates the list needs a lot of work but at least you have a place to start from :

struct Node 
{
    int   Data;
    Node* pNext; 
};

Next you should implement a function to add a node and another one to delete a node from the list. The operations you have to do are specializations of those two actions.

I am not going write the code for you. You need write this code yourself. You might find this tutorial helpful : Circular Linked List[^]. Their data structure is almost identical to yours.

#include <iostream>
#include <fstream>
using namespace std;

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

void Addition(Node** Head, int x) 
    {
        Node* temp = new Node;
        if (*Head == NULL) 
        {
            temp->data = x;
            (*Head) = temp;
            (*Head)->Next = *Head;
        }
        else 
        {
            temp->data = x;
            temp->Next = (*Head)->Next;
            (*Head)->Next = temp;
            *Head = temp;
        }
    }

void Insertion(Node* Head) 
    { 
        Node* current = Head->Next;
        do 
        {
            if (current->Next->data < 0 && current->data != 1) 
            {
                Node* p = new Node;
                p->data = 1;
                p->Next = current->Next;
                current->Next = p;
            }
            current = current->Next;
        } 
        while (current != Head->Next);
}

void RemovalNegative(Node** Head) 
    { 
        if ((*Head)->Next != NULL) 
        {
            Node* c1 = (*Head)->Next;
            Node* c2 = (*Head)->Next->Next;
            do 
            {
                if (c2->data < 0) 
                {
                    if (c2 == *Head) 
                    {
                    *Head = c1;
                    c1->Next = (*Head)->Next;
                    delete c2;
                    }
                    else 
                    {
                        Node* tmp = c2;
                        c2 = tmp->Next;
                        c1->Next = c2;
                        delete tmp;
                        c1 = c2;
                        c2 = c1->Next;
                    }
                }
                else 
                {
                    c1 = c1->Next;
                    c2 = c2->Next;
                }
            } 
            while (c1 != *Head);
            if ((*Head)->Next->data < 0) 
            {
                Node* tmp = (*Head)->Next;
                (*Head)->Next = (*Head)->Next->Next;
                delete tmp;
            }
        }
        else return;
    }

int RepeatingNum(Node* Head, int x) 
    { 
        int count = 0;
        Node* temp = Head->Next;
        do 
        {
            if (temp->data == x) count++;
            temp = temp->Next;
        } 
        while (temp != Head->Next);
        return count;
    }

void CyclicListDel(Node* Head)
    {
        Node* newNode = Head->Next;
        if (newNode != Head->Next) 
        {
            Node* temp = newNode->Next;
            delete newNode;
            CyclicListDel(temp);
        }
        else return;
    }

void Display(Node* Head) 
    {
        Node* newNode = Head->Next;
        do 
        {
            cout << newNode->data << " ";
            newNode = newNode->Next;
        } 
        while (newNode != Head->Next);
    }

int main() 
    {
        Node* Head = NULL;
        int x = 0;
        int ch = 0;
        int kount = 0;
        cout << "Element: ";
        while (cin >> x) 
        {
            if (x == 0) break;
            cout << "Element: ";
            Addition(&Head, x); 
        }
        cout << "Select an option: \n";
        cout << "1 - Insert '1' in front of a negative number.\n";
        cout << "2 - Delete all negative numbers.\n";
        cout << "3 - Quantity of a given number among the elements of cyclic list.\n";
        cin >> ch;
        switch (ch) 
        {
            case 1:
                Insertion(Head); 
                Display(Head);
                cout << "\n";
                break;
            case 2:
                RemovalNegative(&Head); 
                Display(Head); 
                cout << "\n";
                break;
            case 3:
                cout << "Write a number to count its repetition: \n";
                cin >> kount;
                cout << "Quantity: " << RepeatingNum(Head, kount); 
                cout << "\n";
                break;
        }
        main();
        CyclicListDel(Head); 
        return 0;
    }