线性表顺序存储结构

底层库：Stu_SeqList是一个结构体，内套Node指针。

上层应用：Student节点。

注意：底层库返回均为void型，上层应用强制类型转换为自所需要的数据类型。写代码先写测试框架（打桩）。

参考C语言代码：

linear_seq.c文件（上层应用）：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"seqlist.h"
typedef struct
{
    int age;
    char name[64];
}Student;
/*这个是节点*/
void main()
{
    int ret = 0,i;
    SeqList* list = NULL;
    Student s1,s2,s3,s4;
    s1.age = 18;
    s2.age = 19;
    s3.age = 20;
    s4.age = 21;
    list = SeqList_Create(10);
    if (list == NULL)
    {
        printf("func SeqList_Create() ret :%d \n", ret);
        return;
    }
    ret = SeqList_Insert(list, (SeqListNode*)&s1, 0); //头插法
    ret = SeqList_Insert(list, (SeqListNode*)&s2, 0); //头插法
    ret = SeqList_Insert(list, (SeqListNode*)&s3, 0); //头插法
    ret = SeqList_Insert(list, (SeqListNode*)&s4, 0); //头插法
    //遍历
    for (i = 0; i<SeqList_Length(list); i++)
    {
        Student* tmp = (Student*)/*强制类型转换，外面
        的人知道是什么数据类型，底层库的人返回空类型*/SeqList_Get(list, i);
        if (tmp == NULL)
        {
            return;
        }
        printf("tmp->age:%d ", tmp->age);
    }
    printf("\n");
    //删除链表中的节点
    SeqList_Delete(list, 1);
    for (i = 0; i<SeqList_Length(list); i++)
    {
        Student* tmp = (Student*)/*强制类型转换*/SeqList_Get(list, i);
        if (tmp == NULL)
        {
            return;
        }
        printf("tmp->age:%d ", tmp->age);        
    }    
    /*while (SeqList_Length(list) > 0)
    {
        SeqList_Delete(list, 0);
    }*/

    system("pause");
}

seqlist.h文件（头文件）：

 1 #ifndef  __MY_SEQLIST_H__ 
 2 #define __MY_SEQLIST_H__
 3 
 4 typedef void SeqList;
 5 typedef void SeqListNode;
 6 
 7 SeqList* SeqList_Create(int capacity);/*先返回void*型，再强制类型转换*/
 8 void SeqList_Destroy(SeqList* list);
 9 void SeqList_Clear(SeqList* list);
10 int SeqList_Length(SeqList* list);
11 int SeqList_Capacity(SeqList* list);
12 int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
13 SeqListNode* SeqList_Get(SeqList* list, int pos);/*先返回void*型，再强制类型转换*/
14 SeqListNode* SeqList_Delete(SeqList* list, int pos);
15 #endif  //__MY_SEQLIST_H__

