通过结构体指针实现顺序链表的基础操作
SequenceList.c文件，主要为main函数，操作步骤
#include
#include "SequenceList.h"
#include
/*
初始化顺序表
参数：指向顺序表结构体的指针
*/
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
#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;
}