动态数组

   

    在数据结构当中，除了链表和树的结构之外，一个重要的角色就是动态数组。它与链表不一样的地方就是内存的分配方式。创建一个链表的时候，在内存方面，是不连续分配的，而动态数组就不一样，它就要求连续分配。而两者的大概功能可以说大同小异吧。它的出现可以就是为了节省内存的使用，进行实时的修改内存的使用，避免冗余。但是如果过于频繁的使用，我个人觉得并不是一件什么好的事。

    接触过JAVA的人，对vector这个结构的相关接口应该算是比较了解的，它就是动态数组。以前自己在大学的时候用JSP写过一个简单的聊天室，对于进入聊天室的用户人数进行实时的监控就采用了vector这个结构。

1、定义接口：

1. #ifndef   _VECTOR_H
2. # define   _VECTOR_H
3. 
   
4. 
   
5. typedef   void*　value_type;
6. typedef   struct   _Vector   Vector;
7. 
   
8. 
   
9. 
   
10. typedef    void （＊VectorDestroyFunc)(value_type   data,  void*      ctx);
11. typedef    void   (*VectorForeachFunc)(value_type   data,  void* ctx);
12. 
    
13. 
    
14. typedef   enum   _Ret
15. {
16.         RET_FALSE,
17.         RET_TRUE
18. } Ret;
19. 
    
20. 
    
21. Vector*　  vector_create(VectorDestroyFunc   destroy_func);
22. value_type  vector_index_get(Vector*  thiz,  size_t  index);
23. Ret              vector_append(Vector* thiz, value_type    data);
24. Ret              vector_index_insert(Vector* thiz, value_type  data, size_t   index);
25. Ret              vector_index_delete(Vector*  thiz, size_t   index);
26. Ret              vector_destroy(Vector*  thiz);
27. void         vector_foreach(Vector* thiz, VectorvectorForeachFunc   foreach_func,  void*   ctx);
28. 
    
29. 
    
30. #endif

2、接口的具体实现：

1.   define    ADD_SIZE     100
2. 
   
3. 
   
4. 
   
5.  struct   _Vector
6. {
7.       value_type*   data;
8.       size_t   used_size;
9.       size_t    total_size;
10.       VectorDestroyFunc    destroy_func;
11. };
12. 
    
13. 
    
14.  Vector*   vector_create(VectorDestroyFunc   destroy_func)
15. {
16.        Vector*   thiz =  (Vector*)malloc(sizeof(Vector));
17. 
    
18.         thiz->data =  NULL;
19.         thiz->used_size = 0;
20.         thiz->total_size = 0;
21.         thiz->destroy_func = destroy_func;
22. 
    
23. 
    
24. 
    
25.         return thiz;
26. }
27. 
    
28. 
    
29.  value_type  vector_get_index(Vector*  thiz,  size_t index)
30. {
31.         assert(thiz != NULL   &&  index < thiz->total_size);;
32.         
33.        return   thiz->data[index];     
34. }
35. 
    
36. 
    
37. 
    
38.  static  Ret vector_set_memory(Vector*  thiz)
39. {
40.         thiz->total_size = thiz->total_size  +  ADD_SIZE;
41.          thiz->data =  (value_type*)alloc(thiz->data, thiz->total_size * sizeof(value_type));
42. 
    
43. 
    
44.          return RET_TRUE;
45. }
46. 
    
47. 
    
48. 
    
49.  Ret  vector_append(Vector*  thiz, value_type  data)
50. {
51.           assert(thiz != NULL);
52. 
    
53.           if(thiz->used_size + 1 > thiz->total_size)
54.          {
55.                  if(vector_set_memory(thiz) != RET_TRUE)
56.                         return RET_FALSE;
57.          }
58.           
59.           thiz->data[used_size] = data;
60.           thiz->total_size ++;
61.           thiz->used_size ++;
62.           
63.         return RET_TRUE;
64. }
65. 
    
66. Ret              vector_index_insert(Vector* thiz, value_type  data, size_t   index);
67. Ret              vector_index_delete(Vector*  thiz, size_t   index);
68. Ret              vector_destroy(Vector*  thiz);
69. 
    
70. 
    
71. 
    

 3、实现一下遍历函数：

1. void   vector_foreach(Vector*  thiz, VectorForeachFunc  foreach_func,  void* ctx)
2. {
3.         assert(thiz  != NULL);
4.        
5.         size_t  index = 0;
6.          while(thiz->used_size  == index)
7.          {
8.                   foreach_func(thiz->data[index], ctx);
9.                   index++;
10.           }
11.  
12.          return ;
13. }

       无论是链表还是数组实现遍历函数的目的就是为了打印出每个数组元素的值，因为数组元素里面可以保存数据，也可以保存地址。