Question

I need this in C programing

And please give me complete code with screenshot of your output.

onded reverze. e le defnes α node stricture identical to the list nodes for the cycle detection probem in Lab4 3. Cycle le removal (20 points). Implemeat the function break.cycleO in The prototype of the fnction s The function receives as its sole argment a poister to the the link that closwes the cycle, list. If the list contains a cycle the function snest remowe otherwise, the list aast remain either case the head node must reai hable from the head sode by following the same, and all other nodes mst remain "sext links The function must return the address of the (unchanged) head node. You may use additional fusctions and local variables besides thoe provikded template, but cannot change the values stored in the nodes or allocate new nodes. Hint: If here is a cyele of length n, traveling from a node on the cycle n steps will get 1 of ngh back to the node. 4 List reversal (20 points). Implemeat the function reverseO in reverse.e The prototype of the function is. node * reverse(ธ。de * head ) ; As above, the function receives as its sole argument a pointer to the bead node of a singly lisked list. This time the list is assswed to be acyelic. The function must change the "next" links of the sodes so that the nodes end up linked in reverse order. The fupction must return the address of the new head node (originally last in the list). You may use additional functions and local variables besides those already included in the provided template, bat cannot change the values stored in the modes or dynamically allocate new nodes. Several test cases (including both cyclic and acyclic lists) are hard coded in the mais compiling and running the reverse program should print the following output function of reverse.c. After completing the implementation of the teo functions, reverse: 3-2-1-0 reverse reverse : 0->1.32.3 reverse : 10->9-28-->6-5-n reverse reverse: 4-5-6-7-8-9-10 reverse1 17-16->15-14-13-12->11 reverse reverse: 11-12-13->14-15-16-17 reverse: 18 reverse reverse: 18 reverse: 23-22->21->20->19 reverse reverse: 19-20-21->22-23 reverse reverse reverse2

Answer 1

The main idea to detect a cycle is to take two pointer one running fast and other is slow so if there is a cycle then fastpointer and slowpointer will to same node at some point if yes then cycle is present remove it otherwise no cycle present
#include<stdio.h>

//struct for linked list
struct node
{
    int data;
    struct node* next;
};


struct node * break_cycle(struct node *head)
{
    struct node *slowpointer = head, *fastpointer = head;
    
    while (slowpointer && fastpointer && fastpointer->next)
    {
        slowpointer = slowpointer->next; //move one pointer one step further 
        fastpointer = fastpointer->next->next; // second pointer two step
                
        //if both comes to same node means there is a cycle then call remove cycle and break the loop and return the head        
        if (slowpointer == fastpointer)
        {
            removecycle(slowpointer, head);
            break;
            
        }
        return head;
    }
}

void removecycle(struct node *loop_node, struct node *head) {
    struct node *ptr1;
    struct node *ptr2;

/* Set a pointer to the begining of the Linked List and move it one by one to find the first node which is part of the Linked List */
    ptr1 = head;
    while (1) {
        /* Now start a pointer from loop_node and check if it ever reaches ptr2 */
        ptr2 = loop_node;
        while (ptr2->next != loop_node && ptr2->next != ptr1)
            ptr2 = ptr2->next;

        /* If ptr2 reached ptr1 then there is a loop. So break the loop */
        if (ptr2->next == ptr1)
            break;

        /* If ptr2 did't reach ptr1 then try the next node after ptr1 */
        ptr1 = ptr1->next;
    }
}

Reverse linkedlist

#include<stdio.h>

//struct for linked list
struct node
{
    int data;
    struct node* next;
};

struct node * reverse(struct node * head){
    //we take two pointers and store one with the previous value and the one with next value
    struct node * previous = NULL, *next = NULL;

    while (head != NULL){
        //loop untill we reach last node we save next node of current node in next and point the current node next
        // to previous node value and then previous point to current node and current node becomes next node
        next = head->next;
        head->next = previous;
        previous = head;
        head = next;
    }

    return previous;
}