Объявление узла Generics

Question

Microsoft приводит это как пример сортировки пузыря для изучения дженериков. Это имеет смысл, пока я не доберусь до строк 76 и 77. Как эти объявления возможны? Узел это класс. Разве вы не должны создавать его с новым? Как бы вы оптимизировали сортировку? Какая часть является общей, а какая нет?

1   public class GenericList<T> : System.Collections.Generic.IEnumerable<T>
2       {
3           protected Node head;
4           protected Node current = null;
5   
6           // Nested class is also generic on T
7           protected class Node
8           {
9               public Node next;
10              private T data;  //T as private member datatype
11   
12              public Node(T t)  //T used in non-generic constructor
13              {
14                  next = null;
15                  data = t;
16              }
17  
18              public Node Next
19              {
20                  get { return next; }
21                  set { next = value; }
22              }
23  
24              public T Data  //T as return type of property
25              {
26                  get { return data; }
27                  set { data = value; }
28              }
29          }
30  
31          public GenericList()  //constructor
32          {
33              head = null;
34          }
35  
36          public void AddHead(T t)  //T as method parameter type
37          {
38              Node n = new Node(t);
39              n.Next = head;
40              head = n;
41          }
42  
43          // Implementation of the iterator
44          public System.Collections.Generic.IEnumerator<T> GetEnumerator()
45          {
46              Node current = head;
47              while (current != null)
48              {
49                  yield return current.Data;
50                  current = current.Next;
51                  
52              }
53          }
54  
55          System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
56          {
57              return GetEnumerator();
58          }
59      }
60  
61      public class SortedList<T> : GenericList<T> where T : System.IComparable<T>
62      {
63          // A simple, unoptimized sort algorithm that 
64          // orders list elements from lowest to highest:
65  
66          public void BubbleSort()
67          {
68              if (null == head || null == head.Next)
69              {
70                  return;
71              }
72              bool swapped;
73  
74              do
75              {
76                  Node previous = null;
77                  Node current = head;
78  
79                  
80                  //Console.WriteLine(previous.GetType());
81                  //Console.ReadLine();
82  
83                  swapped = false;
84                  
85                   
86                  //Debug.WriteLine(p);
87                  //Debug.WriteLine("Testing " + current.ToString());
88  
89                  while (current.next != null)
90                  {
91                      //  Because we need to call this method, the SortedList
92                      //  class is constrained on IEnumerable<T>
93                      if (current.Data.CompareTo(current.next.Data) > 0)
94                      {
95                          Node tmp = current.next;
96                          current.next = current.next.next;
97                          tmp.next = current;
98  
99                          if (previous == null)
100                         {
101                             head = tmp;
102                         }
103                         else
104                         {
105                             previous.next = tmp;
106                         }
107                         previous = tmp;
108                         swapped = true;
109                     }
110                     else
111                     {
112                         previous = current;
113                         current = current.next;
114                     }
115                 }
116             } while (swapped);
117         }
118     }

Answer 1

Тип

A class в C # может быть инициализирован с помощью null или значением, совместимым с типом объявленияСтроки 76 и 77 выглядят так:

Node previous = null;
Node current = head;

Здесь значение null допустимо.По сути, это говорит: «У меня нет ценности».Присвоение head также допустимо, поскольку head также имеет тип Node.В результате две ссылки head и current ссылаются на одно и то же Node значение объекта.Модификация экземпляра Node через одну из ссылок будет видна другой.

Answer 2

Объекты не создаются в строках 76 и 77 в этом коде.Как вы сказали, Node это класс.Классы в .NET всегда являются ссылочными типами, что означает, что:

1. Значением переменной ссылочного типа является ссылка на объект (или ничего).
2. Переменным ссылочного типа может быть присвоено значение null, что означает, что переменная не ссылается ни на что.
3. Присвоение одной переменной ссылочного типа другой переменной ссылочного типа копирует ссылку, а необъект.

Answer 3

Это ссылки , которые могут указывать на экземпляры класса или могут быть просто null.

Вы можете назначить ссылки на другие ссылки:

Foo f1 = new Foo();
Foo f2 = f1;
Foo f3 = null;

Answer 4

Вы назначаете previous и next на null и head соответственно. Это операция присваивания, как и любая другая. Вам не нужно использовать new, если вы на самом деле не создаете новый экземпляр объекта.

Общими частями являются все, что относится к T. Это универсальный тип, который предоставляется при создании экземпляра класса. Хорошим примером является List<T>, который создает список объектов типа T. Вы можете указать это как List<string> для списка строк, List<int> для списка целых и т. Д.