用c# 实现顺序表

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Text;
   
4. 
   
5. namespace ListDS
   
6. {
   
7.     /// <summary>
   
8.     /// 顺序表
   
9.     /// </summary>
   
10.     /// <typeparam name="T"></typeparam>
    
11.     public  class SeqListDS<T> : IListDS<T>
    
12.     {
    
13.         /// <summary>
    
14.         /// 最大容量。
    
15.         /// </summary>
    
16.         private int maxsize;
    
17.         /// <summary>
    
18.         /// 数据。
    
19.         /// </summary>
    
20.         private T[] date;
    
21.         /// <summary>
    
22.         /// 最后的位置。
    
23.         /// </summary>
    
24.         private int last;
    
25.         /// <summary>
    
26.         /// 索引器。
    
27.         /// </summary>
    
28.         /// <param name="index">位置</param>
    
29.         /// <returns></returns>
    
30.         public T this[int index]
    
31.         {
    
32.             get
    
33.             {
    
34.                 return date[index];
    
35.             }
    
36.             set
    
37.             {
    
38.                 date[index] = value;
    
39.             }
    
40.         }
    
41.         /// <summary>
    
42.         /// 最后一个数据的位置属性。
    
43.         /// </summary>
    
44.         public int Last
    
45.         {
    
46.             get
    
47.             {
    
48.                 return last;
    
49.             }
    
50.             set
    
51.             {
    
52.                 last = value;
    
53.             }
    
54.         }
    
55.         /// <summary>
    
56.         /// 容量属性。
    
57.         /// </summary>
    
58.         public int MaxSize
    
59.         {
    
60.             get
    
61.             {
    
62.                 return maxsize;
    
63.             }
    
64.             set
    
65.             {
    
66.                 maxsize = value;
    
67.             }
    
68.         }
    
69.         /// <summary>
    
70.         /// 构造函数。
    
71.         /// </summary>
    
72.         /// <param name="size"></param>
    
73.         public SeqListDS(int size)
    
74.         {
    
75.             maxsize = size;
    
76.             date = new T[size];
    
77.             last = -1;
    
78.         }
    
79.         /// <summary>
    
80.         /// 长度。
    
81.         /// </summary>
    
82.         /// <returns></returns>
    
83.         public int GetLength()
    
84.         {
    
85.             return last + 1;
    
86.         }
    
87.         /// <summary>
    
88.         /// 清空。
    
89.         /// </summary>
    
90.         public void Clear()
    
91.         {
    
92.             last = -1;
    
93.         }
    
94.         /// <summary>
    
95.         /// 是否为空。
    
96.         /// </summary>
    
97.         /// <returns></returns>
    
98.         public bool IsEmpty()
    
99.         {
    
100.             if (last == -1)
     
101.             {
     
102.                 return true;
     
103.             }
     
104.             else
     
105.             {
     
106.                 return false;
     
107.             }
     
108.         }
     
109.         /// <summary>
     
110.         /// 是否为空。
     
111.         /// </summary>
     
112.         /// <returns></returns>
     
113.         public bool IsFull()
     
114.         {
     
115.             if (last == maxsize - 1)
     
116.             {
     
117.                 return true;
     
118.             }
     
119.             else
     
120.             {
     
121.                 return false;
     
122.             }
     
123.         }
     
124.         /// <summary>
     
125.         /// 附加元素。
     
126.         /// </summary>
     
127.         /// <param name="item">要加的元素</param>
     
128.         public void Append(T item)
     
129.         {
     
130.             if (!(this.IsFull()))
     
131.             {
     
132.                 date[++last] = item;
     
133.             }
     
134.             else
     
135.             {
     
136.                 Console.WriteLine("顺序表已满!");
     
137.                 return;
     
138.             }
     
139. 
     
140.         }
     
141.         /// <summary>
     
142.         /// 插入元素。
     
143.         /// </summary>
     
144.         /// <param name="item">元素</param>
     
145.         /// <param name="i">位置</param>
     
146.         public void InSert(T item, int i)
     
147.         {
     
148.             if (!this.IsFull())
     
149.             {
     
150.                 last++;
     
151.                 for (int j = last; j >= i; )
     
152.                 {
     
153.                     date[j] = date[--j];
     
154.                 }
     
155.                 date[i - 1] = item;
     
156.             }
     
157.             else
     
158.             {
     
159.                 Console.WriteLine("顺序表已满!");
     
160.                 return;
     
161.             }
     
162.         }
     
163.         /// <summary>
     
164.         /// 删除。
     
165.         /// </summary>
     
166.         /// <param name="i"></param>
     
167.         /// <returns></returns>
     
168.         public T Delete(int i)
     
169.         {
     
170.             T item = default(T);
     
171.             if (this.IsEmpty())
     
172.             {
     
173.                 Console.WriteLine("顺序表是空的！");
     
174.                 return item;
     
175.             }
     
176.             if (i > last + 1 || i < 1)
     
177.             {
     
178.                 Console.WriteLine("没有第{0}个元素！", i);
     
179.                 return item;
     
180.             }
     
181.             else
     
182.             {
     
183.                 item = date[i - 1];
     
184.                 for (int j = i; j <= last; j++)
     
185.                 {
     
186.                     date[j - 1] = date[j];
     
187.                 }
     
188.                 last--;
     
189.                 return item;
     
190. 
     
191.             }
     
192.         }
     
193.         /// <summary>
     
194.         /// 找元素。
     
195.         /// </summary>
     
196.         /// <param name="i"></param>
     
197.         /// <returns></returns>
     
198.         public T GetElem(int i)
     
199.         {
     
200.             T item = default(T);
     
201.             if (this.IsEmpty())
     
202.             {
     
203.                 Console.WriteLine("顺序表为空!");
     
204.                 return item;
     
205.             }
     
206.             if (i > last + 1 || i < 1)
     
207.             {
     
208.                 Console.WriteLine("位置不对!");
     
209.                 return item;
     
210.             }
     
211.             else
     
212.             {
     
213.                 item = date[i - 1];
     
214.                 return item;
     
215.             }
     
216. 
     
217.         }
     
218.         /// <summary>
     
219.         /// 找位置。
     
220.         /// </summary>
     
221.         /// <param name="value"></param>
     
222.         /// <returns></returns>
     
223.         public int Locate(T value)
     
224.         {
     
225.             if (this.IsEmpty())
     
226.             {
     
227.                 Console.WriteLine("顺序表为空!");
     
228.                 return 0;
     
229.             }
     
230.             else
     
231.             {
     
232.                 for (int i = 0; i <= last; i++)
     
233.                 {
     
234.                     if (date[i].Equals(value))
     
235.                     {
     
236.                         return i;
     
237.                     }
     
238. 
     
239.                 }
     
240.                 Console.WriteLine("没{0}的元素", value.ToString());
     
241.                 return 0;
     
242.             }
     
243. 
     
244.         }
     
245.         /// <summary>
     
246.         /// 判断是否存在item元素.
     
247.         /// </summary>
     
248.         /// <param name="item">要判断的元素</param>
     
249.         /// <returns>true:存在；false：不存在</returns>
     
250.         public bool IsHas(T item)
     
251.         {
     
252.             if (this.IsEmpty())
     
253.             {
     
254.                 Console.WriteLine("顺序表为空!");
     
255.                 return false;
     
256.             }
     
257.             for (int i = 0; i < this.GetLength(); i++)
     
258.             {
     
259.                 if (date[i].Equals(item))
     
260.                 {
     
261.                     return true;
     
262.                 }
     
263.             }
     
264.             return false;
     
265.         }
     
266. 
     
267.         public void Display()
     
268.         {
     
269.             if (IsEmpty())
     
270.             {
     
271.                 Console.WriteLine("列表为空。");
     
272.                 return;
     
273.             }
     
274.             for (int i = 0; i <=this.Last; i++)
     
275.             {
     
276.                 Console.Write("{0},", this[i].ToString());
     
277.             }
     
278.             Console.WriteLine();
     
279. 
     
280.         }
     
281.     }
     
282. }
     

复制代码

继续努力 。。

学习了 啊！！！

偶惭愧地顶{:soso_e149:}