seqlist.c文件（底层库实现）：

  1 #include <stdlib.h>
  2 #include <string.h>
  3 #include <stdio.h>
  4 #include "seqlist.h"
  5 
  6 typedef struct
  7 {
  8     int length;
  9     int capacity;
 10     unsigned int *node;   //int* node[]
 11 }Stu_SeqList;
 12 /*这个是大数组*/
 13 SeqList* SeqList_Create(int capacity)
 14 {
 15     int ret = 0;
 16     Stu_SeqList *tmp = NULL;
 17     tmp = (Stu_SeqList*)malloc(sizeof(Stu_SeqList));/*可以在栈上分配，
 18                             也可以在堆上分配，这里采用在堆上分配。*/
 19     if (tmp == NULL)
 20     {
 21         ret = -1;
 22         printf("func SeqList_Create() err:%d \n", ret);
 23         return NULL;
 24     }
 25     tmp->node = (unsigned int *)malloc(sizeof(unsigned int *)* capacity);
 26     /*此时大数组里只分配了capacity个unsigned int *型的node,数组还是空的*/
 27     if(tmp->node == NULL)
 28     {
 29         ret = -2;
 30         printf("func SeqList_Create() err: malloc err %d \n", ret);
 31         return NULL;
 32     }
 33     tmp->capacity = capacity;
 34     tmp->length = 0;
 35     return tmp;
 36 }
 37 void SeqList_Destroy(SeqList* list)
 38 {
 39     Stu_SeqList* s_list = NULL;
 40     if (list == NULL)
 41     {
 42         return;
 43     }
 44     s_list = (Stu_SeqList*)list;//因为我不知道别人传什么数据类型，所以要强制类型转换。
 45     if (s_list->node != NULL)
 46     {
 47         free(s_list->node);
 48     }
 49     free(s_list);
 50 }
 51 //清空链表 //回到初始化状态
 52 void SeqList_Clear(SeqList* list)
 53 {
 54     Stu_SeqList* s_list = NULL;
 55     if (list == NULL)
 56     {
 57         return;
 58     }
 59     s_list = (Stu_SeqList*)list;
 60     s_list->length= 0;
 61     return;
 62 }
 63 int SeqList_Length(SeqList* list)
 64 {
 65     Stu_SeqList* s_list = NULL;
 66     if (list == NULL)
 67     {
 68         return -1;
 69     }
 70     s_list = (Stu_SeqList*)list;
 71     return s_list->length;
 72 }
 73 int SeqList_Capacity(SeqList* list)
 74 {
 75     Stu_SeqList* s_list = NULL;
 76     if (list == NULL)
 77     {
 78         return -1;
 79     }
 80     s_list = (Stu_SeqList*)list;
 81     return s_list->length;
 82 }
 83 int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
 84 {
 85     Stu_SeqList* s_list = NULL;
 86     int i = 0, ret = 0;
 87     if (list == NULL || node == NULL || pos<0)
 88     {
 89         ret = -1;
 90         printf("fun SeqList_Insert() err:%d \n", ret);
 91         return ret;
 92     }
 93     s_list = (Stu_SeqList*)list;
 94     //判断是不是满了
 95     if (s_list->length >= s_list->capacity)
 96     {
 97         ret = -2;
 98         printf("fun SeqList_Insert() (tlist->length >= tlist->capacity) err:%d \n", ret);
 99         return ret;
100     }
101     if (pos >= s_list->length)
102     {
103         pos = s_list->length; //修正
104     }
105     for (i = s_list->length; i>pos; i--)
106     {
107         s_list->node[i] = s_list->node[i - 1];        //元素后移
108     }
109     s_list->node[i] = (unsigned int) node;
110     s_list->length++;
111     return 0;
112 }
113 SeqListNode* SeqList_Get(SeqList* list, int pos)
114 {
115     Stu_SeqList* s_list = NULL;
116     int i = 0, ret = 0;
117     if (list == NULL || pos<0)
118     {
119         printf("fun SeqList_Insert() err:%d \n", ret);
120         return NULL;
121     }
122     s_list = (Stu_SeqList*)list;
123     return (void* )s_list->node[pos];
124 }
125 SeqListNode* SeqList_Delete(SeqList* list, int pos)
126 {
127     Stu_SeqList* s_list = NULL;
128     int i = 0;
129     SeqListNode* ret = 0;
130     if (list == NULL || pos<0)
131     {
132         printf("fun SeqList_Insert() err:%d \n", ret);
133         return NULL;
134     }
135     s_list = (Stu_SeqList*)list;
136     ret = (SeqListNode*)s_list->node[pos];
137     for (i = pos + 1; i<s_list->length; i++)
138     {
139         s_list->node[i-1] = s_list->node[i];        //元素后移
140     }
141     s_list->length--;
142     return ret;
143 }

 

posted @ 2018-03-16 09:20  Alexadar  阅读(208)  评论(0)    收藏  举报