数据结构——循环队列

（一）头文件

  1 #ifndef _LINKLIST_H_
  2 #define _LINKLIST_H_
  3 
  4 #define SUCCESS           100
  5 #define FAILURE           101
  6 
  7 typedef int DataType;
  8 
  9 struct node
 10 {
 11     DataType data;          //数据域
 12     struct node *next;      //指针域
 13 };
 14 typedef struct node Node;
 15 typedef Node *Link;
 16 
 17 int InitLink(Link *l);
 18 int EmptyLink(Link l);
 19 int InsertLink(Link l, int p, DataType e);
 20 int LinkLength(Link l);
 21 int TraverseLink(Link l, void(*p)(DataType));
 22 int GetElem(Link l, int p, DataType *e);
 23 int LocateElem(Link l, DataType e, int(*p)(DataType, DataType));
 24 int PriorElem(Link l, DataType e, int(*p)(DataType, DataType));
 25 int NextElem(Link l, DataType e, int(*p)(DataType, DataType));
 26 int ReverseLink(Link l);
 27 int DeleteLink(Link l, int p, DataType *e);
 28 int ClearLink(Link l);
 29 int DestroyLink(Link *l);
 30 #endif

（二）调用函数

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include "LinkList.h"
  4 #include <string.h>
  5 /*
  6     链表初始化
  7 */
  8 int InitLink(Link *l)
  9 {
 10     (*l) = (Link)malloc(sizeof(Node) * 1);   //给头结点分配空间
 11     if (NULL == (*l))
 12     {
 13         return FAILURE;
 14     }
 15     (*l)->next = NULL;                       //头结点下一个元素为空
 16 
 17     return SUCCESS;
 18 }
 19 
 20 /*
 21     判断链表是否为空
 22 */
 23 int EmptyLink(Link l)
 24 {
 25     return (l->next == NULL) ? SUCCESS : FAILURE;
 26 }
 27 
 28 /*
 29     向链表插入节点
 30 */
 31 int InsertLink(Link l, int p, DataType e)
 32 {
 33     Link q = l, n;
 34     int j = 1;
 35 
 36     if (NULL == l)
 37     {
 38         return FAILURE;
 39     }
 40 
 41     while (q && j < p)            //移动指针到要插入位置的前一个位置
 42     {
 43         q = q->next;
 44         j++;
 45     }
 46 
 47     if (q == NULL || j > p)      //判断插入的位置是否合法
 48     {
 49         return FAILURE;
 50     }
 51 
 52     n = (Link)malloc(sizeof(Node) * 1);
 53     if (NULL == n)
 54     {
 55         return FAILURE;
 56     }
 57 
 58     n->data = e;
 59     n->next = q->next;
 60     q->next = n;
 61 
 62     return SUCCESS;
 63 }
 64 
 65 /*
 66     链表的长度
 67 */
 68 int LinkLength(Link l)
 69 {
 70     Link q = l;
 71     int len = 0;
 72 
 73     while (q)
 74     {
 75         q = q->next;
 76         len++;
 77     }
 78 
 79     return len - 1;
 80 }
 81 
 82 /*
 83     遍历链表
 84     参数：p是函数指针，指向Visit函数
 85 */
 86 int TraverseLink(Link l, void(*p)(DataType))
 87 {
 88     Link q = l->next;
 89 
 90     while(q)
 91     {
 92         p(q->data);
 93         q = q->next;
 94     }
 95 
 96     return SUCCESS;
 97 }
 98 
 99 /*
100     获取元素
101 */
102 int GetElem(Link l, int p, DataType *e)
103 {
104     Link q = l;
105     int len = 0;
106 
107     while (q)
108     {
109         q = q->next;
110         len++;
111         if (p == len)
112         {
113             *e = q->data;
114             return SUCCESS;
115         }
116     }
117 
118     return FAILURE;
119 }
120 
121 /*
122     查找元素位置，返回元素的位置
123     参数：p是函数指针，指向Equal函数
124 */
125 int LocateElem(Link l, DataType e, int(*p)(DataType, DataType))
126 {
127     Link q = l->next;
128     int len = 1;
129 
130     while (q)
131     {
132         if (p(e, q->data))
133         {
134             return len;
135         }
136         q = q->next;
137         len++;
138     }
139 
140     return FAILURE;
141 }
142 
143 /*
144     获取元素的前驱，保存在参数e中
145 */
146 int PriorElem(Link l, DataType e, int(*p)(DataType, DataType))
147 {
148     Link q = l->next;
149 
150     if (p(e, q->data))         //第一个元素不存在前驱
151     {
152         return FAILURE;
153     }
154 
155     while (q->next)
156     {
157         if (p(q->next->data, e))
158         {
159             return q->data;
160         }
161         q = q->next;
162     }
163 
164     return FAILURE;
165 }
166 
167 /*
168     获取元素后继，保存在参数e中
169 */
170 int NextElem(Link l, DataType e, int(*p)(DataType, DataType))
171 {
172     Link q = l->next;
173 
174     while (q->next)            //最后一个元素不存在后继           
175     {
176         if (p(q->data, e))
177         {
178             return q->next->data;
179         }
180         q = q->next;
181     }
182 
183     return FAILURE;
184 }
185 
186 /*
187     链表反转
188 */
189 int ReverseLink(Link l)
190 {
191     Link q;
192 
193     if (NULL == l)
194     {
195         return FAILURE;
196     }
197 
198     Link p = l->next;
199     l->next = NULL;
200 
201     while (p)
202     {
203         q = p;
204         p = p->next;
205         q->next = l->next;
206         l->next = q;
207     }
208 
209     return SUCCESS;
210 }
211 
212 /*
213     删除链表结点，被删除元素保存在参数e中
214 */
215 int DeleteLink(Link l, int p, DataType *e)
216 {
217     Link q = l, n;
218     int j = 1;
219 
220     if (NULL == l)
221     {
222         return FAILURE;
223     }
224 
225     while (q && j < p)            //移动指针到要插入位置的前一个位置
226     {
227         q = q->next;
228         j++;
229     }
230 
231     if (q == NULL || j > p)      //判断插入的位置是否合法
232     {
233         return FAILURE;
234     }
235 
236     n = q->next;
237     q->next = n->next;
238     *e = n->data;
239     free(n);
240 
241     return SUCCESS;
242 }
243 
244 /*
245     清空链表，删除所有结点，保留头结点
246 */
247 int ClearLink(Link l)
248 {
249     Link p = l->next;
250 
251     while (p)
252     {
253         l->next = p->next;
254         free(p);
255         p = l->next;
256     }
257 
258     return SUCCESS;
259 }
260 
261 /*
262     销毁链表，即释放头结点
263 */
264 int DestroyLink(Link *l)
265 {
266     free(*l);
267     (*l) = NULL;
268 
269     return SUCCESS;
270 }
        

