顺序表和链表

1.1 线性表在逻辑上是连续的一块内存空间，在物理结构上不一定是连续的，在物理结果上一般是数组、链表。

1.2 顺序表用数组存储数据元素，在数组上进行增删查改。

顺序表分为静态顺序表（使用定长数组存储）

动态顺序表（使用动态开辟的数组存储）

静态顺序表（固定大小的）：

typedef int SLDataType;//将int类型转换为SLDataType，以后数据类型变了，直接把int换掉，后面就全部 
                       //改了.
#define N 10;

struct SeqList //vector
{
   int arr[N];
   int size;//记录当前顺序表中有效数据个数.
};

void SeqListPushBack(struct SeqList* ps,SLDataType x);//尾插
void SeqListPopBack(struct SeqList* ps);//尾删
void SeqListPushFront(struct SeqList* ps,SLDataType x);//头插
void SeqListPopFront(struct SeqList* ps);//头删
void SeqListPushBack(struct SeqList* ps,SLDataType x);
void SeqListPushBack(struct SeqList* ps,SLDataType x);

动态顺序表（大小可变）SeqList.h(类型申明、接口申明)：

#include<stdio.h>
#include<stdlib.h>
typedef int SLDataType;//将int类型转换为SLDataType，以后数据类型变了，直接把int换掉，后面就全部 
                       //改了.
typedef struct SeqList //vector
{
   SLDataType* a;
   int size;//记录当前顺序表中有效数据个数.
   int capacity;//记录当前空间的大小
}SL,SeqList;

void SeqListInit(SeqList s);
void SeqListPushBack(SeqList* ps,SLDataType x);//尾插
void SeqListPopBack(SeqList* ps);//尾删
//  任意位置插入
void SeqListInsert(SeqList* ps,int pos,SLDataType x);//形参有：结构体地址、待插入的位 
                                                            //置、待插入的数据
//  任意位置删除
void SeqListErase(SeqList* ps,int pos);//形参有：结构体地址、待插入的位置
void SeqListPushFront(SeqList* ps,SLDataType x);//头插
void SeqListPopFront(SeqList* ps);//头删
void SeqListPushBack(SeqList* ps,SLDataType x);
void SeqListPushBack(SeqList* ps,SLDataType x);

SeqList.c

//尾插
//1.创建一个顺序表
//2.初始化创建的顺序表
//3.
void SeqListInit(SeqList* ps)//初始化
{
   ps->size=0;
   ps->a=NULL;
   ps->capacity=0;
   ps->a=(SeqList*)malloc(sizeof(SLDataType)*4);
   if(ps->a=NULL)
     {
        printf("申请空间失败\n");
        exit(-1);
     }
   ps->size=0;
   ps->capacity=4;
}
void SeqListpushBack(struct SeqList* ps,SLDataType x)//尾插
{
  //判断是否满了，如果满了要增容。
  if(ps->size>=ps->capacity)
    {
       ps->capacity*=2;//
       ps->a=(SLDataType*)relloc(ps->a,sizeof(SLDataType)*ps->capacity);
       if(ps->a==NULL)
         {
            printf("扩容失败\n");
            exit(-1);
         }
    }
  ps->a[ps->size]=x;
  ps->size++;
}
void SeqListPopBack(struct SeqList* ps);//尾删
{
  ps->size--;
}
//  任意位置插入
void SeqListInsert(struct SeqList* ps,int pos,SLDataType x);//形参有：结构体地址、待插入的位 
                                                            //置、待插入的数据
//  任意位置删除
void SeqListErase(struct SeqList* ps,int pos);//形参有：结构体地址、待插入的位置
void SeqListPushFront(struct SeqList* ps,SLDataType x);//头插
{
  //判断是否满了，如果满了要增容。
  if(ps->size>=ps->capacity)
    {
       ps->capacity*=2;//
       ps->a=(SLDataType*)relloc(ps->a,sizeof(SLDataType)*ps->capacity);
       if(ps->a==NULL)
         {
            printf("扩容失败\n");
            exit(-1);
         }
    }
   int i=ps->size-1;
   for(i=size-1;i>0;i--)
     {
        ps->a[i+1]=ps->a[i];
     }
   ps->a[0]=x;
   ps->size++;
}
void SeqListPopFront(struct SeqList* ps);//头删
{
     //判断是否满了，如果满了要增容。
  if(ps->size>=ps->capacity)
    {
       ps->capacity*=2;//
       ps->a=(SLDataType*)relloc(ps->a,sizeof(SLDataType)*ps->capacity);
       if(ps->a==NULL)
         {
            printf("扩容失败\n");
            exit(-1);
         }
    }
  int i=0;
  for(i=0;i<ps->size-1;i++)
    {
       ps->a[i]=ps->a[i+i];
    }
  ps->size--;
}
void SeqListPushBack(struct SeqList* ps,SLDataType x);
void SeqListPushBack(struct SeqList* ps,SLDataType x);

test.c 

//test.c
#include "SeqList.h"
#include<stdio.h>

//测试头尾插入删除

void TestSeqList1()
{
   SeqList s;
   void SeqListInit(&s);
   SeqListPushBack(&s,1);
   SeqListprint(&s);
}

int main()
{
   struct SeqList s;
   
   
   
}