（7）数据结构——循环队列（数组）实现

ArrayQueue.h

  1 /*********************************************************************
  2 *:
  3 *:          Filename: ArrayQueue.h
  4 *:
  5 *:          Author: dspeeding
  6 *:          Copyright (c) 2012, dspeeding
  7 *:
  8 *:        Created at: 2012.06.13
  9 *:     Last modified: 2012.06.13  
 10 *:             
 11 *:      Introduction: 数组队列（数据结构）的c实现(循环数组)
 12 *:                    
 13 *:
 14 *:*********************************************************************/
 15 #ifndef _ARRAYQUEUE_H_
 16 #define _ARRAYQUEUE_H_
 17 
 18 #include "ElemType.h"
 19 
 20 
 21 typedef void (*Visit)(PCElemType);
 22 
 23 /*定义数组队列结构体*/
 24 typedef struct TDefArrayQueue
 25 {
 26     PElemType        pArray;                /*指向队列的数组空间*/
 27     int             front;                /*队首指针（下标）*/
 28     int             rear;                /*队尾指针（下标）*/
 29     int             len;                /*队列长度*/
 30     int             maxSize;            /*数组长度*/
 31 }ArrayQueue;
 32 
 33 typedef ArrayQueue* PArrayQueue;
 34 typedef const ArrayQueue CArrayQueue;
 35 typedef const ArrayQueue* PCArrayQueue;
 36 
 37 
 38 
 39 /****************************************
 40  Purpose :     初始化数组队列
 41  Input   :     pQueue --队列指针
 42  Return  :     None
 43 *****************************************/
 44 int InitArrayQueue(PArrayQueue pQueue, int maxSize);
 45 
 46 
 47 /****************************************
 48  Purpose :     向队列中插入元素
 49  Input   :     pQueue --队列指针
 50             pData  --数据指针
 51  Return  :     0         --OK
 52             -1         --Fail
 53 *****************************************/
 54 int AddArrayQueue(PArrayQueue pQueue, PCElemType pData);
 55 
 56 
 57 /****************************************
 58  Purpose :     从队列中删除元素
 59  Input   :     pQueue --队列指针
 60             pData  --数据指针
 61  Return  :     0         --OK
 62             -1         --Fail
 63 *****************************************/
 64 int DelArrayQueue(PArrayQueue pQueue, PElemType pData);
 65 
 66 
 67 /****************************************
 68  Purpose :     从队列中提取元素
 69  Input   :     pQueue --队列指针
 70             pData  --数据指针
 71  Return  :     0         --OK
 72             -1         --Fail
 73 *****************************************/
 74 int PeekArrayQueue(PArrayQueue pQueue, PElemType pData);
 75 
 76 
 77 /****************************************
 78  Purpose :     判断数组队列是否为空
 79  Input   :     pQueue -- 队列指针
 80  Return  :     0       -- 为空
 81             其他   -- 非空
 82 *****************************************/
 83 int IsEmptyArrayQueue(PArrayQueue pQueue);
 84 
 85 
 86 /****************************************
 87  Purpose :     清空数组队列
 88  Input   :     pQueue -- 队列指针
 89  Return  :     0         --OK
 90             -1         --Fail
 91 *****************************************/
 92 int ClearArrayQueue(PArrayQueue pQueue);
 93 
 94 
 95 
 96 /****************************************
 97  Purpose :     打印数组队列
 98  Input   :     pQueue -- 队列指针
 99             visit  -- 函数地址
100  Return  :     None
101 *****************************************/
102 void DispalyArrayQueue(PArrayQueue pQueue, Visit visit);
103 #endif

