Автор оригинала: Pankaj Kumar.
Связанный список – это простой, но увлекательная структура данных, которую можно использовать для хранения линейно связанных нереационных данных.
Мы часто встречаются с интересными манипулятивными проблемами, используя связанный список по мере того, как они требуют нерешенного мышления с ограниченными свойствами по отдельно связанным списком.
В этой статье мы будем обсуждать проблему на Обратитесь в одиночку связанный список Отказ
На протяжении всей статьи я предполагаю, что вы сможете понять базовую терминологию, связанную с связанными списками. Если это не так, пожалуйста, обратитесь к следующей статье (S) перед чтением.
Java linkedList – LinkedList в Java
Реверсив связанный список
Давайте погрузиться прямо в обсуждение для решения. Мы обсудим два метода:
- Итеративный раствор (используя 3 указателя)
- Рекурсивное решение (используя указатели псевдо-2)
Примечание : Я бы предложил вам попытаться решить проблему, а затем перейти к решению.
Обратный список связан с использованием итеративного решения
- Давайте сначала перейдем к базовым случаям. Если связанный список имеет 0 или только 1 узел, то он не имеет смысла поменять список, поэтому мы можем просто вернуть тогда и там.
- Предполагая, что у нас сейчас узлы, мы можем сделать следующее.
- Держите 3 указателя на предыдущем узле, текущем узле, следующем узле.
- Изначально назначить предыдущий узел как NULL, текущий узел в качестве головы и следующего узла в качестве преемника головы.
- Обратитесь в связь между предыдущим и текущим узлом.
- Переместите все указатели на шаг вперед, сделав следующие:
- Предыдущий узел
- Текущий узел
- Следующий узел -> следующий
- Перейдите к шагу 5, пока текущий узел не станет NULL.
- Назначьте голову как предыдущий узел и возврат.
Код, следующий на этой парадигме, можно найти здесь.
Код в C.
#include#include struct node{ int data; struct node *next; } *head = NULL; struct node *make_node(int data){ struct node *new = (struct node *)malloc(sizeof(struct node)); new->next = NULL; new->data = data; return new; } void push(int data){ struct node *new_node = make_node(data); new_node->next = head; head = new_node; } void print_list(){ struct node *cur = head; while(cur){ printf("%d ", cur->data); cur = cur->next; } printf("\n"); } void reverse_list(){ if(head == NULL || head->next == NULL) return; struct node *prev = NULL, *cur = head, *next; while(cur){ next = cur->next; cur->next = prev; prev = cur; cur = next; } head = prev; } int main(){ push(3); push(4); push(5); push(6); printf("Given Linked list is: "); print_list(); reverse_list(); printf("Reversed Linked list is: "); print_list(); return 0; }
Код в Python
class Node:
def __init__(self, data):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None
def reverse(self):
if self.head is None or self.head.next is None:
return
prev = None
cur = self.head
while cur:
next_element = cur.next
cur.next = prev
prev = cur
cur = next_element
self.head = prev
def push(self, data):
new_node = Node(data)
new_node.next = self.head
self.head = new_node
def print_list(self):
cur = self.head
l1 = []
while cur:
l1.append(cur.data)
cur = cur.next
return l1
head = LinkedList()
head.push(3)
head.push(4)
head.push(5)
head.push(6)
print("Given list is: ", head.print_list())
head.reverse()
print("Reversed list is: ", head.print_list())
Обратный список связан с использованием рекурсивного решения
Рекурсивное решение немного легко понять, поскольку он использует более естественный и простой для понимания алгоритма. Тем не менее, итеративные и рекурсивные решения аналогичны в работе.
В основном мы используем рекурсию, чтобы заменить указатель «Далее», поскольку мы можем вернуться вперед до конца связанного списка и следуйте аналогичным образом как итеративное решение.
Единственные различия, которые мы перемещаем назад, а также до конца списка, из-за использования рекурсии.
Также обратите внимание, что в рекурсивом решении нам не требуется следующий указатель, поскольку рекурсия позволяет нам двигаться вперед в связанном списке.
Здесь мы определяем рекурсивное решение в 2 частях:
- Рекурсивный случай:
- Мы сначала продвинулись вперед в связанном списке.
- Когда рекурсион заканчивается, мы можем просто связать текущий узел к предыдущему узлу.
- Базовый чехол: если текущий элемент NULL, то мы можем просто назначить голову как предыдущий узел I.E. Последний узел связанного списка в этом случае.
Код, следующий за этой парадигмой, можно найти здесь:
Код в C.
#include#include struct node{ int data; struct node *next; } *head = NULL; struct node *make_node(int data){ struct node *new = (struct node *)malloc(sizeof(struct node)); new->next = NULL; new->data = data; return new; } void push(int data){ struct node *new_node = make_node(data); new_node->next = head; head = new_node; } void print_list(){ struct node *cur = head; while(cur){ printf("%d ", cur->data); cur = cur->next; } printf("\n"); } struct node *reverse_list(struct node *prev, struct node *cur){ if(cur == NULL){ head = prev; } else{ reverse_list(cur, cur->next); cur->next = prev; } } int main(){ push(3); push(4); push(5); push(6); printf("Given Linked list is: "); print_list(); reverse_list(NULL, head); printf("Reversed Linked list is: "); print_list(); return 0; }
Код в Python
class Node:
def __init__(self, data):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None
def _reverse(self, prev, cur):
if cur is None:
self.head = prev
else:
self._reverse(cur, cur.next)
cur.next = prev
def reverse(self):
self._reverse(None, self.head)
def push(self, data):
new_node = Node(data)
new_node.next = self.head
self.head = new_node
def print_list(self):
cur = self.head
l1 = []
while cur:
l1.append(cur.data)
cur = cur.next
return l1
head = LinkedList()
head.push(3)
head.push(4)
head.push(5)
head.push(6)
print("Given list is: ", head.print_list())
head.reverse()
print("Reversed list is: ", head.print_list())
Выход
Обратный список связан с использованием рекурсии – Python