数据结构---实现基于静态数组的顺序表的基本操作

实现基于静态数组的顺序表的以下基本操作:
首先先定义一个结构体类型seqlist（ arr【】，size（有效的元素个数）），预定义一个数组的最大长度，将整型数据变量typedef为datatype，为了以后在插入删除别的类型时方便修改

1. 初始化 void InitSeq(seqlist *s)
   将数组的size置为0，不需要给每个元素进行赋值，
2. 尾插 void SeqListPushBack(seqlist *s,DataType data)
   首先要判断是否为空数组，并且是否有空余位置插入，将数组的size+1，把元素放入最后一个位置。
3. 尾删void SeqListPophBack(seqlist *s)
   只需将size-1即可，也得先判断是否为空数组
4. 头插 void SeqListPushFront(seqlist *s, DataType data)
   首先要判断是否为空数组，并且是否有空余位置插入。把数组整体向后移一位（先移动最后一个元素），将第0号元素空出来，把需要插入的元素放入即可，size++。
5. 头删 void SeqListPopFront(seqlist *s)
   判断是否为空数组，若不是，把后边的元素整体向前移（先移动第一个元素），size–。
6. 读任意位置元素DataType Get(seqlist *s, size_t pos)
   判断是否为空数组，直接输出给定位置的元素还得判断给的位置是否超出数组最大范围
7. 修改任意位置元素void UpdateData(seqlist *s, size_t pos, DataType data)
   判断是否为空数组还得判断给的位置是否超出数组最大范围， 先找到这个位置元素，将其值进行修改，
8. 查找指定元素值的下标size_t Find(seqlist *s, DataType data)
   判断是否为空数组还得判断给的位置是否超出数组最大范围，给定一个元素，遍历，判断是否与数组内的元素相等，若不相等，count++，

9. 在任意位置插入元素void Insert(seqlist *s, size_t pos, DataType data)
   首先要判断是否为空数组，并且是否有空余位置插入还得判断给的位置是否超出数组最大范围，将(下标+1)的元素依次向后移动，再将给定元素插入给定位置，size+1;
   10.在任意位置删除元素
   要判断是否为空数组，将给定位置的下一个元素向前覆盖，依次到最后一个元素，size-1。

   各种函数主体：

#define MAX_SIZE 10
#include<assert.h>
typedef int DataType;
typedef struct SeqList
{
    int arr[MAX_SIZE];
    size_t size;
}seqlist;

void InitSeq(seqlist *s)     //初始化静态线性表
{
    assert(s);
    if (s == NULL)
    {
        return;
    }
    s->size = 0;
}

void SeqListPushBack(seqlist *s,DataType data)   //尾部插入数据
{
    assert(s);
    if (s == NULL)
    {
        return;
    }
    if (s->size >MAX_SIZE)
    {
        return;
    }
    ++s->size;
    s->arr[s->size - 1] = data;
}

void SeqListPopBack(seqlist *s)   //尾删
{
    assert(s);
    if (s == NULL)
    {
        return;
    }
    --s->size;
}
void SeqListPushFront(seqlist *s, DataType data)//头插
{
    assert(s);
    if (s == NULL)
    {
        return;
    }
    if (s->size >MAX_SIZE)
    {
        return;
    }
    ++s->size;      //先将有效数字加一，保证不丢失数据
    for (size_t i = s->size - 1; i > 0; i--)
    {
        s->arr[i] = s->arr[i-1];
    }
    s->arr[0] = data;
}
void SeqListPopFront(seqlist *s)//头删
{
    assert(s);
    if (s == NULL)
    {
        return;
    }
    for (size_t i = 1; i <= s->size; i++)
    {
        s->arr[i - 1] = s->arr[i];
    }
    s->size--;
}
DataType Get(seqlist *s, size_t pos)//读任意位置的元素
{
    assert(s);
    if (s == NULL)
    {
        return -1;
    }
    if (pos >= s->size)
    {
        return -1;
    }
    return s->arr[pos];
}
void UpdateData(seqlist *s, size_t pos, DataType data)//修改任意位置元素
{
    assert(s);
    if (s == NULL)
    {
        return;
    }
    if (pos>=s->size)
    {
        return ;
    }
    s->arr[pos - 1] = data;
}
size_t Find(seqlist *s, DataType data)//查找指定元素值的下标
{
    assert(s);
    if (s == NULL)
    {
        return -1;
    }
    for (size_t i = 0; i < s->size; i++)
    {
        if (s->arr[i] == data)
            return i;
    }
    return -2;
}
void Insert(seqlist *s, size_t pos, DataType data)//在第pos个位置插入元素
{
    assert(s);
    if (s == NULL)
    {
        return;
    }
    if (s->size >MAX_SIZE)
    {
        return;
    }
    if (pos >= s->size)
    {
        return ;
    }
    ++s->size;
    for (size_t i = s->size-1; i >= pos; i--)
    {
        s->arr[i] = s->arr[i-1];
    }
    s->arr[pos - 1] = data;
}
void Delete(seqlist *s, size_t pos)//删除下标为pos的元素
{
    assert(s);
    if (s == NULL)
    {
        return;
    }
    for (size_t i = pos; i < s->size-1; i++)
    {
        s->arr[i] = s->arr[i + 1];
    }
    --s->size;
}
void SeqListPrint(seqlist *s)//打印整个数组
{
    assert(s);
    size_t i = 0;
    for (; i < s->size; i++)
    {
        printf("%d ", s->arr[i]);
    }
    printf("\n");
}

测试函数：

void test()
{
    seqlist s;
    int tmp;
    InitSeq(&s);
    SeqListPushBack(&s, 1);
    SeqListPushBack(&s, 2);
    SeqListPushBack(&s, 3);
    SeqListPushBack(&s, 4);
    printf("初始化，尾插后的数组：\n");
    SeqListPrint(&s);
    printf("/\n");

    SeqListPopBack(&s);   //尾删
    printf("尾删后的数组：\n");
    SeqListPrint(&s);
    printf("/\n");

    SeqListPushFront(&s, 0);//头插
    SeqListPushFront(&s, -1);
    printf("头插后的数组：\n");
    SeqListPrint(&s);
    printf("/\n");

    SeqListPopFront(&s);//头删
    SeqListPopFront(&s);//头删
    printf("头删后的数组:\n");
    SeqListPrint(&s);
    printf("/\n");

    tmp = Get(&s, 2);//读任意位置的元素
    printf("arr[2]元素为：%d", tmp);
    printf("\n");
    tmp = Get(&s, 1);//读任意位置的元素
    printf("arr[1]元素为：%d", tmp);
    printf("\n");
    printf("/\n");
    printf("查找指定元素值的下标:\n");
    tmp = Find(&s, 1);//查找指定元素值的下标
    printf("元素1的下标为: %d\n",tmp);
    tmp = Find(&s, 2);//查找指定元素值的下标
    printf("元素2的下标为：%d\n ",tmp);
    tmp = Find(&s, 4);//查找指定元素值的下标
    printf("元素4的下标为：%d\n ",tmp);
    printf("/\n");
    Insert(&s, 2, -5);//在任意位置插入元素
    printf("在第二个元素上插入-5：\n");
    SeqListPrint(&s);
    printf("/\n");
    printf("删除下标为2的元素：\n");
    Delete(&s, 1);//删除下标为pos的元素
    SeqListPrint(&s);
}

主函数：

#include<stdio.h>
#include<windows.h>
#include"标头.h"

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

测试结果：