链表线性表的c语言实现方式 seqlist.h 和 seqlist.c

seqlist.h 文件

#ifndef _SEQLIST_H_
#define _SEQLIST_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//线性表
//线性表顺序存储 类似于数组，存的元素节点,只有业务节点，
//业务节点之间没有关系,线性关系不是链性关系，可以[]操作
typedef void List;
typedef void ListNode;

#ifndef bool
#define bool int
#define true 1
#define false 0
#endif

typedef struct _tag_SeqList
{
    int length;     //当前有效节点个数
    int capacity;   //容量
    //业务节点,类似于数组,node[]里存的是指针，指向业务节点
    //业务节点是没有直接联系的
    unsigned int **node; 
}SeqList;

List* SeqList_Create(int capacity);
bool SeqList_Destroy(List* list);
bool SeqList_Clear(List* list);
int SeqList_GetLength(List* list);
int SeqList_GetCapacity(List* list);
bool SeqList_InsertOneNode(List* list ,ListNode* listnode, int pos);
ListNode* SeqList_GetOneNode(List* list ,int pos);
ListNode* SeqList_DeleteOneNode(List* list, int pos);
bool SeqList_DeleteAllNode(List* list);

#endif

seqlist.c 文件

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


//线性表 顺序存储
//创建线性表，开辟内存
List* SeqList_Create(int capacity)
{
    SeqList* listtemp = NULL; 
    listtemp = (SeqList*)malloc(sizeof(SeqList));
    if (listtemp == NULL)
    {
        printf("func selistcreate() err");
        return NULL;
    }
    memset(listtemp,0,sizeof(SeqList));
    listtemp->node = (unsigned int **)malloc(sizeof(unsigned int **) * capacity);
    if (listtemp->node == NULL)
    {
        printf("func selistcreate() err");
        return NULL;
    }
    listtemp->capacity = capacity;
    listtemp->length = 0;
    return listtemp;
}
/****销毁线性表，释放内存********/
bool SeqList_Destroy(List* list)
{
    SeqList* listtemp = NULL;
    if (list == NULL)
    {
        return false;
    }
    listtemp = (SeqList*)list;
    if (listtemp->node != NULL)
    {
        free(listtemp->node);
    }
    free(listtemp);
    return true;
}
//清空节点，但不释放内存
bool SeqList_Clear(List* list)
{
    SeqList* listtemp = NULL;
    if (list == NULL)
    {
        return false;
    }
    listtemp = (SeqList*)list;
    listtemp->length = 0;
    return true;
}
//返回长度
int SeqList_GetLength(List* list)
{
    SeqList* listtemp = NULL;
    if (list == NULL)
    {
        return -1;
    }
    listtemp = (SeqList*)list;
    return listtemp->length;
}
//返回容量
int SeqList_GetCapacity(List* list)
{
    SeqList* listtemp = NULL;
    if (list == NULL)
    {
        return -1;
    }
    listtemp = (SeqList*)list;
    return listtemp->capacity;
}
//插入一个节点
bool SeqList_InsertOneNode(List* list ,ListNode* listnode, int pos)
{
    SeqList* listtemp = NULL;
    int i = 0;
    if (list == NULL || listnode == NULL || pos < 0)
    {
        return false;
    }
    listtemp = (SeqList*)list;
    //判断链表节点是否已满
    if (listtemp->length >= listtemp->capacity)
    {
        printf("节点已满");
        return false;
    }
    //容错修正 容量20 长度6 pos10 修正查到7上[6]
    if (pos >= listtemp->length )
    {
        pos = listtemp->length;
    }
    //元素后移
    for (i = listtemp->length; i > pos; i--)
    {
        listtemp->node[i] = listtemp->node[i-1];
    }
    //节点插入
    listtemp->node[pos] = (unsigned int *)listnode;
    listtemp->length++;
    return true;
}
//得到一个节点
ListNode* SeqList_GetOneNode(List* list ,int pos)
{
    SeqList* listtemp = NULL;
    ListNode* ret = NULL;
    if (list == NULL || pos < 0)
    {
        return NULL;
    }
    listtemp = (SeqList*)list;
    if (listtemp->length <= 0 || pos >= listtemp->length)
    {
        return NULL;
    }
    ret  = (ListNode*)(listtemp->node[pos]);
    return ret;
}
//删除一个节点
ListNode* SeqList_DeleteOneNode(List* list, int pos)
{
    SeqList* listtemp = NULL;
    ListNode* ret = NULL;
    int i = 0;
    if (list == NULL || pos < 0)
    {
        return NULL;
    }
    listtemp = (SeqList*)list;
    if (listtemp->length <= 0 || pos >= listtemp->length)
    {
        return NULL;
    }
    //缓存节点
    ret = (ListNode*)listtemp->node[pos];
    //节点删除，节点前移
    for (i = pos+1; i < listtemp->length; i++)
    {
        listtemp->node[ i-1 ] = listtemp->node[ i];
    }
    listtemp->length--;
    return ret;
    return NULL;
}
//删除所有节点
bool SeqList_DeleteAllNode(List* list)
{
    SeqList* listtemp = NULL;
    if (list == NULL )
    {
        return false;
    }
    listtemp = (SeqList*) list;
    if (listtemp->length <= 0)
    {
        return false;
    }
    while(listtemp->length > 0)
    {
        SeqList_DeleteOneNode(listtemp,0);
    }
    return true;
}

