使用C#实现顺序队列

安哥网络

队列(Queue)是插入操作限定在表的尾部而其它操作限定在表的头部进行的线性表。把进行插入操作的表尾称为队尾(Rear)，把进行其它操作的头部称为队头(Front)。当对列中没有数据元素时称为空对列(Empty Queue)。

  

队列通常记为：Q= (a1,a2,…,an)，a1为队头元素，an为队尾元素。元素按照a1,a2,…,an的次序依次入队，出队的次序与入队相同，即a1第一个出队，an最后一个出队。所以，对列的操作是按照先进先出(First In First Out)或后进后出( Last In Last Out)的原则进行的，因此，队列又称为FIFO表或LILO表。

  

队列的常用操作有：

  

1、构造一个空队列：InitQueue()//在C#中可以使用构造函数来实现

  

2、清空队列：ClearQueue()

  

3、判断队列是否为空：IsEmpty()

  

4、判断队列是否已满：IsFull()

  

5、求队列长度：QueueLength()

  

6、入队操作：In()

  

7、出队操作：Out()

  

8、得到队头元素：GetHead()

  

下面给出一个实现顺序栈的源代码：

1. using System;
   
2. 
   
3. 
   
4. 
   
5. class Queue
   
6. 
   
7. {
   
8. 
   
9.     object[] data;  //数据元素
   
10. 
    
11.     int maxsize;    //最大容量
    
12. 
    
13.     int front;      //指向队头
    
14. 
    
15.     int rear;       //指向队尾
    
16. 
    
17. 
    
18. 
    
19.     //初始化队列
    
20. 
    
21.     public Queue(int size)
    
22. 
    
23.     {
    
24. 
    
25.         this.maxsize = size;
    
26. 
    
27.         data = new object[size];
    
28. 
    
29.         front = rear = -1;
    
30. 
    
31.     }
    
32. 
    
33.     //最大容量属性
    
34. 
    
35.     public int MaxSize
    
36. 
    
37.     {
    
38. 
    
39.         get
    
40. 
    
41.         {
    
42. 
    
43.             return this.maxsize;
    
44. 
    
45.         }
    
46. 
    
47.         set
    
48. 
    
49.         {
    
50. 
    
51.             this.maxsize = value;
    
52. 
    
53.         }
    
54. 
    
55.     }
    
56. 
    
57.     //队尾属性
    
58. 
    
59.     public int Rear
    
60. 
    
61.     {
    
62. 
    
63.         get
    
64. 
    
65.         {
    
66. 
    
67.             return this.rear;
    
68. 
    
69.         }
    
70. 
    
71.     }
    
72. 
    
73.     //队头属性
    
74. 
    
75.     public int Front
    
76. 
    
77.     {
    
78. 
    
79.         get
    
80. 
    
81.         {
    
82. 
    
83.             return this.front;
    
84. 
    
85.         }
    
86. 
    
87.     }
    
88. 
    
89.     //数据属性
    
90. 
    
91.     public object this[int index]
    
92. 
    
93.     {
    
94. 
    
95.         get
    
96. 
    
97.         {
    
98. 
    
99.             return data[index];
    
100. 
     
101.         }
     
102. 
     
103.     }
     
104. 
     
105.     //获得队列的长度
     
106. 
     
107.     public int GetQueueLength()
     
108. 
     
109.     {
     
110. 
     
111.         return rear-front;
     
112. 
     
113.     }
     
114. 
     
115.     //判断队列是否满
     
116. 
     
117.     public bool IsFull()
     
118. 
     
119.     {
     
120. 
     
121.         if(GetQueueLength() == maxsize)
     
122. 
     
123.             return true;
     
124. 
     
125.         else
     
126. 
     
127.             return false;
     
128. 
     
129.     }
     
130. 
     
131.     //判断队列是否为空
     
132. 
     
133.     public bool IsEmpty()
     
134. 
     
135.     {
     
136. 
     
137.         if(rear==front)
     
138. 
     
139.             return true;
     
140. 
     
141.         else
     
142. 
     
143.             return false;
     
144. 
     
145.     }
     
146. 
     
147.     //清空队列
     
148. 
     
149.     public void ClearQueue()
     
150. 
     
151.     {
     
152. 
     
153.         rear = front = -1;
     
154. 
     
155.     }
     
156. 
     
157.     //入队
     
158. 
     
159.     public void In(object e)
     
160. 
     
161.     {
     
162. 
     
163.         if(IsFull())
     
164. 
     
165.         {
     
166. 
     
167.             Console.WriteLine("队列已满！");
     
168. 
     
169.             return;
     
170. 
     
171.         }
     
172. 
     
173.         data[++rear]=e;
     
174. 
     
175.     }
     
176. 
     
177.     //出队
     
178. 
     
179.     public object Out()
     
180. 
     
181.     {
     
182. 
     
183.         if(IsEmpty())
     
184. 
     
185.         {
     
186. 
     
187.             Console.WriteLine("队列为空！");
     
188. 
     
189.             return null;
     
190. 
     
191.         }
     
192. 
     
193.         if(rear-front>0)
     
194. 
     
195.         {
     
196. 
     
197.             object tmp = data[++front];
     
198. 
     
199.             return tmp;
     
200. 
     
201.         }
     
202. 
     
203.         else
     
204. 
     
205.         {
     
206. 
     
207.             Console.WriteLine("全出队了！");
     
208. 
     
209.             ClearQueue();
     
210. 
     
211.             return null;
     
212. 
     
213.         }
     
214. 
     
215.     }
     
216. 
     
217.     //获得队头元素
     
218. 
     
219.     public object GetHead()
     
220. 
     
221.     {
     
222. 
     
223.         if(IsEmpty())
     
224. 
     
225.         {
     
226. 
     
227.             Console.WriteLine("队列为空！");
     
228. 
     
229.             return null;
     
230. 
     
231.         }
     
232. 
     
233.         return data[front+1];
     
234. 
     
235.     }
     
236. 
     
237. }
     
238. 
     
239. class Test
     
240. 
     
241. {
     
242. 
     
243.     static void Main()
     
244. 
     
245.     {
     
246. 
     
247.         Queue q = new Queue(1);
     
248. 
     
249.         int rdNum;
     
250. 
     
251.         Random rd = new Random();
     
252. 
     
253.         while(!q.IsFull())
     
254. 
     
255.         {
     
256. 
     
257.             rdNum = rd.Next(10,100);
     
258. 
     
259.             q.In(rdNum);
     
260. 
     
261.             Console.WriteLine("{0}入队,队列元素个数：{1}",rdNum,q.GetQueueLength());
     
262. 
     
263.            
     
264. 
     
265.         }
     
266. 
     
267.         Console.WriteLine("***************************");
     
268. 
     
269.         while(!q.IsEmpty())
     
270. 
     
271.         {
     
272. 
     
273.             Console.WriteLine("{0}出队,队列元素个数：{1}",q.Out(),q.GetQueueLength());
     
274. 
     
275.         }      
     
276. 
     
277.     }
     
278. 
     
279. }

复制代码

运行结果如下：

  

本文转载自：http://blog.163.com/fujl_2008/bl ... 107200810975036509/