不定长顺序表的数据结构以及方法的定义

#ifndef _SEQ_LIST_H_
#define _SEQ_LIST_H_

#include <stdlib.h>


typedef int elem_type;

typedef struct _SEQ_LIST
{
elem_type *data; //指针指向顺序堆空间
int len; //顺序表中有len个元素
int total; //顺序表总大小
}SEQ_LIST;

#define ERROR -1


SEQ_LIST *init_seq_list(int size);
bool destory_seq_list(SEQ_LIST *p);

bool insert_tail(SEQ_LIST *p, elem_type e);
bool insert_head(SEQ_LIST *p, elem_type e);
bool insert(SEQ_LIST *p,int pos, elem_type e);
bool is_full(SEQ_LIST *p);
void pfunc(void *p);
//##########################//
bool clear_seq_list(SEQ_LIST *p);
bool is_empty(SEQ_LIST *p);
int get_length(SEQ_LIST *p);

bool del_tail(SEQ_LIST *p, elem_type *e);
bool del_head(SEQ_LIST *p, elem_type *e);

bool get(SEQ_LIST *p, int pos, elem_type *e);
bool put(SEQ_LIST *p, int pos, elem_type e);

bool del(SEQ_LIST *p,int pos, elem_type *e);

////

int search(SEQ_LIST *p,elem_type e);///
bool show(SEQ_LIST *p, void (*pfunc)(void *));


////

SEQ_LIST *clone(SEQ_LIST *p);

bool remove_range(SEQ_LIST *p, int start, int end);

SEQ_LIST *sub_seq_list(SEQ_LIST *p, int start ,int end);

