Как отменить односвязный список в C?

Question

для моего класса У меня есть задача построить связанный список, ввести данные и выполнить различные функции. Мой код компилируется отлично, однако реверсия и конструктивная функция реверсии не работают.

Если я отменил список и распечатал его, я верну только первый узел. Кажется, у меня что-то отсутствует. Вот мой код: (Если вы заметили какие-либо ошибки в любой из других функций, дайте мне знать) Заранее благодарим!

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

typedef struct DoubleNode{ 
    struct DoubleNode* next; 
    double data; 

} DoubleNode; 

DoubleNode* insertFirst(DoubleNode*head, double c) { 
    DoubleNode* temp; 
    temp=malloc(sizeof(DoubleNode)); 
    temp->data= c; 
    temp->next= head; 

    return temp; 
} 
void printList(DoubleNode*head) { 
    DoubleNode* cursor; 
    printf("("); 
    cursor=head; 
    while (cursor != NULL) { 
     printf("%fl", cursor->data); 
     printf(" "); 
     cursor=cursor->next; 
    } 
    printf(")"); 
} 


DoubleNode* insertLast(DoubleNode *head, double d) { 
    DoubleNode *tmp, *cursor; 
    //trivial case: empty list 
    if (head==NULL) 
    {return insertFirst(head,d); 
    } else{ 
     //general case: goto end 
     cursor=head; 
     while (cursor->next != NULL){ 
      cursor =cursor->next; 
     } 
     tmp= malloc(sizeof(DoubleNode)); 
     tmp->data = d; 
     tmp->next = NULL; 
     cursor->next=tmp; 
     return head; 
    } 
} 

DoubleNode* reverseDoubleListCon(DoubleNode*head) { 
    DoubleNode *temp, *res, *cell; 
    cell=head; 
    res=NULL; 
    while (cell!=NULL) { 
     temp=malloc(sizeof(DoubleNode)); 
     temp->data=cell->data; 
     temp->next=res; 
     res=temp; 
     cell=cell->next; 
    } 
    return res; 
} 

void reverseDoubleList(DoubleNode*head) { 
    DoubleNode *chain, *revChain, *cell; 
    cell=head; 
    revChain=NULL; 
    while (cell!=NULL) { 
     chain=cell->next; 
     cell->next=revChain; 
     revChain=cell; 
     cell=chain; 
    } 
    head=revChain; 
} 

double get(DoubleNode*head, double n) { 
    DoubleNode *cursor; 
    cursor=head; 
    for (int i=0; i<n; i++) { 
     cursor=cursor->next; 

    } 
    return cursor->data; 
} 

DoubleNode* delete(DoubleNode*head, double n) { 
    DoubleNode *cursor, *rest; 
    cursor=head; 
    for (int i=0; i<n; i++) { 
     cursor=rest; 
     cursor=cursor->next; 

    } 
    rest->next=cursor->next; 
    free(cursor); 
    return head; 

} 

DoubleNode* insert(DoubleNode*head, double d, double n) { 
    DoubleNode *cursor, *temp, *rest; 
    cursor=head; 

    for (int i = 0; i<n-1; i++) { 
     rest=cursor; 
     cursor= cursor->next; 
    } 
    temp=malloc(sizeof(DoubleNode)); 
    temp->data=d; 
    temp->next=cursor; 
    rest->next= temp; 

    return head; 
} 

int main(int argc, const char * argv[]) { 
    DoubleNode *head; 
    head=malloc(sizeof(DoubleNode)); 

    for (double i=0.0; i <11.0; i++) { 
     head=insertLast(head, i); 
    } 
    printList(head); 
    reverseDoubleList(head); 
    printList(head); 
    reverseDoubleListCon(head); 
    printList(head); 

    return 0; 
} 

Answer 1

Чтобы создать обратную копию одного связанного список копирования одного элемента за другие, и добавить его в передней части обратного списка:

DoubleNode* reverseDoubleListCon(DoubleNode* head) { 
    DoubleNode *reverse = NULL; 
    while (head) 
    { 
     DoubleNode *temp = malloc(sizeof(DoubleNode)); 
     temp->data = head->data; // copy data to new element 
     head = head->next;  // step one forward 
     temp->next = reverse; // successor of new element is first element of reverse list 
     reverse = temp;   // head of reverse list is new element 
    } 
    return reverse; 
} 

DoubleNode* reverseHead = reverseDoubleListCon(head); 

Для обратного один связанного списка удалить первый элемент из списка и добавить его в переднем обратного списка:

DoubleNode* reverseDoubleList(DoubleNode* head) { 
    DoubleNode *reverse = NULL; 
    while (head) 
    { 
     DoubleNode *temp = head; // next element is head of list 
     head = head->next;  // step one forward 
     temp->next = reverse;  // successor of next element is first element of reverse list 
     reverse = temp;   // head of reverse list is next element 
    } 
    return reverse; 
} 

head = reverseDoubleList(head); 

Answer 2

Это будет работать для вашей обратной функции.

void reverseDoubleList(DoubleNode **head) { 
    DoubleNode *prev, *curr, *next; 
    curr=*head; 
    prev=NULL; 
    while (curr!=NULL) { 
     next=curr->next; 
     curr->next = prev; 
     prev = curr; 
     curr = next; 
    } 
    *head=prev; 
} 

Тогда в главном, назовите его reverseDoubleList(&head). Распечатайте список после этого, чтобы увидеть эффект.

Answer 3

void rev(node **head) 
{ 
    node *prev = NULL; 
    node *next = *head->next; 
    node *cur; 

    for (cur = *head; cur; cur = next) { 
     next = cur->next; 
     prev = cur; 
    } 
    *head = prev 
} 

Это связанный список сначала:

---

Шаг 2: Узел B выполнен в точке А, а А-> следующая производится NULL

---

Шаг 3: Процесс продолжается ...

---

Шаг 4: Связанный список теперь обратная ,