ArrayQueue.c

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #include "ArrayQueue.h"
  5 
  6 /*************************************************************************
  7  Function:     IsFullArrayQueue()
  8  Purpose :     数组队列是否空间已满
  9  Input   :     pQueue --队列指针
 10  Return  :     0        --满
 11             其他    --没满
 12  Modify  :
 13  Remark  :
 14 **************************************************************************/
 15 int IsFullArrayQueue(PArrayQueue pQueue)
 16 {
 17     if(pQueue->len >= pQueue->maxSize)
 18     {
 19         return 0;
 20     }
 21     
 22     return -1;
 23 }
 24 
 25 /*************************************************************************
 26  Function:     AgainMallocArrayQueue()
 27  Purpose :     空间扩展为原来的2倍，原内容被自动拷贝到pQueue所指向的存储空间中
 28  Input   :     pQueue --队列指针
 29  Return  :     None
 30  Modify  :
 31  Remark  :
 32  *************************************************************************/
 33 int AgainMallocArrayQueue(PArrayQueue pQueue)
 34 {
 35     int i;
 36     PElemType pTempData;
 37     pTempData = realloc(pQueue->pArray, 2*pQueue->maxSize*sizeof(ElemType));
 38     if(!pTempData)
 39     {
 40         /*动态存储空间分配失败*/
 41         return -1;
 42     }
 43     
 44     /*指向新的队列空间*/
 45     pQueue->pArray = pTempData;
 46     
 47     /*把原队列的尾部内容后移maxSize个位置*/
 48     if(pQueue->rear != pQueue->maxSize - 1)
 49     {
 50         for(i = 0;i <= pQueue->rear;i++)
 51         {
 52             memcpy(&pQueue->pArray[i+pQueue->maxSize], &pQueue->pArray[i], sizeof(ElemType));
 53             memset(&pQueue->pArray[i], 0, sizeof(ElemType));
 54         }
 55         /*队尾指针后移maxSize个位置*/
 56         pQueue->rear += pQueue->maxSize;
 57     }
 58     pQueue->maxSize = 2 * pQueue->maxSize;
 59     
 60     return 0;
 61 }
 62 
 63 /*************************************************************************
 64  Function:     InitArrayQueue()
 65  Purpose :     初始化队列
 66  Input   :     pQueue --队列指针
 67             maxSize--队列数组最大值
 68  Return  :     0         --OK
 69             -1         --Fail
 70  Modify  :
 71  Remark  :
 72  *************************************************************************/
 73 int InitArrayQueue(PArrayQueue pQueue, int maxSize)
 74 {
 75     /*检查ms是否有效*/
 76     if(maxSize <= 0)
 77     {
 78         return -1;
 79     }
 80     
 81     pQueue->maxSize = maxSize;
 82     pQueue->pArray = malloc(maxSize * sizeof(ElemType));
 83     if(!pQueue->pArray)
 84     {
 85         /*内存分配失败*/
 86         return -1;
 87     }
 88     
 89     memset(pQueue->pArray, 0, maxSize * sizeof(ElemType));
 90     /*初始化队列为空*/
 91     pQueue->front = 0;
 92     pQueue->rear = -1;
 93     pQueue->len = 0;
 94     
 95     return 0;
 96 }
 97 
 98 /*************************************************************************
 99  Function:     AddArrayQueue()
100  Purpose :     向队列中插入元素
101  Input   :     pQueue --队列指针
102             pData  --数据指针
103  Return  :     0         --OK
104             -1         --Fail
105  Modify  :
106  Remark  :
107 **************************************************************************/
108 int AddArrayQueue(PArrayQueue pQueue, PCElemType pData)
109 {
110     /*当队列满时，进行动态分配*/
111     if(IsFullArrayQueue(pQueue) == 0)
112     {
113         if(AgainMallocArrayQueue(pQueue))
114         {
115             return -1;
116         }
117     }
118     
119     /*求出队尾的下一个位置*/
120     pQueue->rear = (pQueue->rear + 1)% pQueue->maxSize;
121     memcpy(&pQueue->pArray[pQueue->rear], pData, sizeof(ElemType));
122     pQueue->len++;
123     return 0;
124 }
125  
126 /*************************************************************************
127  Function:     DelArrayQueue()
128  Purpose :     从队列中删除元素
129  Input   :     pQueue --队列指针
130             pData  --数据指针
131  Return  :     0         --OK
132             -1         --Fail
133  Modify  :
134  Remark  :
135 **************************************************************************/
136 int DelArrayQueue(PArrayQueue pQueue, PElemType pData)
137 {
138     if(IsEmptyArrayQueue(pQueue) == 0)
139     {
140         /*队列为空*/
141         return -1;
142     }
143     
144     memcpy(pData, &pQueue->pArray[pQueue->front],sizeof(ElemType));
145     memset(&pQueue->pArray[pQueue->front], 0, sizeof(ElemType));
146     /*队首指针指向下一个位置*/
147     pQueue->front = (pQueue->front + 1) % pQueue->maxSize;
148     pQueue->len--;
149     return 0;
150 }
151 
152 /*************************************************************************
153  Function:     PeekArrayQueue()
154  Purpose :     从队列中提取元素
155  Input   :     pQueue --队列指针
156             pData  --数据指针
157  Return  :     0         --OK
158             -1         --Fail
159  Modify  :
160  Remark  :
161 **************************************************************************/
162 int PeekArrayQueue(PArrayQueue pQueue, PElemType pData)
163 {
164     if(IsEmptyArrayQueue(pQueue) == 0)
165     {
166         /*队列为空*/
167         return -1;
168     }
169     memcpy(pData, &pQueue->pArray[pQueue->front],sizeof(ElemType));
170 }
171 
172 /*************************************************************************
173  Function:     IsEmptyArrayQueue()
174  Purpose :     判断数组队列是否为空
175  Input   :     pQueue -- 队列指针
176  Return  :     0       -- 为空
177             其他   -- 非空
178  Modify  :
179  Remark  :
180 **************************************************************************/
181 int IsEmptyArrayQueue(PArrayQueue pQueue)
182 {
183     if(pQueue->len == 0)
184     {
185         return 0;
186     }
187     else
188     {
189         return -1;
190     }
191 }
192 
193 /*************************************************************************
194  Function:     ClearArrayQueue()
195  Purpose :     清空数组队列
196  Input   :     pQueue -- 队列指针
197  Return  :     0         --OK
198             -1         --Fail
199  Modify  :
200  Remark  :
201 **************************************************************************/
202 int ClearArrayQueue(PArrayQueue pQueue)
203 {
204     if(pQueue->pArray != NULL)
205     {    
206         free(pQueue->pArray);
207         pQueue->pArray = NULL;
208         pQueue->front = 0;
209         pQueue->rear = -1;
210         pQueue->maxSize = 0;
211         pQueue->len = 0;
212         return 0;
213     }
214     return -1;
215 }
216 
217 /*************************************************************************
218  Function:     DispalyArrayQueue()
219  Purpose :     打印数组队列
220  Input   :     pQueue -- 队列指针
221             visit  -- 函数地址
222  Return  :     None
223  Modify  :
224  Remark  :
225 **************************************************************************/
226 void DispalyArrayQueue(PArrayQueue pQueue, Visit visit)
227 {
228     int i;
229     for(i=0;i<pQueue->maxSize;i++)
230     {
231         visit(&(pQueue->pArray[i]));
232     }
233     printf("\n");
234 }