SEQ_LIST *insert_elem(SEQ_LIST *p,elem_type *e);
SEQ_LIST *reverse(SEQ_LIST *p);
SEQ_LIST *del_repeat_elem(SEQ_LIST *p,SEQ_LIST *s);
SEQ_LIST *combine(SEQ_LIST *p,SEQ_LIST *s,SEQ_LIST *c);
SEQ_LIST *combine_ea(SEQ_LIST *p,SEQ_LIST *s);
#endif

 

  1 #include"SEQ_LIST.h"
  2 
  3 #include <stdlib.h>
  4 #include <stdio.h>
  5 int e = 0;
  6 static bool inc(SEQ_LIST *p)//内部函数，本文件内可见
  7 {
  8     if(p == NULL)
  9     {
 10         return false;
 11     }
 12     //
 13     printf("%d-%d\n",p->total,p->total*2);
 14     p->data = (elem_type *)realloc(p->data,p->total*2*sizeof(elem_type));//1024-int
 15     p->total = 2*p->total;
 16 
 17     return true;
 18 }
 19 
 20 SEQ_LIST *init_seq_list(int size)
 21 {
 22     SEQ_LIST *p = (SEQ_LIST *)malloc(sizeof(SEQ_LIST) * 1);
 23     if (p == NULL)
 24     {
 25         return NULL;
 26     }
 27     p->data = (elem_type *)malloc(sizeof(elem_type) * size);
 28     if (p->data == NULL)
 29     {
 30         return NULL;
 31     }
 32 
 33     p->len = 0;
 34     p->total = size;
 35 
 36     return p;
 37 }
 38 /*
 39 bool init_seq_list(SEQ_LIST *s1,int m)
 40 {
 41     if(s1==NULL)
 42     {
 43         return false;
 44     }
 45    elem_type *p = (elem_type *)malloc(sizeof(elem_type)* m);
 46     p = s1->data;
 47     s1->len = 0;
 48    return true;
 49 
 50 }*/
 51 
 52 bool destory_seq_list(SEQ_LIST *p)
 53 {
 54     if(p==NULL)
 55     {
 56         return false;
 57     }
 58     free(p->data);
 59     free(p);
 60     return true;
 61 }
 62 
 63 bool clear_seq_list(SEQ_LIST *p)
 64 {
 65     if(p == NULL)
 66     {
 67         return false;
 68     }
 69     p->len = 0;
 70     return true;
 71 
 72 }
 73 
 74 bool is_full(SEQ_LIST *p)
 75 {
 76     if(p==NULL)
 77     {
 78         return false;
 79     }
 80     
 81     return p->len == p->total ;
 82 
 83 }
 84 
 85 bool is_empty(SEQ_LIST *p)
 86 {
 87     if (p == NULL)
 88     {
 89         return false;
 90     }
 91     
 92     return p->len == 0;
 93 
 94 }
 95 
 96 int get_length(SEQ_LIST *p)
 97 {
 98     if(p==NULL)
 99     {
100         return false;
101     }
102     return p->len ;
103 }
104 
105 bool insert_tail(SEQ_LIST *p, elem_type e)
106 {
107     if(p==NULL)
108     {
109         return false;
110     }
111     if(is_full(p))
112     {
113       inc(p);
114       printf("增加空间成功\n");
115     }
116     p->data[p->len ++] = e;
117     return true;
118 
119 }
120 
121 bool insert_head(SEQ_LIST *p, elem_type e)
122 {
123     if(p==NULL)
124     {
125         return false;
126     }
127     if(is_full(p))
128     {
129         inc(p);
130     }
131     p->len ++;
132     for(int i =p->len;i>0;i--)
133     {
134         p->data[i] = p->data[i-1];
135     }
136     p->data[0] = e;
137     return true;
138 }
139 
140 bool insert(SEQ_LIST *p,int pos, elem_type e)
141 {
142     if(p==NULL)
143     {
144         return false;
145     }
146     if(is_full(p))
147     {
148         inc(p);
149     }
150     
151     for(int i = p->len -1;i>=pos;i--)
152     {
153         p->data [i] = p->data[i-1];
154     }
155     p->data [pos] = e;
156     return true;
157 
158 }
159 
160 bool del_tail(SEQ_LIST *p, elem_type *e)
161 {
162     if(p==NULL)
163     {
164         return false;
165     }
166     if(is_empty(p))
167     {
168         return false;
169     }
170     *e = p->data[--p->len];
171     return true;
172 }
173 bool del_head(SEQ_LIST *p, elem_type *e)
174 {
175     if(p==NULL)
176     {
177         return false;
178     }
179     if(is_empty(p))
180     {
181         return false;
182     }
183     *e = p->data[0];
184     for(int i = 0;i<p->data [p->len];i++)
185     {
186         p->data [i] = p->data[i+1];
187     }
188     p->len --;
189     return true;
190 }
191 
192 bool get(SEQ_LIST *p, int pos, elem_type *e)
193 {
194     if(p==NULL)
195     {
196         return false;
197     }
198     if(!(pos>=0 && pos<=p->len ))
199     {
200         return false;
201     }
202     *e = p->data [pos];
203     return true;
204 
205         
206 }
207 bool put(SEQ_LIST *p, int pos, elem_type *e)
208 {
209     if(p==NULL)
210     {
211         return false;
212     }
213     if(!(pos>=0 && pos<=p->len ))
214     {
215         return false;
216     }
217     p->data [pos] = *e;
218     return true;
219 
220 }
221 
222 bool del(SEQ_LIST *p,int pos, elem_type *e)
223 {
224     if(p==NULL)
225     {
226         return false;
227     }
228     if (is_empty(p))
229     {
230         return false;
231     }
232     *e = p->data [pos];
233     for(int i = pos;i<p->len ;i++)
234     {
235         p->data [i] = p->data [i+1]; 
236     }
237     p->len --;
238     return true;
239 
240 
241 }
242 
243 int search(SEQ_LIST *p,elem_type e)
244 {
245     if(p==NULL)
246     {
247         return ERROR;
248     }
249     if(is_empty(p))
250     {
251         return ERROR;
252     }
253     for(int i = 0;i<p->len ;i++)
254     {
255         if(p->data[i] == e)
256         {
257             return i;
258         
259         }
260     }
261 }
262 
263 
264 bool show(SEQ_LIST *p, void (*pfunc)(void *))
265 {
266     if(p==NULL)
267     {
268         return false;
269     }
270     if(is_empty(p))
271     {
272         return false;
273     }
274    
275     for (int i=0;i<p->len;i++)
276     {
277         pfunc(&p->data[i]);
278     }
279     printf("\n");
280     printf("%d %d\n",p->len ,p->total );
281     return true;
282 
283 }
284 
285 bool sort(SEQ_LIST *p)
286 {
287     if(p == NULL)
288     {
289         return false;
290     }
291     if(is_empty(p))
292     {
293         return false;
294     }
295 
296     elem_type tmp = 0;
297     for(int i = 0;i< p->len-1;i++)
298     {
299         for(int j=0;j<p->len -1-i;j++)
300         {
301             if(p->data[j]>p->data[j+1])
302             {
303                 tmp = p->data[j];
304                 p->data[i] = p->data[i+1];
305                 p->data[i+1] = tmp;
306             }
307 
308         }
309           
310     }
311     return true ;
312 }
313 
314 SEQ_LIST *clone(SEQ_LIST *p)
315 {
316     if(p==NULL)
317     {
318         return NULL;
319     }
320     
321    SEQ_LIST *s = init_seq_list(p->total);
322    s->len = 0;
323     if(is_empty(p))
324     {
325         return s;
326     }
327     
328     for(int i= 0;i<p->len ;i++)
329    {
330        s->data[i] = p->data[i];
331        s->len++;
332    }
333    return s;
334 
335 }
336 
337 bool remove_range(SEQ_LIST *p, int start, int end)
338 {
339     if(p=NULL)
340     {
341         return false;
342     }
343     if(is_empty(p))
344     {
345         return false;
346     }
347     
348     for(int i=start;i<end;i++)
349     {
350         del(p,i,&e);
351 
352     }
353     return true;
354 }
355 
356 SEQ_LIST *sub_seq_list(SEQ_LIST *p, int start ,int end)
357 {
358     if(p==NULL)
359     {
360         return NULL;
361     }
362     if(is_empty(p))
363     {
364         return NULL;
365     }
366    SEQ_LIST *s = init_seq_list(end - start);
367    p->len = 0;
368    for(int i=start,j=0;i<=end,j<(end - start);i++,j++)
369    {
370       s->data[j] =  p->data[start];
371       s->len ++;
372    }
373    return s;
374 
375     
376 }
377 
378 
379 //设顺序表va中的数据元素递增有序。
380 //试写一算法，将x插入到顺序表的适当位置上，以保持该表的有序性。
381 SEQ_LIST *insert_elem(SEQ_LIST *p,elem_type *e)
382 {
383     if(p==NULL)
384     {
385         return NULL;
386     }
387     if(is_empty(p))
388     {
389         return NULL;
390     }
391     if(is_full(p))
392     {
393         inc(p);
394     }
395     int rs = 0;
396     for(int i =0;i<p->len ;i++)
397     {
398         if(*e >= p->data[i] && *e <= p->data[i+1])
399         {
400               rs = i;
401         }
402     }
403     for(int j = p->len -1;j >= rs;j--)
404     {
405          p->data[j+1] = p->data[j];
406     }
407    p->data[rs] = *e;
408    return p;
409 
410 }
411 
412 //试写一算法，实现顺序表的就地逆置，
413 //即利用原表的存储空间将线性表逆置为。
414 SEQ_LIST *reverse(SEQ_LIST *p)
415 {
416     if(p==NULL)
417     {
418         return NULL;
419     }
420     if(is_empty(p))
421     {
422         return NULL;
423     }
424     elem_type tmp = 0;
425     for(int i = 0,j=p->len ;i<j;i++,j--)
426     {
427         tmp = p->data [i];
428         p->data[i] = p->data[j];
429         p->data[j] = tmp;
430         
431     }
432     return p;
433 }
434 
435 //利用顺序表的基本运算，实现如果在顺序表A中出现的元素，
436 //在顺序表B中也出现，则将A中该元素删除。
437 SEQ_LIST *del_repeat_elem(SEQ_LIST *p,SEQ_LIST *s)
438 {
439     if( p == NULL || s==NULL)
440     {
441         return NULL;
442     }
443     if(is_empty(p) || is_empty(s))
444     {
445         return p;
446     }
447     for(int i= 0;i<p->len ;i++)
448     {
449         for(int j = 0;j<s->len;s++)
450         {
451             if(p->data[i] == s->data[j])
452             {
453                 del(p,i,&e);
454             }
455         }
456     }
457     return p;
458 }
459 
460 
461 //顺序表A和顺序表B的元素都是非递减排列，
462 //利用线性表的基本运算，将它们合并成一个顺序表C，
463 //要求C也是非递减排列。例如，A=（6，11，11，23）
464 //B=（2，10，12，12，21），则C=（2，6，10，11，11，12，12，21，23）
465 
466 SEQ_LIST *combine(SEQ_LIST *p,SEQ_LIST *s)
467 {
468     if(p==NULL || s==NULL)
469     {
470         return NULL;
471     }
472     SEQ_LIST *c = init_seq_list(p->len + s->len );
473 
474     if(c==NULL)
475     {
476         return NULL;
477     }
478     for(int i = 0;i<p->len ;i++)
479     {
480         c->data[i] = p->data[i];
481     }
482     for(int j = 0 ;j<s->len ;j++)
483     {
484         c->data[j + p->len ] = s->data[j];
485     }
486     //sort(c);
487     return c;
488 }
489 
490 SEQ_LIST *combine_ea(SEQ_LIST *p,SEQ_LIST *s)
491 {
492     if(p==NULL || s==NULL )
493     {
494         return NULL;
495     }
496     SEQ_LIST *c = init_seq_list(p->len + s->len );
497     if(c==NULL)
498     {
499         return NULL;
500     }
501     for(int i = 0;i<p->len ;i++)
502     {
503         for(int j=0;j<s->len ;j++)
504         {
505             if(p->data[i]<= s->data[j])
506             {
507                 c->data[i] = p->data[i];
508                 c->len ++;
509                 break;
510             }
511             else 
512             {
513                 c->data [i] = s->data [i];
514                 c->len ++;
515             }
516 
517         }
518         return c;
519     }
520 
521 }

 

具体方法的实现