/******************以下为测试代码***********************/

/*
typedef struct _tag_Teacher
{
    int age;
}Teacher;
void  main()
{

    int kk = 0;
    List* seqlist = NULL;
    Teacher t1,t2,t3,t4,t5;
    Teacher* teacher = NULL;

    t1.age = 21;
    t2.age = 22;
    t3.age = 23;
    t4.age = 24;
    t5.age = 25;

    seqlist = SeqList_Create(12);
    if (seqlist == NULL)
    {
        printf("创建list失败");
    }
    //头插法

    //SeqList_InsertOneNode(seqlist,&t1,0);
    //SeqList_InsertOneNode(seqlist,&t2,0);
    //SeqList_InsertOneNode(seqlist,&t3,0);
    //SeqList_InsertOneNode(seqlist,&t4,0);
    //SeqList_InsertOneNode(seqlist,&t5,0);

    //尾插法
    SeqList_InsertOneNode(seqlist,&t1,SeqList_GetLength(seqlist));
    SeqList_InsertOneNode(seqlist,&t2,SeqList_GetLength(seqlist));
    SeqList_InsertOneNode(seqlist,&t3,SeqList_GetLength(seqlist));
    SeqList_InsertOneNode(seqlist,&t4,SeqList_GetLength(seqlist));
    SeqList_InsertOneNode(seqlist,&t5,SeqList_GetLength(seqlist));
    //遍历
    for(kk = 0; kk < SeqList_GetLength(seqlist); kk ++ )
    {
        teacher = (Teacher*)SeqList_GetOneNode(seqlist,kk);
        if (teacher == NULL)
        {
            printf("读取线性表失败\n");
        }
        printf("老师%d的年龄是%d\n",kk+1,teacher->age);
    }
    teacher = (Teacher*)SeqList_GetOneNode(seqlist,SeqList_GetLength(seqlist)-1);
    if (teacher == NULL)
    {
        printf("读取线性表失败\n");
    }
    printf("老师%d的年龄是:%d\n",SeqList_GetLength(seqlist),teacher->age);
    SeqList_DeleteAllNode(seqlist);
    printf("线性表的长度是：%d\n",SeqList_GetLength(seqlist));
    printf("线性表的容量是：%d\n",SeqList_GetCapacity(seqlist));
    SeqList_Destroy(seqlist);
    system("pause");
}
*/

上述可能会调用其它头文件或源文件，如果调用，请翻看我的其它博客，对其源文件和头文件的实现方式。
good luck !