线性表的顺序存储结构

1.顺序存储定义
线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。

2.顺序表的一些基本操作
（1）线性表的初始化
定义一个结构体，结构体里面存储数组的起始地址，线性表的大小和线性表的长度。

int SeqInit(sq *s)
{
    (*s) = (sq)malloc(sizeof(seq));//为定义的结构体指针初始化，分配一个地址
    if((*s) == NULL)
    {
        return FAILURE;
    }

    (*s)->array = (int *)malloc(sizeof(int) * SIZE);//为结构体中的指针即数组的起始地址初始化，分配一个地址
    if((*s)->array == NULL)
    {
        return FAILURE;
    }

    (*s)->size = SIZE;
    (*s)->length = 0;

    return SUCCESS;
}

（2）顺序表中元素的插入
步骤：
如果插入的位置不合理，抛出异常；
如果线性表长度大于等于数组长度，则跑出异常或动态增加容量；
从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一个位置；
将要插入元素填入位置i处；
表长加1；

int SeqInsert(sq s, int i, int e)//把数据e插入在位置I处
{
    int *p = NULL;

    if(s == NULL)
    {
        return FAILURE;
    }

    if(s->length >= s->size)
    {
        return FAILURE;
    }

    if(i <= 0 || i > s->size)
    {
        return FAILURE;
    }

    for(p = s->array + s->length; p >= s->array + i; p--)
    {
        memcpy(p, p - 1, sizeof(int));//将插入元素的位置后的每一个元素都向后移动一位
    }

    memcpy(s->array + i - 1, &e, sizeof(int));//把数据e插入到i位置处
    s->length++;

    return SUCCESS;
}

（3）顺序表数据的删除
步骤：
如果删除位置不合理，抛出异常；
取出删除元素；
从删除元素位置开始遍历到最后一个元素位置，分别将它们都向前移动一个位置；
表长减1；

int SeqDelete(sq s, int i, int *e)//将第i个位置的元素删除，并用e记下其值返回
{
    if(s == NULL || i > s->length || i <= 0)
    {
        return FAILURE;
    }

    int *p = NULL;

    *e = *(s->array + i - 1);

    for(p = s->array + i - 1; p <= s->array + s->length; p++)
    {
        memcpy(p, p + 1, sizeof(int));//在删除元素的位置后将所有的元素都向前移动一位
    }

    s->length--;

    return *e;
}

具体代码：
头文件：

#ifndef _SEQUENCE_H_
#define _SEQUENCE_H_

#define SIZE    10
#define SUCCESS  0
#define FAILURE -1

struct sequence
{
    int *array;
    int size;
    int length;
};

typedef struct sequence seq;
typedef seq *sq;

int SeqInit(sq *s);//初始化
int SeqEmpty(sq s);//判断是否为空表
int SeqInsert(sq s, int i, int e);//插入元素
int SeqTravel(sq s);//遍历顺序表
int SeqLength(sq s);//求长度
int SeqGetElem(sq s, int k, int *e);//已知位置找元素的值
int SeqLocate(sq s, int e);//已知元素的值找位置
int SeqPrior(sq s, int k);//求前驱
int SeqAfter(sq s, int k);//求后继
int SeqDelete(sq s, int i, int *e);//删除元素
int SeqClear(sq s);//清空顺序表

#endif

主函数：

#include <stdio.h>
#include "sequence.h"

