线性表顺序存储API

顺序存储的优点：

无需为线性表中的逻辑关系增加额外的空间

可以快速的获取表中合法位置的元素

顺序存储的缺点：

插入和删除操作需要移动大量元素

当线性表长度变化较大时难以确定存储空间的容量

seqlist.h

#ifndef __MY_SEQLIST_H__
#define __MY_SEQLIST_H__

typedef void SeqList;

typedef void SeqListNode;

typedef unsigned int DataType;

SeqList* SeqList_Create(int capacity);

void SeqList_Destroy(SeqList* list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList*list,SeqListNode*node,int pos);

SeqListNode* SeqList_Get(SeqList*list,int pos);

/*这种返回int的删除程序是不恰当的 因为顺序表底层库不关心业务节点内存的分配与释放
全部是有调用者实现的内存分配与释放，所以 我们应该返回指向节点的指针 而不是int型变量*/
//int SeqList_Delete(SeqList*list,int pos);

SeqListNode* SeqList_Delete(SeqList*list,int pos);

#endif

seqlist.c

#include "seqlist.h"
#include <stdio.h>
#include<stdlib.h>
#include <memory.h>

//线性表
//1.线性表顺序存储---顺序表
//2.线性表链式存储---链表

typedef struct _tag_SeqList
{
    int length;//顺序表的长度和容量是两个不同的概念  容量 >=长度
    int capacity;
    DataType* node;
}TSeqList;

SeqList* SeqList_Create(int capacity)
{
    int ret = 0;
    TSeqList *tmp = NULL;
    tmp = (TSeqList*)malloc(sizeof(TSeqList));
    if (tmp==NULL)
    {
        ret = -1;
        printf("func malloc() err:%d\n",ret);
        return NULL;
    }
    memset(tmp,0,sizeof(TSeqList));
    tmp->node = (DataType*)malloc(sizeof(DataType*)*capacity);
    if (tmp==NULL)
    {
        ret = -2;
        printf("func malloc err:%d\n",ret);
        return NULL;
    }
    tmp->capacity = capacity;
    tmp->length = 0;
    return tmp;
}

void SeqList_Destroy(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list ==NULL)
    {
        return ;
    }
    tlist = (TSeqList*)list;
    if (tlist->node!=NULL)
    {
        free(tlist->node);
        tlist->node = NULL;
    }
    free (tlist);
    tlist = NULL;
}
//清空
void SeqList_Clear(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list ==NULL)
    {
        return ;
    }
    tlist = (TSeqList*)list;
    tlist->length = 0;
}

int SeqList_Length(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list ==NULL)
    {
        return -1 ;
    }
    tlist = (TSeqList*)list;
    return tlist->length;
}

int SeqList_Capacity(SeqList* list)
{
    TSeqList *tlist = NULL;
    if (list ==NULL)
    {
        return -1 ;
    }
    tlist = (TSeqList*)list;
    return tlist->capacity;
}

int SeqList_Insert(SeqList*list,SeqListNode*node,int pos)
{
    TSeqList *tlist = NULL;
    int i = 0;
    int ret = 0;
    if (list ==NULL|| node==NULL || pos<0)
    {
        ret = -1;
        printf("list ==NULL|| node==NULL || pos<0 ");
        return ret ;
    }
    tlist = (TSeqList *)list;
    //判断满不满
    if (tlist->length>=tlist->capacity)
    {
        ret = -2;
        printf("tlist->length>=tlist->capacity :%d\n",ret);
        return ret ;
    }
    //容错修正 假设长度目前为6，容量为20，现在用户输入pos = 10 插入；我们应该在位置7插入
    if (pos>=tlist->length)
    {
        pos = tlist->length;
    }

    //元素后移
    for (i = tlist->length; i>pos;i--)
    {
        tlist->node[i] = tlist->node[i-1];
    }
    //在pos位置插入元素
    tlist->node[i] = (DataType)node;//void指针赋值给其他类型的指针时都要进行转换
    tlist->length++;

    return ret;
}

SeqListNode* SeqList_Get(SeqList*list,int pos)
{
    TSeqList *tlist = NULL;
    int i = 0;
    int ret = 0;
    tlist = (TSeqList *)list;
    if (list ==NULL||pos<0||pos>=tlist->length)
    {
        ret = -1;
        printf("list ==NULL||pos<0||pos>=tlist->length :%d\n",ret);
        return NULL ;
    }
    return (SeqListNode*)(tlist->node[pos]);
}
//删除pos处的元素 返回成不成功 0成功 

SeqListNode* SeqList_Delete(SeqList*list,int pos)
{
    TSeqList *tlist = NULL;
    int i = 0;
    SeqListNode *ret=NULL;
    
     if (list ==NULL||pos<0)
    {
        printf("list ==NULL||pos<0||pos>=tlist->length");
        return NULL ;
    }
    tlist = (TSeqList *)list;
    ret = (SeqListNode*)tlist->node[pos];//保存要删除的节点元素值
    //元素前移
    for (i = pos ;i <=tlist->length;i++)
    {
        tlist->node[i] = tlist->node[i+1];
    }
    tlist->length--;
    return ret;
}

test.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include<stdio.h>
#include <string.h>
#include "seqlist.h"

typedef struct Teacher
{    
    int age;
    char name[10];
}Teacher;

void display()
{
    int ret = 0;
    int i = 0;
    Teacher t1,t2,t3,t4,t5,t6;

    SeqList* list = NULL;

    t1.age = 30;
    t2.age = 31;
    t3.age = 32;
    t4.age = 33;
    t5.age = 34;
    t6.age = 35;

    list =(SeqList* )SeqList_Create(10);

    if (list ==NULL)
    {
        ret = -1;
        printf("func SeqList_Create() error :%d\n",ret);
        return ret ;
    }

    ret = SeqList_Insert(list,&t1,0);//任何指针都可以赋值给void指针 不需要转换
    ret = SeqList_Insert(list,&t2,0);
    ret = SeqList_Insert(list,&t3,0);
    ret = SeqList_Insert(list,&t4,0);
    ret = SeqList_Insert(list,&t5,0);
    ret = SeqList_Insert(list,&t6,0);

    for (i = 0;i<SeqList_Length(list);i++)
    {
        Teacher * tmp = (Teacher *)SeqList_Get(list,i);
        if (tmp==NULL)
        {
            ret = -1;
            printf("func SeqList_Get() error :%d\n",ret);
            return ret ;
        }
        printf("%d\n",tmp->age);
    }
    //删除链表中的节点
    while (SeqList_Length(list)>0)
    {
         ret =  SeqList_Delete(list,0);
         if (ret == NULL)
         {
             printf("func SeqList_Delete() err \n");
         }
    }

    SeqList_Destroy(list);
}

int main()
{
    display();
    system("pause");
    return 0;
}