изменения узлов связанного списка

Question

Код для моего списка узлов:

struct list{           
    int value;          
    struct list *next;        
}; 

я хочу сделать функцию подкачки так:

void swap(struct list *head , int v) 

Пользователь дает ряд V и программы найдите его в списке и измените его на следующий узел. Например, если пользователь дает 3, а список содержит: 2 -1 7 3 -5 4, функция подкачки сделает список следующим образом: 2 -1 7 -5 3 4 Любые идеи?

Я сделал следующий код для обмена:

void swap(struct list *head, int v){ 
     struct list *before=NULL; 
     struct list *found=NULL; 
     struct list *after=NULL; 


if(head==NULL){ 
    printf("Case of empty list !\n); 
} 

before=head; 
found=head; 
while(found->next !=NULL){ 
     if (found->value==v){ 
       after = before->next; 
       before = found->next; 
     } 
     before = found; 
     found = found->next; 
     after = found->next; 
} 
return; 
} 

Answer 1

Попробуйте так:

1. Поиск для int v в связанных список до последнего узла

2. Если он найден, и если этот узел не является последним узлом, тогда поменяйте данные узла.

3. Если это последний узел, то вы не можете поменять местами. Вы должны найти еще один случай

4. Если этот узел является только узел, то и вы должны рассмотреть еще одно условие так же, как если это будет последний узел

Если вы хотите поменять узел, то попробуйте это код

void swap(node *head, int v) { 

node * prev,*curr,*NEXT,*temp 

curr=head; 

prev=curr; 

NEXT=curr->next; 

while(curr!=NULL){ 

if(curr->data==v){ 

    if(curr->next!=NULL){ 
    prev->next=NEXT; 
    temp=NEXT->next; 
    NEXT->next=curr; 
    curr->next=temp; 

    break; 
    } 

    else{ 
    printf("\nThere is no further node to swap "); 
    } 
} 

prev = curr; 
curr = curr->next; 
NEXT = curr->next; 

} 

}  

Answer 2

Ну отработкой ваш пример, вы можете сделать что-то вроде следующего: Найти узел, содержащий 3 в списке. Это должно быть легко, поскольку вы передаете указатель на заголовок списка. Как только вы найдете 3, сохраните -5 во временном указателе узла. Узел с «7» указывает на то же место, что и временный указатель. Затем добавьте следующую точку указателя -5 к 3. Наконец, переназначьте 3 до 4. Логика такая же, как любая функция подкачки. Вы будете использовать временную переменную для хранения того, что вы меняете. Затем переназначьте значения.

Более общее объяснение:

1. Траверс узел, содержащий V
2. Затем сохраните следующий узел во временной указатель
3. Установить следующий указатель предыдущего узла равна временной указатель
4. . Установите следующий указатель узла, содержащий «v», равный следующему указателю временного узла.
5. установить «следующий» указатель временного указателя, равный узлу, содержащему «v»
6. Рассмотрим крайние случаи, такие как: узел не может быть выгружена потому что это последний узел в списке и т.д.

Answer 3

Поскольку у вас есть только цифры в структуре, вы должны просто их обменивать.

Будьте осторожны, за исключением следующих случаев:

• Когда нет никакого элемента поменять (т.е. конец списка).
• Когда элемент не существует в списке.

В коде:

void swap(struct list *head, int v){ 

    int temporary_number; 
    struct list *found=NULL; 

    if(head==NULL){ 
     printf("%s", "Case of empty list !\n"); 
    } 

    found = head; 

    while(found->next != NULL){ 
     if (found->value == v){ 
       temporary_value = found->next->value 
       found->next->value = found->value 
       found->value = temporary_value 
     } 
     found = found->next 
    } 

    return; 
} 

Answer 4

Не спешите. :) Как вы сказали, вам нужно поменять местами сами, вместо того, чтобы менять их значения, а затем вы здесь. :)

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

struct list 
{           
    int value;          
    struct list *next;        
}; 

void push_front(struct list **head, int value) 
{ 
    struct list *tmp = malloc(sizeof(struct list)); 

    if (tmp) 
    { 
     tmp->value = value; 
     tmp->next = *head; 
     *head = tmp; 
    } 
} 

void display(struct list *head) 
{ 
    for (struct list *tmp = head; tmp; tmp = tmp->next) 
    { 
     printf("%d ", tmp->value); 
    } 
    printf("\n"); 
}  

void swap(struct list **head, int value) 
{ 
    while (*head && (*head)->value != value) 
    { 
     head = &(*head)->next; 
    } 

    if (*head && (*head)->next) 
    { 
     struct list *next = (*head)->next->next; 
     (*head)->next->next = *head; 
     *head = (*head)->next; 
     (*head)->next->next = next; 
    }   
} 

int main(void) 
{ 
    struct list *head = NULL; 

    push_front(&head, 4); 
    push_front(&head, -5); 
    push_front(&head, 3); 
    push_front(&head, 7); 
    push_front(&head, -1); 
    push_front(&head, 2); 

    display(head); 

    swap(&head, 2); 
    display(head); 

    swap(&head, 2); 
    display(head); 

    swap(&head, 2); 
    display(head); 

    swap(&head, 2); 
    display(head); 

    swap(&head, 2); 
    display(head); 

    swap(&head, 2); 
    display(head); 

    return 0; 
} 

Выход программы

2 -1 7 3 -5 4 
-1 2 7 3 -5 4 
-1 7 2 3 -5 4 
-1 7 3 2 -5 4 
-1 7 3 -5 2 4 
-1 7 3 -5 4 2 
-1 7 3 -5 4 2 

Или еще интересный пример

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

struct list 
{           
    int value;          
    struct list *next;        
}; 

void push_front(struct list **head, int value) 
{ 
    struct list *tmp = malloc(sizeof(struct list)); 

    if (tmp) 
    { 
     tmp->value = value; 
     tmp->next = *head; 
     *head = tmp; 
    } 
} 

void display(struct list *head) 
{ 
    for (struct list *tmp = head; tmp; tmp = tmp->next) 
    { 
     printf("%d ", tmp->value); 
    } 
    printf("\n"); 
}  

void swap(struct list **head, int value) 
{ 
    while (*head && (*head)->value != value) 
    { 
     head = &(*head)->next; 
    } 

    if (*head && (*head)->next) 
    { 
     struct list *next = (*head)->next->next; 
     (*head)->next->next = *head; 
     *head = (*head)->next; 
     (*head)->next->next = next; 
    }   
} 

int main(void) 
{ 
    struct list *head = NULL; 
    int a[] = { 2, -1, 7, 3, -5, 4 }; 

    for (size_t i = 0; i < sizeof(a)/sizeof(*a); i++) 
    { 
     push_front(&head, a[i]); 
     display(head); 
     for (size_t j = 0; j < i; j++) 
     {    
      swap(&head, a[i]); 
      display(head); 
     } 
     printf("\n"); 
    } 

    display(head); 

    return 0; 
} 

Выход программы

2 

-1 2 
2 -1 

7 2 -1 
2 7 -1 
2 -1 7 

3 2 -1 7 
2 3 -1 7 
2 -1 3 7 
2 -1 7 3 

-5 2 -1 7 3 
2 -5 -1 7 3 
2 -1 -5 7 3 
2 -1 7 -5 3 
2 -1 7 3 -5 

4 2 -1 7 3 -5 
2 4 -1 7 3 -5 
2 -1 4 7 3 -5 
2 -1 7 4 3 -5 
2 -1 7 3 4 -5 
2 -1 7 3 -5 4 

2 -1 7 3 -5 4 

Как обычно мой ответ лучшим . :)