ElemType.h

 1 #ifndef _ELEMTYPE_H_
 2 #define _ELEMTYPE_H_
 3 
 4 /*定义需要的数据类型，这里可以是基本数据类型，也可以是结构体数据类型，
 5   结构体中最好不要使用指针，使用结构体时请包含相关头文件*/
 6 typedef struct TDefStudent
 7 {
 8     int     nStuId;
 9     char     szStuName[20];
10 }Stu;
11 
12 typedef Stu* PStu;
13 typedef const Stu CStu;
14 typedef const Stu* PCStu;
15   
16   
17 typedef Stu ElemType;
18 typedef ElemType* PElemType;
19 typedef const ElemType* PCElemType;
20 
21 
22 /****************************************
23  Purpose :     打印数据
24  Input   :     pVal --要被打印的数据
25  Return  :     None
26 *****************************************/
27  void visit(PCElemType pVal);
28 
29 #endif

ElemType.c

 1 #include <stdio.h>
 2 #include "ElemType.h"
 3 /*************************************************************************
 4  Purpose :     打印输出数据
 5  Input   :     pVal --要被打印的数据
 6  Return  :     None
 7  Modify  :
 8  Remark  :
 9  *************************************************************************/
10  void visit(PCElemType pVal)
11  {
12     printf("[%d],[%s]  ", pVal->nStuId, pVal->szStuName);
13  }

Testmain.c

 1 #include <stdio.h>
 2 #include "ArrayQueue.h"
 3 #include "ElemType.h"
 4 
 5 int main()
 6 {
 7     ArrayQueue mQueue;
 8     ElemType a[4] = {{1,"zhangsan"}, {2,"lisi"}, {3,"wangwu"}, {4,"zhaoliu"}};
 9     int i;
10     InitArrayQueue(&mQueue, 4);
11     
12     for(i=0;i<4;i++)
13     {
14         printf("插入数据:\n");
15         if(AddArrayQueue(&mQueue, &a[i]))
16         {
17             printf("add data fail\n");
18         }
19         DispalyArrayQueue(&mQueue, visit);
20     }
21     ElemType outData;
22     printf("删除数据:\n");
23     if(DelArrayQueue(&mQueue, &outData))
24     {
25         printf("del data fail\n");
26     }
27     printf("del data{[%d],[%s]}\n", outData.nStuId, outData.szStuName);
28     DispalyArrayQueue(&mQueue, visit);
29     if(DelArrayQueue(&mQueue, &outData))
30     {
31         printf("del data fail\n");
32     }
33     printf("del data{[%d],[%s]}\n", outData.nStuId, outData.szStuName);
34     
35     DispalyArrayQueue(&mQueue, visit);
36     
37     ElemType a1 = {20,"a1"};
38     ElemType a2 = {21,"a2"};
39     ElemType a3 = {22,"a3"};
40     ElemType a4 = {23,"a4"};
41     ElemType a5 = {24,"a5"};
42     if(AddArrayQueue(&mQueue, &a1))
43     {
44         printf("add data fail\n");
45     }
46     DispalyArrayQueue(&mQueue, visit);
47     if(AddArrayQueue(&mQueue, &a2))
48     {
49         printf("add data fail\n");
50     }
51     DispalyArrayQueue(&mQueue, visit);
52     if(AddArrayQueue(&mQueue, &a3))
53     {
54         printf("add data fail\n");
55     }
56     DispalyArrayQueue(&mQueue, visit);
57     if(AddArrayQueue(&mQueue, &a4))
58     {
59         printf("add data fail\n");
60     }
61     DispalyArrayQueue(&mQueue, visit);
62     if(AddArrayQueue(&mQueue, &a5))
63     {
64         printf("add data fail\n");
65     }
66     DispalyArrayQueue(&mQueue, visit);
67     
68     while(IsEmptyArrayQueue(&mQueue))
69     {
70         if(DelArrayQueue(&mQueue, &outData))
71         {
72             printf("del data fail\n");
73         }
74         printf("del data{[%d],[%s]}\n", outData.nStuId, outData.szStuName);
75     }
76     
77     ClearArrayQueue(&mQueue);
78     
79     return 0;
80 }

posted on 2013-08-16 13:32 dspeeding 阅读(576) 评论(0) 编辑收藏举报