线性表实现

1. 数据封装，void指针不能作为左值所以可以防止数据被意外修改

   .typedef void LineList;
   .typedef void LineListNode;
   .typedef unsigned int TLineList{};
   .typedef unsigned int TLineNode;

2. 创建线性表结构体{1.现在的长度length 2.所能容纳的最大数量 3.指向接下来的位置指针}

3. 创建线性表函数void* Line_List(int quantity)是否合法quantity>0申请内存 ret = (Tlinelist*)macall(sizeof(TLinelist)+sizeof(TLineNode)*quantity)申请成功则额

4. 线性表的销毁
   free(list);

5. 线性表的清零
   判断是否合法length = 0;

6. 获取线性表的长度
   如果合法则获取长度

7. 获取线性表的最大容量

8. 线性表的插入
   判断是否合法

9. 获取线性表的元素

10. 删除线性表的元素

list.h

#ifndef _LIST_H_
#define _LIST_H_
typedef void SeqList;
typedef void SeqListNode;
typedef unsigned int TSeqListNode;
//线性表的结构体
typedef struct _tag_SeqList
{
    int capacity;//最大数量
    int length;//现在的长度
    TSeqListNode* node;//指向接下来的位置
} TSeqList;

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);
SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif

list.c

#include <stdio.h>
#include <malloc.h>
#include "list.h"

SeqList* SeqList_Create(int capacity) // O(1)
{
    TSeqList* ret = NULL;
    //判断线性表是否合法（即元素个数是否大于0）
    if (capacity >= 0)
    {
        ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode) * capacity);
    }
    //如果创建成功
    if (ret != NULL)
    {
        ret->capacity = capacity;
        ret->length = 0;
        ret->node = (TSeqListNode*)(ret + 1);//把指针指向接下来的空间
    }

    return ret;
}
//线性表的销毁
void SeqList_Destroy(SeqList* list) // O(1)
{
    free(list);
}
//线性表的清零
void SeqList_Clear(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    //线性表的清除
    if (sList != NULL)
    {
        sList->length = 0;
    }
}
//获取线性表的长度失败返回-1，成功返回长度
int SeqList_Length(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    int ret = -1;

    if (sList != NULL)
    {
        ret = sList->length;
    }

    return ret;
}

//获取线性表的最大容量，失败返回-1
int SeqList_Capacity(SeqList* list) // O(1)
{
    TSeqList* sList = (TSeqList*)list;
    int ret = -1;

    if (sList != NULL)
    {
        ret = sList->capacity;
    }

    return ret;
}
//线性表的插入
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos) // O(n) 
{
    TSeqList* sList = (TSeqList*)list;
    int ret = (sList != NULL);//判断线性表是否合法
    int i = 0;
    //ret=ret&&()中的ret&&的作用是在线性表合法的情况下再判断位置是否合法
    ret = ret && (sList->length + 1 <= sList->capacity);
    ret = ret && (0 <= pos);

    if (ret)
    {
        if (pos >= sList->length)//如果大于当前长度就把它放到最后
        {
            pos = sList->length;
        }
        //后移元素
        for (i = sList->length; i>pos; i--)
        {
            sList->node[i] = sList->node[i - 1];
        }

        sList->node[i] = (TSeqListNode)node;
        sList->length++;//**容易忘记加**
    }

    return ret;
}
//获取线性表中的元素
SeqListNode* SeqList_Get(SeqList* list, int pos) // O(1) 
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = NULL;

    if ((sList != NULL) && (0 <= pos) && (pos < sList->length))
    {
        ret = (SeqListNode*)(sList->node[pos]);
    }

    return ret;
}
//删除元素
SeqListNode* SeqList_Delete(SeqList* list, int pos) // O(n)
{
    TSeqList* sList = (TSeqList*)list;
    SeqListNode* ret = SeqList_Get(list, pos);//删除前先获取这个值
    int i = 0;

    if (ret != NULL)
    {
        for (i = pos + 1; i<sList->length; i++)
        {
            sList->node[i - 1] = sList->node[i];
        }

        sList->length--;
    }

    return ret;
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "list.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[])
{
    SeqList* list = SeqList_Create(5);

    int i = 0;
    int j = 1;
    int k = 2;
    int x = 3;
    int y = 4;
    int z = 5;
    int index = 0;

    SeqList_Insert(list, &i, 0);
    SeqList_Insert(list, &j, 0);
    SeqList_Insert(list, &k, 0);
    SeqList_Insert(list, &x, 0);
    SeqList_Insert(list, &y, 0);
    SeqList_Insert(list, &z, 0);

    for (index = 0; index<SeqList_Length(list); index++)
    {
        int* p = (int*)SeqList_Get(list, index);

        printf("%d\n", *p);
    }

    printf("\n");

    while (SeqList_Length(list) > 0)
    {
        int* p = (int*)SeqList_Delete(list, 0);

        printf("%d\n", *p);
    }

    SeqList_Destroy(list);
    system("pause");
    return 0;
}