int main()
{
    sq s;//定义一个结构体指针
    int ret;
    int i;
    int e;

    ret = SeqInit(&s);//初始化，为结构体指针后结构体中的数组起始地址分配地址
    if(ret == SUCCESS)
    {
        printf("Init success!\n");
    }

    else
    {
        printf("Init failure!\n");
    }

    ret = SeqEmpty(s);
    if(ret == SUCCESS)
    {
        printf("The seq is empty!\n");
    }

    else
    {
        printf("The seq is not empty!\n");
    }

    for(i = 0; i < 5; i++)
    {
        ret = SeqInsert(s, i + 1, i);
        if(ret == SUCCESS)
        {
            printf("Insert %d success!\n", i);
        }

        else
        {
            printf("Insert %d failure!\n", i);
        }
    }

    ret = SeqTravel(s);
    if(ret == SUCCESS)
    {
        printf("Travel success!\n");
    }

    ret = SeqLength(s);
    printf("Length is %d\n", ret);

    ret = SeqGetElem(s, 3, &e);
    if(ret == SUCCESS)
    {
        printf("The third elem is %d\n", e);
    }

    else
    {
        printf("Can not find!\n");
    }

    ret = SeqLocate(s, 3);
    printf("The location is %d\n", ret);

    ret = SeqPrior(s, 3);
    printf("the prior is %d\n", ret);

    ret = SeqAfter(s, 3);
    printf("The after is %d\n", ret);

    ret = SeqDelete(s, 3, &e);
    if(ret != FAILURE)
    {
        printf("Delete %d success!\n", e);
    }

    else
    {
        printf("Delete %d failure!\n", e);
    }

    ret = SeqTravel(s);

    ret = SeqClear(s);
    if(ret == SUCCESS)
    {
        printf("Clear success!\n");
    }

    else
    {
        printf("Clear failure!\n");
    }

    return 0;
}

各个函数接口：

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

int SeqInit(sq *s)
{
    (*s) = (sq)malloc(sizeof(seq));
    if((*s) == NULL)
    {
        return FAILURE;
    }

    (*s)->array = (int *)malloc(sizeof(int) * SIZE);
    if((*s)->array == NULL)
    {
        return FAILURE;
    }

    (*s)->size = SIZE;
    (*s)->length = 0;

    return SUCCESS;
}

int SeqEmpty(sq s)
{
    if(s == NULL)
    {
        return FAILURE;
    }

    if(s->length != 0)
    {
        return FAILURE;
    }

    return SUCCESS;
}

int SeqInsert(sq s, int i, int e)
{
    int *p = NULL;

    if(s == NULL)
    {
        return FAILURE;
    }

    if(s->length >= s->size)
    {
        return FAILURE;
    }

    if(i <= 0 || i > s->size)
    {
        return FAILURE;
    }

    for(p = s->array + s->length; p >= s->array + i; p--)
    {
        memcpy(p, p - 1, sizeof(int));
    }

    memcpy(s->array + i - 1, &e, sizeof(int));
    s->length++;

    return SUCCESS;
}

int SeqTravel(sq s)
{
    if(s == NULL)
    {
        return FAILURE;
    }

    int i;

    for(i = 0; i < s->length; i++)
    {
        printf("%d\n", *(s->array + i));
    }

    return SUCCESS;
}

int SeqLength(sq s)
{
    if(s == NULL)
    {
        return FAILURE;
    }

    else
    {
        return s->length;
    }
}

int SeqGetElem(sq s, int k, int *e)
{
    if(s == NULL)
    {
        return FAILURE;
    }

    else
    {
        *e = *(s->array + k - 1);
        return SUCCESS;
    }
}

int SeqLocate(sq s, int e)
{
    if(s == NULL)
    {
        return FAILURE;
    }

    int i;

    for(i = 0; i < s->length; i++)
    {
        if(e == *(s->array + i))
        {
            return (i + 1);
        }
    }
}

int SeqPrior(sq s, int k)
{
    if(s == NULL)
    {
        return FAILURE;
    }

    int i;

    for(i = 0; i < s->length; i++)
    {
        if(k == *(s->array + i))
        {
            return *(s->array + i - 1);
        }
    }
}

int SeqAfter(sq s, int k)
{
    if(s == NULL)
    {
        return FAILURE;
    }

    int i;

    for(i = 0; i < s->length; i++)
    {
        if(k == *(s->array + i))
        {
            return *(s->array + i + 1);
        }
    }
}

int SeqDelete(sq s, int i, int *e)
{
    if(s == NULL || i > s->length || i <= 0)
    {
        return FAILURE;
    }

    int *p = NULL;

    *e = *(s->array + i - 1);

    for(p = s->array + i - 1; p <= s->array + s->length; p++)
    {
        memcpy(p, p + 1, sizeof(int));
    }

    s->length--;

    return *e;
}

int SeqClear(sq s)
{
    if(s == NULL)
    {
        return FAILURE;
    }

    free(s->array);
    free(s);

    return SUCCESS;
}