c# 单链表实现 简单示例（可复制直接运行）

最近学习数据结构，发现c# 其实和c 的链表的实现差不多的

下面是一段可直接运行的代码

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 using System.Threading;
  5 
  6 namespace SingleLinkedList
  7 {
  8     class Program
  9     {
 10         static void Main(string[] args)
 11         {
 12 
 13             //实例调用
 14             LinkList<int> list = new LinkList<int>();
 15             for (var i = 0; i < 10; i++)
 16             {
 17                 list.Append(i);                
 18             }
 19             Node<int> node = list.Head;
 20             while(node.Next!=null)
 21             {
 22                 Console.WriteLine(node.Data);
 23                 node = node.Next;
 24                 Thread.Sleep(1000);
 25             }
 26             Console.WriteLine(node.Data);
 27             Console.ReadLine();
 28         }
 29     }
 30     //定义单链表的结点
 31     //结点存储数据和下一个结点的地址(引用).这里用一个类表示.
 32     public class Node<T>
 33     {
 34         private T data;  //数据
 35         private Node<T> next; //引用
 36 
 37         //构造器
 38         public Node(T val, Node<T> p)
 39         {
 40             data = val;
 41             next = p;
 42         }
 43 
 44         //构造器2
 45         public Node(Node<T> p)
 46         {
 47             next = p;
 48         }
 49 
 50         //构造器3
 51         public Node(T val)
 52         {
 53             data = val;
 54             next = null;
 55         }
 56 
 57         //构造器4
 58         public Node()
 59         {
 60             data = default(T);
 61             next = null;
 62         }
 63 
 64         //数据域属性
 65         public T Data
 66         {
 67             get
 68             {
 69                 return data;
 70             }
 71             set
 72             {
 73                 data = value;
 74             }
 75         }
 76 
 77         //引用域属性
 78         public Node<T> Next
 79         {
 80             get { return next; }
 81             set { next = value; }
 82         }
 83     }
 84 
 85 
 86 
 87     //单链表类--定义操作结点的一些方法(如删除, 插入等).
 88     //IList<T>是.net自带的一个接口. 这里实现了这个接口.
 89     public class LinkList<T> 
 90     {
 91         private Node<T> head;  //单链表的头引用
 92 
 93         //头引用 属性
 94         public Node<T> Head
 95         {
 96             get { return head; }
 97             set { head = value; }
 98         }
 99 
100         //构造器
101         public LinkList()
102         {
103             head = null;
104         }
105 
106         ///<summary>
107         ///求单链表的长度
108         ///需要从表头开始, 一个结点一个结点遍历,直到表的末尾.
109         ///</summary>
110 
111         public int GetLength()
112         {
113             Node<T> p = head;
114 
115             int len = 0;
116             while (p != null)
117             {
118                 ++len;
119                 p = p.Next;
120             }
121 
122             return len;
123         }
124 
125         ///<summary>
126         /// 清空单链表
127         /// head=null即可.
128         /// 单链表清空后,原来结点所占用的空间不会一直保留,
129         /// 而由垃圾回收器进行回收.
130         ///</summary>
131         public void Clear()
132         {
133             head = null;
134         }
135 
136         ///<summary>
137         /// 判断单链表是否为空
138         /// head==null,即为空
139         ///</summary>
140         public bool IsEmpty()
141         {
142             if (head == null)
143             {
144                 return true;
145             }
146             else
147             {
148                 return false;
149             }
150         }
151 
152         ///<summary>
153         ///附加操作
154         ///在单链表的末尾添加新元素
155         /// </summary>
156         public void Append(T item)
157         {
158             Node<T> q = new Node<T>(item);
159             Node<T> p = new Node<T>();
160 
161             if (head == null)
162             {
163                 head = q;
164                 return;
165             }
166 
167             p = head;
168             while (p.Next != null)
169             {
170                 p = p.Next;
171             }
172 
173             p.Next = q;
174         }
175 
176         //在单链表的第 i 个结点位置前插入一个值为 item 的结点.
177         public void Insert(T item, int i)
178         {
179             if (IsEmpty() || i < 1)
180             {
181                 Console.WriteLine("List is empty or Position is error!");
182                 return;
183             }
184 
185             //就一个head元素.(插入到head前即可)
186             if (i == 1)
187             {
188                 Node<T> q = new Node<T>(item);
189                 q.Next = head;
190                 return;
191             }
192 
193             //非head(中间某一元素前插入P)
194             Node<T> p = head;
195             Node<T> r = new Node<T>();
196             int j = 1;
197 
198             while (p.Next != null && j < i)
199             {
200                 r = p;
201                 p = p.Next;
202                 ++j;
203             }
204 
205             if (j == i)
206             {
207                 Node<T> q = new Node<T>(item);
208                 q.Next = p;
209                 r.Next = q;
210             }
211 
212         }
213 
214         //在单链表的第 i 个结点的位置后插入一个值为 item的结点.
215         public void InsertPost(T item, int i)
216         {
217             if (IsEmpty() || i < 1)
218             {
219                 Console.WriteLine("List is empty or Position is error!");
220                 return;
221             }
222 
223             if (i == 1)
224             {
225                 Node<T> q = new Node<T>(item);
226                 q.Next = head.Next;
227                 head.Next = q;
228                 return;
229             }
230 
231             Node<T> p = head;
232             int j = 1;
233 
234             while (p != null && j < i)
235             {
236                 p = p.Next;
237                 ++j;
238             }
239 
240             if (j == i)
241             {
242                 Node<T> q = new Node<T>(item);
243                 q.Next = p.Next;
244                 p.Next = q;
245             }
246         }
247 
248         //删除单链表的第 i 个结点
249         public T Delete(int i)
250         {
251             if (IsEmpty() || i < 0)
252             {
253                 Console.WriteLine("Link is empty or Position is error!");
254                 return default(T);
255             }
256 
257             Node<T> q = new Node<T>();
258             if (i == 1)
259             {
260                 q = head;
261                 head = head.Next;
262                 return q.Data;
263             }
264 
265             Node<T> p = head;
266             int j = 1;
267 
268             //从头一直找到 i 所在的位置
269             //条件是: (1).单链表没有到末尾,
270             //(2).还没有到 i 所在的位置 ( j< i).
271             while (p.Next != null && j < i)
272             {
273                 ++j;
274                 q = p;
275                 p = p.Next;
276             }
277 
278             if (j == i)
279             {
280                 q.Next = p.Next;
281                 return p.Data;
282             }
283             else
284             {
285                 Console.WriteLine("The item node is not exist!");
286                 return default(T);
287             }
288         }
289 
290         //获得单链表的第 i 个数据元素
291         public T GetElem(int i)
292         {
293             if (IsEmpty())
294             {
295                 Console.WriteLine("List is empty!");
296                 return default(T);
297             }
298 
299             Node<T> p = new Node<T>();
300             p = head;
301             int j = 1;
302 
303             while (p.Next != null & j < i)
304             {
305                 ++j;
306                 p = p.Next;
307             }
308 
309             if (j == i)
310             {
311                 return p.Data;  //找到了.
312             }
313             else
314             {
315                 Console.WriteLine("The item node is not exist!");
316                 return default(T);
317             }
318         }
319 
320         ///<summary>
321         ///在单链表中查找值为 value 的结点
322         ///</summary>
323         public int Locate(T value)
324         {
325             if (IsEmpty())
326             {
327                 Console.WriteLine("List is Empty!");
328                 return -1;
329             }
330 
331             Node<T> p = new Node<T>();
332             p = head;
333             int i = 1;
334             while (!p.Data.Equals(value) && p.Next != null)
335             {
336                 p = p.Next;
337                 ++i;
338             }
339 
340             return i;
341         }
342     }
343 }

 

转载于:https://www.cnblogs.com/sclgxlt/p/3726194.html