Question

(WRITE THIS PROGRAM IN C LANGUAGE).Before I ask the question, i'm just letting you know that I asked this question before but I unfortunately the answer was wrong, in fact, it didn't even answer my questions. So please make an effort to answer this question.

In this question, we will learn about a variant of linked list called \doubly Linked List". In addition to the \next" pointer pointing to the next node in the list, a node in a doubly linked list also contains a pointer \prev" pointing to the previous node in the list. One implementation of the doubly linked List is as follows. #include #include // Node d e f i n i t i o n f o r doubly l i n k e d l i s t typedef struct d l l n o d e { int data ; struct d l l n o d e * next ; struct d l l n o d e * prev ; } DLLnode t ; // De f ini t i on of doubly l i n k e d l i s t typedef struct { DLLnode t * head ; } DLL t ; // Creates a doubly l i n k e d l i s t DLL t * DLLCreate ( ) { DLL t * r e t = mal loc ( sizeof (DLL t ) ) ; r e t->head = NULL; return r e t ; } // Appends a DLLnode t containing the value x int o a DLL t void DLLAppend(DLL t * i n t l i s t , int x ) f // Create a DLLnode t DLLnode t * newNode = mal loc ( s izeof (DLLnode t ) ) ; newNode->data = x ; newNode->prev = NULL; newNode->next = NULL; // Point head to new node if list is empty i f ( i n t l i s t ->head == NULL) { i n t l i s t ->head = newNode ; return ; } DLLnode t * temp =i n t l i s t ->head ; while ( temp->next != NULL) { temp = temp->next ; // Go To last Node } temp->next = newNode ; newNode->prev = temp ; } // Prints the elements of a doubly l i n k e d l i s t void DLLPrint (DLL t * i n t l i s t ) f DLLnode t * temp = i n t l i s t ->head ; while ( temp != NULL) { p r i n t f ( "%d " , temp->data ) ; temp = temp->next ; } p r i n t f ( "\n" ) ; } Part a) Based on the doubly linked list implementation given above, implement a func- tion called \DLLReverse" to reverse a list. For example, if a doubly linked list originally contains the list f4, 5, 7, 7, 9g, after calling DLLReverse, the list would become f9, 7, 7, 5, 4g. The function prototype is given below. // Reverses a DLL t void DLLReverse (DLL t * i n t l i s t ) f } Part b) Implement a function called \DLLRemove" to remove any node at a specied index \ind". Just as with C++ arrays, the rst element of the list should have an index of 0. Starting at 0, indices go up to one less than the length of the list. Your DLLRemove function should give the following message if the user passes in an invalid index: \Warning: Invalid index!" No other operations should be done if the index is invalid. The function prototype is given below. // Removes the element at index ind f o r a DLL t , and // warns the user i f the index i s i n v a l i d void DLLRemove(DLL t * i n t l i s t , int ind ) {

Answer 1

#include <stdio.h>
#include <stdlib.h>

//Node definition for doublylinkedlist 
typedef struct dllnode 
{
    int data; 
    struct dllnode *next;
    struct dllnode *prev;
} DLLnodet;

//Definition of doublylinkedlist
typedef struct{
    DLLnodet* head;
}DLLt;

//Creates a doublylinkedlist
DLLt* DLLCreate(){
    DLLt *ret=malloc(sizeof(DLLt)); 
    ret->head=NULL;
    return ret;
}

//Appends a DLLnodet containing the value x into a DLLt
void DLLAppend(DLLt *intlist, int x) {
    //Create a DLLnodet
    DLLnodet*newNode=malloc(sizeof(DLLnodet));
    newNode->data=x;
    newNode->prev=NULL;
    newNode->next=NULL;

    //Point head to new node if list is empty
    if(intlist->head==NULL){
        intlist->head=newNode;
        return;
    }

    DLLnodet*temp=intlist->head;
    while(temp->next!=NULL){
        temp=temp->next;
        //Go To lastNode
    }

    temp->next=newNode;
    newNode->prev=temp;
}

//Prints the elements of a doublylinkedlist
void DLLPrint(DLLt* intlist){
    DLLnodet*temp=intlist->head;
    while(temp!=NULL){
        printf("%d ",temp->data);
        temp=temp->next;
    }
    printf("\n");
}

void DLLReverse(DLLt *intlist) {
    DLLnodet* current = intlist->head;
    DLLnodet* prev = NULL;

    while(current != NULL) {
        DLLnodet *tmp = current->next;
        if(prev != NULL) {
            prev->prev = current;
        }
        current->next = prev;
        prev = current;
        current = tmp;
    }
    // prev now points to last node, which should become head now.
    intlist->head = prev;
    prev->prev = NULL;
}

void DLLRemove(DLLt *intlist, int ind) {
    if(intlist == NULL) {
        return;
    }
    if(ind == 0) {
        DLLnodet* t = intlist->head;
        intlist->head = t->next;

        if(intlist->head != NULL) {
            intlist->head->prev = NULL;
        }
        free(t);
        return;
    } else {
        int i = 1;
        DLLnodet *prev = intlist->head;
        DLLnodet *current = intlist->head->next;

        while((current != NULL) && (ind != i)) {
            current = current->next;
            i++;
        }

        if(current != NULL) {
            DLLnodet *p = current->prev;
            DLLnodet *n = current->next;

            if(p != NULL) {
                p->next = n;
            }
            if(n != NULL) {
                n->prev = p;
            }
            free(current);
        } else {
printf("Invalid Index");
}
    }
}

int main() {
    DLLt* list = DLLCreate();
    DLLAppend(list, 1);
    DLLAppend(list, 2);
    DLLAppend(list, 3);
    DLLAppend(list, 4);
    DLLAppend(list, 5);

    DLLPrint(list);

    DLLReverse(list);
    DLLPrint(list);

    DLLRemove(list, 4);
    DLLPrint(list);

    DLLRemove(list, 0);
    DLLPrint(list);
}

Please upvote, as i have given the exact answer as asked in question. Still in case of any concerns in code, let me know in comments. Thanks!

a main.c 102 103 104 105 106 107 108 109 110 Files saved https://AfraidHoneydewMacroinstructio if(p != NULL) { p->next clang verston 6.0.0-1ubuntu2 (tags/R 1 2 3 4 5 5 4 3 2 1 5 4 3 2 4 3 2 main.c = n; != NULL) { n->prev if(n p; = free(current); 112 113 114 int main() [ 115 116 DLLt" list -DLLCreate); DLLAppend(list, 1); DLLAppend (list, 2); DLLAppend(list, 3); DLLAppend(list, 4); DLLAppend (list, 5); 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 DLLPrint(list); DLLReverse(list); DLLPrint (list); DLLRemove(list, 4) DLLPrint (list); DLLRemove(list, ) DLLPrint (list);