在介绍功能之前我们先定义一个线性表的结构体:
#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,销毁是释放堆上开辟的空间。
#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,销毁是释放堆上开辟的空间。