Основы связанного списка
Я пытаюсь понять основы Linked List. Определение моего класса LinkedList выглядит следующим образом:
public class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
Теперь я столкнулся с проблемой. Мой код выглядит следующим образом:
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode prev = dummy;
ListNode slow = head;
head.next = null;
prev.next = slow;
ListNode temp = slow.next;
prev.next = temp;
System.out.println(dummy.next); //comes out null
Почему это значение равно нулю? dummy.next указывал на голову, а я заменил только slow и prev?
Обновлено:
Можем ли мы использовать slow и head как взаимозаменяемые? Если да, то почему это происходит?
// head points to a Linked list starting from 1 in 1 -> 2 -> 3
ListNode curr = head;
while(curr.next!= null){
curr= curr.next;
}
System.out.println(curr);
System.out.println(head); //these are different and head does not change
Перекрестные публикации: stackoverflow.com/q/51110381/781723, cs.stackexchange.com/q/93668/755. Пожалуйста не размещайте один и тот же вопрос на нескольких сайтах. У каждого сообщества должен быть честный шанс ответить, не тратя время зря.
Ответы 1
Вы объявляете, что dummy указывает на тот же объект, что и head. Затем вы делаете head.next = null;. Поскольку dummy и head ссылаются на один и тот же объект, dummy.next также имеет значение null.
Обновлено:
Посмотрев дальше на ваш код, я обнаружил проблему.
Я вставлю ваш код с номерами строк для удобства.
ListNode dummy = new ListNode(0); // Line 1
dummy.next = head; // Line 2
ListNode prev = dummy; // Line 3
ListNode slow = head; // Line 4
head.next = null; // Line 5
prev.next = slow; // Line 6
ListNode temp = slow.next; // Line 7
prev.next = temp; // Line 8
System.out.println(dummy.next); // Line 9
Строки 3-4: Теперь prev указывает на тот же объект, что и dummy, и то же самое для slow и head. По сути, мы можем использовать эти «имена» как синонимы.
Строка 5: установка head рядом с нулевым значением
Строка 6: То же, что и при запуске: dummy.next = head
Строка 7: temp теперь указывает на следующий head (поскольку slow и head одинаковы). Помните, что следующее значение head равно нулю (строка 5). По сути, это означает, что temp равен нулю.
Строка 8: То же, что и dummy.next
= temp. Поскольку значение temp равно нулю, здесь вы устанавливаете dummy рядом с нулем
Привет! Спасибо за ответы. На самом деле у меня был dummy.next = head, а не dummy = head.
Где вы сначала инициализируете переменную dummy?
Привет, Боби! Я отредактировал вопрос, чтобы ответить на вашу озабоченность. Спасибо за ответ!
Без проблем! Спасибо за разъяснение вопроса.
Меня все это очень смущает.
@crazyy_photonn Я нашел проблему. Я обновил ответ.
Привет! Спасибо за предельно подробное объяснение. Что касается объяснения, которое вы даете, у меня есть сомнения. Код выглядит следующим образом: Предположим, что заголовок указывает на связанный список 1 -> 2 -> 3. Голова - это узел со значением 1. Теперь ListNode curr = head ; в то время как (curr.next! = null) {curr = curr.next; } System.out.println (curr); System.out.println (голова); Эти двое разные. Если мы можем использовать curr и head как взаимозаменяемые, почему это показывает разные результаты?
Я отредактировал вопрос, чтобы отразить мои затруднения? Надеюсь, мне понятнее то, о чем я прошу. Не стесняйтесь спрашивать, если что-то не имеет смысла. Спасибо!
Я только сказал, что мы можем использовать curr и head как взаимозаменяемые, потому что вы изначально определяете переменную curr в указать на - тот же объект, на который указывает head. Если вы сделали curr.val = 5;, то вы увидите, что head.val также был изменен на 5. head и curr - это два способа ссылки на один и тот же базовый объект. Но, в вашем цикле while вы переназначаете curr. Это означает, что он больше не будет указывать на тот же объект, на который указывает head.
Ох!! Это действительно имеет смысл. Большое спасибо за то, что прояснили это для меня! Я приму твой ответ. Еще раз спасибо!
Почему бы не попробовать и не посмотреть, что произойдет?