C#中的泛型链表的实现

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Collections;
7. namespace 泛型
8. {
9.     //简单链表的实现，单向(泛型)
10.     class 泛型类
11.     {
12.         public static void Main()
13.         {
14.             
15.             LinkedList<string> list = new LinkedList<string>();
17.             list.AddLast("500");
18.             list.AddLast("400");
19.             list.AddLast("300");
20.             list.AddLast("200");
22.             //使用泛型版的IEnumerable时，foreach也是类型安全的，些时不可能写 string之外的类型
23.             foreach (string i in list)
24.             {
25.                 Console.WriteLine(i);
26.             }
28.             Console.ReadLine();
29.         }
30.     }
32.     ////泛型类的定义与一般类相似，只要使用泛型类型声明，之后，这个类型就可以做为一个字段成员，或者参数类型。
33.     class LinkedListNode<T>
34.     {
35.         //项目值
36.         private T value;
37.         private LinkedListNode<T> next;
38.         private LinkedListNode<T> prev;
40.         public LinkedListNode(T value)
41.         {
42.             this.value = value;
43.         }
45.         public T Value
46.         {
47.             //只读属性
48.             get
49.             {
50.                 return this.value;
51.             }
52.         }
54.         //下一个
55.         public LinkedListNode<T> Next
56.         {
57.             get { return next; }
58.             set { next = value; }
59.         }
61.         //上一个
62.         public LinkedListNode<T> Prev
63.         {
64.             get { return prev; }
65.             set { prev = value; }
66.         }
67.     }
69.     class LinkedList<T> : IEnumerable<T>
70.     {
71.         //第一个
72.         private LinkedListNode<T> first;
73.         internal LinkedListNode<T> First
74.         {
75.             get { return first; }
76.             set { first = value; }
77.         }
79.         //最后一个
80.         private LinkedListNode<T> last;
81.         internal LinkedListNode<T> Last
82.         {
83.             get { return last; }
84.             set { last = value; }
85.         }
87.         //从后面插入
88.         public LinkedListNode<T> AddLast(T node)
89.         {
90.             LinkedListNode<T> newNode = new LinkedListNode<T>(node);
92.             if (first == null)
93.             {
94.                 //Last的引用一直要更新
95.                 first = newNode;
96.                 last = first;
97.             }
98.             else
99.             {
100.                 //把当前最后一个节点的下一个节点的引用 指向新对象
101.                 last.Next = newNode;
102.                 //更新最后一个节点
103.                 last = newNode;
104.             }
106.             return newNode;
107.         }
109.         public IEnumerator<T> GetEnumerator()
110.         {
111.             LinkedListNode<T> current = first;
113.             while (current != null)
114.             {
115.                 yield return current.Value;
116.                 //新引用指向下一个节点的地址
117.                 current = current.Next;
118.             }
120.         }
122.         IEnumerator IEnumerable.GetEnumerator()
123.         {
124.             return GetEnumerator();
125.         }
127.     }
128. }