通过结构体指针实现顺序链表的基础操作

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

/*
初始化顺序表
参数：指向顺序表结构体的指针
*/
int InitSequence(List **l)
{
(*l) = (List *)malloc(sizeof(List) * 1);
if (NULL == *l)
{
return FAILURE;
}
(*l)->data = (DataType *)malloc(sizeof(DataType) * SIZE);
if (NULL == (*l)->data)
{
return FAILURE;
}

(*l)->length = 0;

return SUCCESS;
}

/*
判断顺序表是否为空
*/
int EmptySequence(List *l)
{
//return (l.length == 0) ? SUCCESS : FAILURE;

if (0 == l->length)
{
return SUCCESS;
}
else
{
return FAILURE;
}
}

int InsertSequence(List *l, int p, DataType e)
{
int i;

if (NULL == l->data || NULL == l || p <= 0 || p > l->length + 1 || l->length >= SIZE)
{
return FAILURE;
}

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;
l->length++;

return SUCCESS;
}

/*
顺序表遍历
参数：顺序表
函数指针 指向一个void型函数，函数有一个DataType型形参
*/
int TraverseSequence(List *l, void(*p)(DataType))
{
int i;

for (i = 0 ; i < l->length; i++)
{
p(l->data[i]);
}

return SUCCESS;
}

/*
获取指定位置的元素
参数：l  顺序表
p  位置
e  获取的元素
*/
DataType GetElem(List *l, int p, DataType *e)
{
if (p <= 0 || p > l->length)
{
return FAILURE;
}

//*e = l.data[p - 1];
*e = *(l->data + p - 1);

return SUCCESS;
}

/*
查找元素
参数：l 顺序表
e 要查找的元素
p 函数指针
*/
int LocateElem(List *l, DataType e, int(*p)(DataType, DataType))
{
int i;

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

return FAILURE;
}

/*
获取元素的前驱
参数：l 顺序表
e 查找的元素
*/
DataType PriorElem(List *l, DataType e)
{
int i;

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

return FAILURE;
}

/*
获取元素的后继
*/
DataType NextElem(List *l, DataType e)
{
int i;

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

return FAILURE;

}

/*
删除元素
参数：l 指向顺序表的指针
p 要删除元素的位置
e 删除的元素
*/
int DeleteSequence(List *l, int p, DataType *e)
{
int i;
if (NULL == l || p <= 0 || p > l->length)
{
return FAILURE;
}

*e = l->data[p - 1];
for (i = 0; i < l->length - p; i++)
{
l->data[p - 1 + i] = l->data[p + i];
}
l->length--;

return SUCCESS;
}

int LengthSequence(List *l)
{
return (l->length);
}

/*
清空顺序表
*/
int ClearSequence(List *l)
{
l->length = 0;

return SUCCESS;
}

/*
销毁顺序表
*/
int DestroySequence(List **l)
{
free((*l)->data);
free(*l);
*l = NULL;

return SUCCESS;
}

#ifndef _SEQUENCELIST_H_
#define _SEQUENCELIST_H_

#define SIZE       10
#define FAILURE    10000
#define SUCCESS    10001

typedef int DataType;

struct SequenceList
{
DataType *data;
int length;
};
typedef struct SequenceList List;

int InitSequence(List **l);
int EmptySequence(List *l);
int InsertSequence(List *l, int p, DataType e);
int TraverseSequence(List *l, void (*p)(DataType));
DataType GetElem(List *l, int p, DataType *e);
int LocateElem(List *l, DataType e, int(*p)(DataType, DataType));
DataType PriorElem(List *l, DataType e);
DataType NextElem(List *l, DataType e);
int DeleteSequence(List *l, int p, DataType *e);
int LengthSequence(List *l);
int ClearSequence(List *l);
int DestroySequence(List **l);
#endif

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

void visit(DataType e)                   //打印元素，作为函数参数传入
{
printf("%d ", e);
}

int Equal(DataType a, DataType b)
{
return (a == b) ? 1 : 0;
}

int main()
{
int ret, i, p;
List *list;                             //定义一个顺序表
DataType e;

ret = InitSequence(&list);             //初始化顺序表
if (FAILURE == ret)
{
printf("Init Failure!\n");
}
else
{
printf("Init Success!\n");
}

ret = EmptySequence(list);
if (SUCCESS == ret)
{
printf("Sequence Empty!\n");
}
else
{
printf("Sequence not Empty!\n");
}

for (i = 0; i < 8; i++)
{
ret = InsertSequence(list, i + 1, i + 1);  //向顺序表插入元素
if (FAILURE == ret)
{
printf("Insert %d Failure!\n", i + 1);
}
else
{
printf("Insert %d Success!\n", i + 1);
}
}

ret = EmptySequence(list);                   //判断顺序表是否为空
if (SUCCESS == ret)
{
printf("Sequence Empty!\n");
}
else
{
printf("Sequence not Empty!\n");
}

ret = TraverseSequence(list, visit);                 //遍历顺序表
if (FAILURE == ret)
{
printf("Traverse Failure!\n");
}
else
{
printf("\nTraverse Success!\n");
}

p = 13;                         //位置
ret = GetElem(list, p, &e);    //获取指定位置的元素
if (FAILURE == ret)
{
printf("Get %dth Element Failure!\n", p);
}
else
{
printf("%dth Element is %d\n", p, e);
}

e = 14;
ret = LocateElem(list, e, Equal);     //查找元素位置
if (FAILURE == ret)
{
printf("Locate %d Failure!\n", e);
}
else
{
printf("%d is %dth Element!\n", e, ret);
}

e = 12;
ret = PriorElem(list, e);
if (FAILURE == ret)
{
printf("%d has no prior!\n", e);
}
else
{
printf("%d Prior is %d\n", e, ret);
}

e = 8;
ret = NextElem(list, e);
if (FAILURE == ret)
{
printf("%d has no next!\n", e);
}
else
{
printf("%d Next is %d\n", e, ret);
}

for (i = 0; i < 3; i++)
{
ret = DeleteSequence(list, 1, &e);
if (FAILURE == ret)
{
printf("Delete Failure!\n");
}
else
{
printf("Delete %d Success!\n", e);
}
}

ret = TraverseSequence(list, visit);                 //遍历顺序表
if (FAILURE == ret)
{
printf("Traverse Failure!\n");
}
else
{
printf("\nTraverse Success!\n");
}

printf("Sequence Length %d\n", LengthSequence(list));

ret = ClearSequence(list);
if (FAILURE == ret)
{
printf("Clear Failure!\n");
}
else
{
printf("Clear Success!\n");
}

ret = DestroySequence(&list);
if (FAILURE == ret)
{
printf("Destroy Failure!\n");
}
else
{
printf("Destroy Success!\n");
}

for (i = 0; i < 8; i++)
{
ret = InsertSequence(list, i + 1, i + 1);  //向顺序表插入元素
if (FAILURE == ret)
{
printf("Insert %d Failure!\n", i + 1);
}
else
{
printf("Insert %d Success!\n", i + 1);
}
}

return 0;
}