У меня есть только эта часть кода. Я не могу понять, является ли «следующий» другой метод ptr, или это метод random.next. Просто хочу знать, является ли это общий фрагмент кода, используемый экспертами.

Node mystery(Node ptr) {
    Node temp;
    Node previous = null;
    while (ptr != null) {
        temp = ptr.next;
        ptr.next = previous;
        previous = ptr;
        ptr = temp;
    }
    return previous;
}    


c#
0
Tech U 18 Фев 2020 в 11:31

3 ответа

Лучший ответ

Вы можете выполнить логические шаги шаг за шагом, используя отладчик или лист бумаги с ручкой.

Это похоже на связанный список. Каждый узел указывает на следующий, последняя нота указывает на null

head                    tail
+---+       +---+       +---+
|"A"| next  |"B"| next  |"C"| next
|   |------>|   |------>|   |------> null
+---+       +---+       +---+

while (ptr != null) { будет зацикливаться до тех пор, пока текущий узел не станет null

Код внутри области while - это типичный обмен. Давайте выполним это шаг за шагом, учитывая, что ptr является узлом, содержащим "A", как указано выше.

temp = ptr.next;

Теперь temp указывает на следующий узел.

 ptr
  |
  v
+---+       +---+       +---+
|"A"| next  |"B"| next  |"C"| next
|   |------>|   |------>|   |------> null
+---+       +---+       +---+
              ^
              |
            temp

ptr.next = previous;

Теперь ptr.next указывает на previous, который был инициализирован как ноль. ptr теперь не связан из списка

 ptr
  |
  v
+---+             | +---+       +---+
|"A"| next        | |"B"| next  |"C"| next
|   |------> null | |   |------>|   |------> null
+---+             | +---+       +---+
                  |   ^
                  |   |
                    temp

previous = ptr;

И ptr, и previous указывают на один и тот же узел

 ptr
  |
  v
+---+             | +---+       +---+
|"A"| next        | |"B"| next  |"C"| next
|   |------> null | |   |------>|   |------> null
+---+             | +---+       +---+
  ^               |   ^
  |               |   |
previous             temp

ptr = temp;

Теперь и ptr, и temp указывают на один и тот же узел

                     ptr
                      |
                      v
+---+             | +---+       +---+
|"A"| next        | |"B"| next  |"C"| next
|   |------> null | |   |------>|   |------> null
+---+             | +---+       +---+
  ^               |   ^
  |               |   |
previous             temp

Поскольку ptr != null имеет значение true, цикл продолжается:

temp = ptr.next;

                     ptr
                      |
                      v
+---+             | +---+       +---+
|"A"| next        | |"B"| next  |"C"| next
|   |------> null | |   |------>|   |------> null
+---+             | +---+       +---+
  ^               |               ^
  |               |               |
previous                        temp

ptr.next = previous;

Теперь следующий элемент текущего узла - это тот, который был сохранен ранее (узел "A"):

 ptr
  |
  v
+---+        +---+             | +---+
|"B"| next   |"A"| next        | |"C"| next
|   |------> |   |------> null | |   |------> null
+---+        +---+             | +---+
               ^               |   ^
               |                   |
            previous              temp

previous = ptr;

 ptr
  |
  v
+---+        +---+             | +---+
|"B"| next   |"A"| next        | |"C"| next
|   |------> |   |------> null | |   |------> null
+---+        +---+             | +---+
  ^                            |   ^
  |                                |
previous                         temp

ptr = temp;

                                  ptr
                                   |
                                   v
+---+        +---+             | +---+
|"B"| next   |"A"| next        | |"C"| next
|   |------> |   |------> null | |   |------> null
+---+        +---+             | +---+
  ^                            |   ^
  |                                |
previous                         temp

Так как ptr != null имеет значение true, цикл продолжается и применяется та же логика:

temp = ptr.next;

                                  ptr
                                   |
                                   v
+---+        +---+             | +---+
|"B"| next   |"A"| next        | |"C"| next
|   |------> |   |------> null | |   |------> null
+---+        +---+          ^  | +---+          ^
  ^                         |  |                |
  |                         |                   |
previous                    +-----------------temp

ptr.next = previous;

 ptr
  |
  v
+---+        +---+        +---+
|"C"| next   |"B"| next   |"A"| next
|   |------> |   |------> |   |------> null
+---+        +---+        +---+          ^
               ^                         |
               |                         |
           previous                     temp

previous = ptr;

 ptr
  |
  v
+---+        +---+        +---+
|"C"| next   |"B"| next   |"A"| next
|   |------> |   |------> |   |------> null
+---+        +---+        +---+         ^
  ^                                     |
  |                                     |
previous                               temp

ptr = temp;

                                       ptr
                                        |
+---+        +---+        +---+         |
|"C"| next   |"B"| next   |"A"| next    v
|   |------> |   |------> |   |------> null
+---+        +---+        +---+         ^
  ^                                     |
  |                                     |
previous                               temp

Теперь while (ptr != null) ложно. Цикл заканчивается и возвращается previous, который является новой головой .

Этот метод меняет порядок связанного списка и возвращает заголовок.

1
Cid 18 Фев 2020 в 09:32

Обычно объект Node имеет значение (например, типа int) и другое свойство, которое содержит следующий узел

public class Node{
 public int Value {get; set;}
 public Node Next {get; set;}
 //...
}

Например, здесь следующим узлом n1 является узел n2

enter image description here

Node n1=new Node(5);
Node n2=new Node(2);
n1.Next=n2;
0
Nehorai 18 Фев 2020 в 08:43

Вы код реверсирования одного связанного списка

Это просто еще один пример обращения одного связанного списка: (Подробнее см. этот).

// C# program for reversing the linked list 
using System; 

class GFG { 
    static void Main(string[] args) 
    { 
        LinkedList list = new LinkedList(); 
        list.AddNode(new LinkedList.Node(85)); 
        list.AddNode(new LinkedList.Node(15)); 
        list.AddNode(new LinkedList.Node(4)); 
        list.AddNode(new LinkedList.Node(20)); 

        // List before reversal 
        Console.WriteLine("Given linked list:"); 
        list.PrintList(); 

        // Reverse the list 
        list.ReverseList(); 

        // List after reversal 
        Console.WriteLine("Reversed linked list:"); 
        list.PrintList(); 
    } 
} 

class LinkedList { 
    Node head; 

    public class Node { 
        public int data; 
        public Node next; 

        public Node(int d) 
        { 
            data = d; 
            next = null; 
        } 
    } 

    // function to add a new node at 
    // the end of the list 
    public void AddNode(Node node) 
    { 
        if (head == null) 
            head = node; 
        else { 
            Node temp = head; 
            while (temp.next != null) { 
                temp = temp.next; 
            } 
            temp.next = node; 
        } 
    } 

    // function to reverse the list 
    public void ReverseList() 
    { 
        Node prev = null, current = head, next = null; 
        while (current != null) { 
            next = current.next; 
            current.next = prev; 
            prev = current; 
            current = next; 
        } 
        head = prev; 
    } 

    // function to print the list data 
    public void PrintList() 
    { 
        Node current = head; 
        while (current != null) { 
            Console.Write(current.data + " "); 
            current = current.next; 
        } 
        Console.WriteLine(); 
    } 
} 
0
isxaker 18 Фев 2020 в 09:37