0

Microsoft 将此作为学习泛型的冒泡排序示例。直到我到达第 76 和 77 行才有意义。这些声明是如何可能的?节点是一个类。您不必用 new 实例化它吗?您将如何优化排序?哪个部分是通用的,哪个是非通用的?

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     }
4

4 回答 4

2

C# 中的class类型可以初始化null为与声明类型兼容的值。第 76 行和第 77 行看起来像这样

Node previous = null;
Node current = head;

这里的值null是合法的。它本质上说“我没有价值”。分配 tohead也是合法的,因为head它也是 type Node。结果是两个引用headcurrent引用了相同的Node对象值。通过其中一个引用修改Node实例将对另一个引用可见。

于 2011-10-27T15:42:23.957 回答
0

该代码的第 76 行和第 77 行没有实例化任何对象。正如你所说,Node是一个类。.NET 中的类始终是引用类型,这意味着:

  1. 引用类型的变量的值是对对象的引用(或什么都没有)。
  2. 可以为引用类型的变量分配 value null,这意味着该变量不引用任何内容。
  3. 将一个引用类型的变量分配给另一个引用类型的变量会复制引用,而不是对象。
于 2011-10-27T15:47:01.047 回答
0

您分别分配previous和分配nextnullhead。这是一个赋值操作,就像其他任何操作一样。除非您实际创建对象的新实例,否则不需要使用 new。

通用部分是指任何东西T。它是在实例化类时提供的泛型类型。一个很好的例子是List<T>,它创建了一个类型对象的列表TList<string>您可以将其作为字符串List<int>列表、整数列表等的实例。

于 2011-10-27T15:41:41.367 回答
0

这些引用可能指向一个类的实例,也可能只是.null

您可以将引用分配给其他引用:

Foo f1 = new Foo();
Foo f2 = f1;
Foo f3 = null;
于 2011-10-27T15:43:35.043 回答