（三）主函数

  1 #include <stdio.h>
  2 #include "LinkList.h"
  3 
  4 void visit(DataType e)
  5 {
  6     printf("%d ", e);
  7 }
  8 
  9 int Equal(DataType a, DataType b)
 10 {
 11     return (a == b) ? 1 : 0;
 12 }
 13 
 14 int main()
 15 {
 16     int ret, i, p;
 17     Link link;
 18     DataType e;
 19 
 20     ret = InitLink(&link);
 21     if (SUCCESS == ret)
 22     {
 23         printf("Init Success!\n");
 24     }
 25     else
 26     {
 27         printf("Init Failure!\n");
 28     }
 29 
 30 /*  ret = EmptyLink(link);
 31     if (SUCCESS == ret)
 32     {
 33         printf("Link is Empty!\n");
 34     }
 35     else
 36     {
 37         printf("Link is't Empty!\n");
 38     }*/
 39 
 40     for (i = 0; i < 5; i++)
 41     {
 42         ret = InsertLink(link, i + 1, i + 1);
 43         if (FAILURE == ret)
 44         {
 45             printf("Insert %d Failure!\n", i + 1);
 46         }
 47         else
 48         {
 49             printf("Insert %d Success!\n", i + 1);
 50         }
 51     }
 52 
 53 /*  ret = EmptyLink(link);
 54     if (SUCCESS == ret)
 55     {
 56         printf("Link is Empty!\n");
 57     }
 58     else
 59     {
 60         printf("Link is't Empty!\n");
 61     }
 62 
 63     printf("Length is %d!\n", LinkLength(link));
 64 */
 65     ret = TraverseLink(link, visit);
 66     if (FAILURE == ret)
 67     {
 68         printf("Traverse Failure!\n");
 69     }
 70     else
 71     {
 72         printf("\nTraverse Success!\n");
 73     }
 74 
 75     p = 5;
 76     ret = GetElem(link, p, &e);
 77     if (FAILURE == ret)
 78     {
 79         printf("Get %dth Elem Failure!\n", p);
 80     }
 81     else
 82     {
 83         printf("%dth Elem is %d\n", p, e);
 84     }
 85 
 86     e = 10;
 87     ret = LocateElem(link, e, Equal);
 88     if (FAILURE == ret)
 89     {
 90         printf("Element %d is't exist!\n", e);
 91     }
 92     else
 93     {
 94         printf("%d is %dth Element!\n", e, ret);
 95     }
 96 
 97     /*e = 10;
 98     ret = PriorElem(link, e, Equal);
 99     if (FAILURE == ret)
100     {
101         printf("%d has no prior!\n",e);
102     }
103     else
104     {
105         printf("%d Prior is %d\n", e, ret);
106     }
107 
108     e = 15;
109     ret = NextElem(link, e, Equal);
110     if (FAILURE == ret)
111     {
112         printf("%d has no next!\n",e);
113     }
114     else
115     {
116         printf("%d Next is %d\n", e, ret);
117     }
118 
119     ret = ReverseLink(link);
120     if (SUCCESS == ret)
121     {
122         printf("Reverse Success!\n");
123     }
124 
125     ret = TraverseLink(link, visit);
126     if (FAILURE == ret)
127     {
128         printf("Traverse Failure!\n");
129     }
130     else
131     {
132         printf("\nTraverse Success!\n");
133     }
134 
135     p = 3;
136     ret = DeleteLink(link, p, &e);
137     if (SUCCESS == ret)
138     {
139         printf("Delete %dth Success!\n", p);
140     }
141     else
142     {
143         printf("Delete %dth Failure!\n", p);
144     }
145 
146     ret = TraverseLink(link, visit);
147     if (FAILURE == ret)
148     {
149         printf("Traverse Failure!\n");
150     }
151     else
152     {
153         printf("\nTraverse Success!\n");
154     }
155 
156     ret = ClearLink(link);
157     if (SUCCESS == ret)
158     {
159         printf("Clear Success!\n");
160     }
161     else
162     {
163         printf("Clear Failure!\n");
164     }
165 
166     ret = TraverseLink(link, visit);
167     if (FAILURE == ret)
168     {
169         printf("Traverse Failure!\n");
170     }
171     else
172     {
173         printf("\nTraverse Success!\n");
174     }
175 
176     ret = DestroyLink(&link);
177     if (FAILURE == ret)
178     {
179         printf("Destroy Failure!\n");
180     }
181     else
182     {
183         printf("Destroy Success!\n");
184     }
185 
186         ret = InsertLink(link, 1, 3);
187         if (FAILURE == ret)
188         {
189             printf("Insert %d Failure!\n", i + 1);
190         }
191         else
192         {
193             printf("Insert %d Success!\n", i + 1);
194         }*/
195 
196     return 0;
197 }