Связанные списки: при добавлении элемента почему current.Next указывает на новый узел и почему мы перезаписываем текущий узел

Question

Я новичок в C #, и я поднимаю его, решая сценарии, связанные со структурами данных. Мне нужна помощь для визуализации того, что происходит в следующем фрагменте кода

public void AddAtLast(object data)
{
   Node newNode = new Node();
   newNode.Value = data;
   current.Next = newNode;
   current = newNode;
   Count++;
}

Какую часть я понял

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

Что мне нужно помочь с

Я особенно думаю, почему current.Next указывает на newNode, если он не указывает на NULL, так как мой newNode будет помещен в конец связанного списка, и поэтому он должен указывать на NULL.

Кроме того, почему мы делаем current=newNode?

Я понимаю, почему count++ присутствует, вероятно, потому, что хотят отслеживать положение, в котором добавляется новый элемент, но исправьте меня, если мое понимание неверно.

Answer 1

current - это позиция кандидата для следующей операции AddAtLast, то есть конечного узла связанного списка.

Я понимаю, почему count ++ присутствует, вероятно, потому что он хочет отслеживать> позиция, в которой добавляется новый элемент, но исправьте меня, если мое понимание> неверно с этим.

Для структуры связанного списка, которую вы здесь показали, в то время как count используется для отслеживаниячисло узлов, current для отслеживания текущей позиции «быть добавляемым в последнюю очередь» (то есть старым последним узлом в связанном списке перед добавлением newNode) для упрощения операции AddAtLast.После добавления newNode в старом current методом AddAtLast ваш current будет перемещен и будет ссылаться на обновленный последний узел (то есть newNode, который был добавлен только сейчас).

Answer 2

Похоже, вы пытаетесь отслеживать текущий элемент, как если бы вы использовали указатель в C для хвоста.Таким образом, вы можете иметь ссылку на ссылку на конечный объект.По сути, это свойство типа Node.

Answer 3

Итак, давайте посмотрим, что происходит построчно в методе AddAtLast(object data) связанного списка Класс

1. Node newNode = new Node();

Создайте новый Узел , это цель методов AddAtLast в жизни

2. newNode.Value = data;

Назначить некоторые данные для узла

3. current.Next = newNode;

Назначьте newNode, который был создан, на Current. Это Связанная часть Связанного списка

4. current = newNode;

Перезаписать Current (это должно показаться странным), я расскажу об этом позже.

5. Count++

Увеличьте Count Linked List. Приятно знать размер списка без необходимости обходить все его элементы. Это просто короткий способ всегда знать количество.

---

Первое, что вы должны запомнить

На языке C # (и многих других языках) объекты / классы имеют тип Ссылочный тип . Когда вы создаете Current (или любой другой объект / класс), вы делаете 2 вещи.

1. Резервирование физической части памяти и заполнение ее новым объектом
2. Создание ссылки (он же адрес, он же указатель) на эту память. Думайте об адресах, как Post-It-Note к чему-то, что существует где-то в вашем доме.

Когда вы перезаписываете ссылку, вы фактически не разрушаете память, как если бы вы записали адрес в заметке и написали что-то еще. Ваши туфли все еще живут в шкафу. Единственное исключение из этого в .Net - если для вас больше не осталось ссылок на объект / класс, Сборщик мусора (ваша мама) придет, очистит его и выбросит.

При вызове current = newNode; кажется, что мы просто потеряли его, переписали и потеряли все ссылки на этот узел (мы отслеживали в прошлый раз), но мы этого не сделали.

---

Второе, что нужно запомнить

Умные Сабо , которые инвестировали в Связанный список , знали, что мы должны каким-то образом отслеживать элементы, поэтому они предусмотрели, когда Узел получит добавил, что где-то другой узел должен иметь Link .

Это то, о чем была эта строка кода (current.Next = newNode). Убедитесь, что он действительно связан в списке. Да, поэтому мы переписали это, но теперь мы знаем, что, хотя кто-то еще ссылается Узел , он не будет очищен. Кроме того, если мы хотим найти его снова, все, что нам нужно сделать, это найти первый Node и пройти через связи.

---

Другой способ думать об этом

Думайте о Current как о ведре, в этом ведре у вас есть Узел , и на этом Узле находится лист бумаги, называемый следующим.

1. Кто-то вручает вам новый Узел .
2. Вы старательно пишете имя этого нового узла (который нам кто-то дал) на Узле , который у вас есть в корзине (Next/Link Post-It-Note, который есть у каждого узла)
3. Вы опрокидываете ведро на пол и кладете свой новый Узел в ведро.

Но вы должны помнить, что Node , который вы выдавали, все еще где-то есть (на самом деле, вероятно, есть еще один узел с его именем на нем, как вы написали свой новый * 1129) * Узлы новое имя на это ). Хотя мы не можем легко получить к ним доступ, они все еще есть, если мы пройдем по Связям

По сути, так работает Linked List , это просто набор Nodes с именами других узлов, написанными на нем.

Мы отслеживаем список с помощью таких инструментов, как Current/Temp и First/Head (Buckets) в классе, который инкапсулирует эту логику. Иногда у нас есть Count, чтобы было проще узнать, сколько узлов мы отслеживаем. Хотя действительно, наиболее важной частью Linked List является First/Head корзина. Без этого мы не сможем пройти список.

Current/Temp в вашем исходном методе позволяет нам легко найти последний узел, поэтому вам не нужно просматривать список, чтобы найти его

Пример * ** 1156 тысяча сто пятьдесят пять *