线性表基本功能实现

在介绍功能之前我们先定义一个线性表的结构体：
#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;
#endif
这个结构体中有一个存储表中元素的指针变量data,还有一个整型变量length，用来表示线性表元素的个数。


在main函数中我们主要需要定义一个结构体变量和一个整型变量ret去接子函数的结果。
#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;
}
介绍完这些后我们开始用子函数来实现线性表的一些功能。
一． 线性表的初始化：
这个功能就是将线性表的length置为0。
/*
初始化顺序表
参数：指向顺序表结构体的指针
*/
int InitSequence(List *l)
{
l->data = (DataType *)malloc(sizeof(DataType) * SIZE);
if (NULL == l->data)
{
return FAILURE;
}


l->length = 0;


return SUCCESS;
}
结构体的data指针变量是一个野指针，所以需要malloc来分配内存。


二． 判断线性表是否为空：
只要判断length是否为空就行了。
/*
判断顺序表是否为空
*/
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);
l->data = NULL;


return SUCCESS;
}


注意：销毁和清空的区别：
 清空是将length置为0，销毁是释放堆上开辟的空间。