顺序表

List list;

头文件

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);

 

初始化顺序表

参数：指向顺序表结构体的指针

int InitSequence(List *l)

{

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;

}

}

 

 

在顺序表l第p个位置插入元素e

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;

}

List *list;

头文件

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);

 

初始化顺序表

参数：指向顺序表结构体的指针

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;

}

 

向顺序表插入元素

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 ClearSequence(List *l)

{

l->length = 0;

return SUCCESS;

}

 

销毁顺序表

int DestroySequence(List *l)

{

free(l->data);

l->data = NULL;

return SUCCESS;

}