自己编写顺序表函数库详解

头文件

#ifndef _ARRAYLIST_H
#define _ARRAYLIST_H

#define SIZE 10

#define SUCCESS 10000
#define FAILURE 10001
#define TRUE    10002
#define FALSE   10003

typedef int ElemType;  //为已有的数据类型取一个新名字

//定义一个数据类型，该数据类型的名字叫struct SequenceList,该数据类型含有两个成员变量，分别是data, length;
struct SequenceList
{
  int length;
  ElemType *data;
};

typedef struct SequenceList SeLi;

int SequenceInit(SeLi *l);  //分号不能省
int SequenceInsert(SeLi *l, int p, ElemType e);
int SequenceDelete(SeLi *l, int p, ElemType *e);
int LocateElem(SeLi l, ElemType e);
int GetElem(SeLi l, int p, ElemType *e);
int SequenceLength(SeLi l);
int SequenceEmpty(SeLi l);
int SequenceTraverse(SeLi l, void(*p)(ElemType));
int SequenceClear(SeLi *l);
int SequenceDestroy(SeLi *l);

#endif

库函数   

    写类库：

      1、初始化条件

      2、各个参数的含义

      3、函数操作完达到的功能

#include "ArrayList.h"
#include <stdlib.h> //还包含了exit函数

//初始化条件：结构体已存在,且被传入函数
//SeLi *l l是一个指针,指针的数据类型SeLi *,指针指向的类型是SeLi 
//函数功能：构建一个空的顺序表，为顺序表分配一个空间，顺序表的长度为0
int SequenceInit(SeLi *l)
{
    if (NULL == l)      //入参判断
    {
        return FAILURE;
    }

    l->length = 0; //l这个指针变量指向的结构体的length成员变量
    l->data = (ElemType *)malloc(sizeof(ElemType) * SIZE);//动态内存分配失败

    return SUCCESS;
}

//初始化条件：结构体已存在,且被传入函数，并且顺序表已经建立
//SeLi *l l是一个指针,指针的数据类型是SeLi *,指针指向的类型是SeLi
//p是要插入的位置
//e是要插入的元素
//函数功能：在线性表中的第p个位置插入新元素e
//★注意数组下标和要插入位置p之间有差1的关系
int SequenceInsert(SeLi *l, int p, ElemType e) //p的值从1开始
{
    int i;

    //当结构体未被传入函数，或者顺序表并未被分配空间时，不能插入
    if (NULL == l || NULL == l->data) 
    {
        return FAILURE;
    }

    //如果线性表长度为3，要往第5个位置插入，或者顺序表的长度等于容量，或者插入位置小于1时，插入失败
    if (p > l->length + 1 || l->length >= SIZE || p < 1)
    {
        return FAILURE;
    }

    //从第P个位置开始，将所有元素向后移一个位置
    for (i = 0; i < l->length - p + 1; i++)
    {
        l->data[l->length - i] = l->data[l->length - i - 1]; 
    }

    l->data[p - 1] = e;     //要插入的元素赋给第p-1个元素
    l->length++;            //顺序表长度加1

    return SUCCESS;
}

//初始化条件 结构体存在且被传入函数
//SeLi *l l是一个指针,指针的数据类型是SeLi *,指针指向的类型是SeLi
//p是要删除的元素的位置
//ElemType *e e是要被赋值的元素
//函数功能：删除顺序表中第p个位置的元素，并且用e返回其值
int SequenceDelete(SeLi *l, int p, ElemType *e)
{
    int i;

    if (NULL == l)              //入参判断
    {
        return FAILURE;
    }

    if (p < 1 || p > l->length) //判断要删除的位置是否合法 
    {
        return FAILURE;
    }

    *e = l->data[p - 1];        //将欲删除的元素保留在e中 

    for (i = 0; i < l->length - p; i++)//将第p+1至第l->length位的元素依次向前移动一个位置 
    {
        l->data[p + i - 1] = l->data[p + i];
    }

    l->length--;
                                //表长减一，删除成功返回SUCCESS 
    return SUCCESS;
}

//初始化条件：结构体被传入函数
//SeLi l: l是一个结构体
//函数功能：返回结构体成员length的值，即顺序表的长度
int SequenceLength(SeLi l)
{
    return l.length;
}

//初始化条件：结构体被传入函数
//SeLi l: l是一个结构体
//函数功能：如果顺序表为空，返回TRUE，否则返回FALSE.
int SequenceEmpty(SeLi l)
{
    return (0 == l.length) ? TRUE : FALSE;
}

//初始条件：顺序表已存在
//SeLi l:传入顺序表 
//void(*p)(ElemType):函数指针，指向输出函数
//函数功能：挨个打印顺序表的值
int SequenceTraverse(SeLi l, void(*p)(ElemType))
{
    int i;

    if (NULL == p)                  //入参判断
    {
        return FAILURE;
    }

    for (i = 0; i < l.length; i++) //挨个打印顺序表的值
    {
        p(l.data[i]);
    }

    return SUCCESS;
}

//初始化条件：位置p不小于1或者不大于顺序表的长度
//SeLi l:l是一个结构体
//p是要查看的位置
//ElemType *e是要被赋值的数
//函数功能：将顺序表中第p个位置的元素赋给e
int GetElem(SeLi l, int p, ElemType *e)
{
    //如要要查看的位置小于1，或者大于顺序表的长度，查看失败
    if (p < 1 || p > l.length)  
    {
        return FAILURE;
    }
    
    *e = l.data[p - 1]; //将要查看的位置的值赋给e，（下标和位置差1的关系）

    return SUCCESS;
}

//初始化条件：结构体被传入函数
//SeLi l:l是一个结构体
//e是要查找的元素
//函数功能：在顺序表中查找与给定值e相等的元素，如果找得到，返回位置
int LocateElem(SeLi l, ElemType e)
{
    int i;

    for (i = 0; i < l.length; i++)
    {
        if (e == l.data[i])
        {
            return i + 1;
        }
    }

    return FAILURE;
}

//初始化条件：函数已经存在，且被传入函数
//SeLi *l l是一个指针,指针的数据类型是SeLi *,指针指向的类型是SeLi
//函数功能：清空顺序表
int SequenceListClear(SeLi *l)
{
    if (NULL == l)          //入参判断
    {
        return FAILURE;
    }

    l->length = 0;          //空线性表的长度为0

    return SUCCESS;
}

//初始化条件：结构体已存在，且被传入函数
//SeLi *l l是一个指针,指针的数据类型是SeLi *,指针指向的类型是SeLi
//函数功能：销毁顺序表
//★★记得把指向顺序表的指针变为空指针，光释放会成为野指针
int SequenceListDestroy(SeLi *l)
{
    if (NULL == l)      //入参判断
    {
        return FAILURE;
    }

    l->length = 0;      //先清空顺序表
    free(l->data);      //释放为顺序表分配的空间
    l->data = NULL;     //指针变为空指针

    return SUCCESS;
}