/*
本程序用来测试数据结构中的线性结构：顺序表
*/
#include <stdio.h>
#include <stdlib.h>
#define LINEAR_MAX_SIZE 64
struct LinearList
{
int* List; //顺序表指针
unsigned short int ListLen; //顺序表最大的元素个数
unsigned short int CurrentLen; //顺序表当前元素的个数
};
typedef struct LinearList LINEARLIST;
typedef enum {FALSE,TRUE} BOOL;
void CreateLinearList(LINEARLIST* list,int listLen);
void InitLinearList(LINEARLIST* list);
void EchoLinearList(LINEARLIST* list);
void DestroyLinearList(LINEARLIST* list);
BOOL IsLinearListEmpty(LINEARLIST* list);
BOOL IsLinearListFull(LINEARLIST* list);
void ClearLinearList(LINEARLIST* list);
unsigned short int SearchLinearList(LINEARLIST* list,int element);
void AddNodeLinearList(LINEARLIST* list,int elementPos,int elementInsert);
BOOL DeNodeLinearList(LINEARLIST* list,int element);
BOOL GetValueLinearList(LINEARLIST* list,int index,int* retValue);
int main(const int argc, const char* argv[])
{
LINEARLIST list;
list.List=NULL;
list.ListLen=0;
list.CurrentLen=0;
CreateLinearList(&list,10);
InitLinearList(&list);
EchoLinearList(&list);
putchar('\n');
ClearLinearList(&list);
EchoLinearList(&list);
putchar('\n');
getchar();
getchar();
return 0;
}
/*
函数功能：
创建顺序表
函数原型：
void CreateLinearList(LINEARLIST* list,int listLen)
函数参数：
LINEARLIST* list：待创建的顺序表结构体指针
int listLen: 待初始化线性表长度
返回值：
无返回值
异常：
传递空指针
*/
void CreateLinearList(LINEARLIST* list,int listLen)
{
if(NULL==list)
{
exit(0);
}
else
{
list->List=(int*)malloc(sizeof(int)*listLen);
}
if(list->List ==NULL)
{
list->CurrentLen=0;
list->ListLen=0;
exit(0);
}
else
{
list->CurrentLen=0;
list->ListLen=listLen;
}
}
/*
函数功能：
初始化顺序表
函数原型：
void InitLinearList(LINEARLIST* list)
函数参数：
LINEARLIST* list:待初始化的顺序表结构体指针
返回值：
无
异常：
传递空指针
*/
void InitLinearList(LINEARLIST* list)
{
int i;
//实际应用中，这里应该对list是否为空做测试
if(list->CurrentLen!=0)
{
puts("The Linear List is not empty");
return ;
}
else
{
printf("Please input the element for the list,you can enter %d numbers:\n",list->ListLen);
list->CurrentLen++;
while(list->CurrentLen <= list->ListLen)
{
scanf("%d",&i);
list->List[list->CurrentLen-1]=i;
list->CurrentLen++;
}
fflush(stdin);
}
}
/*
函数功能：
打印顺序表
函数原型：
void EchoLinearList(LINEARLIST* list)
函数参数：
LINEARLIST* list:待打印的顺序表结构体指针
返回值：
无
异常：
传递空指针
*/
void EchoLinearList(LINEARLIST* list)
{
unsigned short int i;
//实际应用中，这里应该对list是否为空做测试
if(list->List ==NULL )
{
puts("The list not exist,then will quit");
exit(0);
}
i=0;
while(i< list->CurrentLen-1)
{
printf("%3d ",list->List[i]);
i++;
}
}
/*
函数功能：
销毁顺序表
函数原型：
void DestroyLinearList(LINEARLIST* list)
函数参数：
LINEARLIST* list：待销毁顺序表存储指针
返回值：
无
异常：
传递空指针
*/
void DestroyLinearList(LINEARLIST* list)
{
if(list==NULL )
{
puts("There is not a list to destroy");
exit(0);
}
if(list->List != NULL)
{
free(list->List);
list->CurrentLen=0;
list->ListLen=0;
}
}
/*
函数功能：
测试顺序表是否为空
函数原型：
BOOL IsLinearListEmpty(LINEARLIST* list)
函数参数：
LINEARLIST* list:待测试顺序表指针
返回值：
如果为空则返回TURE，否则返回FALSE;
异常：
传递空指针
*/
BOOL IsLinearListEmpty(LINEARLIST* list)
{
//实际应用中，需测试list是否为空
if(list->List!=NULL &&list->CurrentLen !=0)
{
return TRUE;
}
else
{
return FALSE;
}
}
/*
函数功能：
测试顺序表是否满
函数原型：
BOOL IsLinearListFull(LINEARLIST* list)
函数参数：
LINEARLIST* list：待测试顺序表指针
返回值：
如果满返回TRUE
*/
BOOL IsLinearListFull(LINEARLIST* list)
{
//实际应用，需要测试list是否为空
if(list->List !=NULL && list->CurrentLen == list->ListLen)
{
return TRUE;
}
else
{
return FALSE;
}
}
/*
函数功能：
将顺序表的元素全部赋值为0
函数原型：
void ClearLinearList(LINEARLIST* list)
函数参数：
LINEARLIST* list：待处理顺序表指针
返回值：
无
异常：
传递空指针
*/
void ClearLinearList(LINEARLIST* list)
{
int i;
//实际应用中，应该对list是否为空进行测试
if(list->List ==NULL)
{
puts("There is not a list to clear");
exit(0);
}
else
{
i=0;
while(i<list->CurrentLen )
{
list->List [i]=0;
i++;
}
}
}
/*
函数功能：
搜索顺序表中是否存在某个元素
函数原型：
unsigned short int SearchLinearList(LINEARLIST* list,int element)
函数参数：
LINEARLIST* list：元素待查找所在的顺序表指针
int element：待查找元素
返回值：
如果存在则返回元素的位置，否则返回0
异常：
传递空指针
*/
unsigned short int SearchLinearList(LINEARLIST* list,int element)
{
int i;
//实际应用需要对list是否为空进行测试
if(list->List !=NULL && list->ListLen!=0)
{
for(i=0;i<list->CurrentLen;i++)
{
if(!(list->List[i] ^ element))
{
return i+1;
}
}
}
return 0;
}
/*
函数功能：
在顺序表中插入新的元素
1、如果存在指定的元素，则将新元素插入到指定元素之后
2、如果不存在指定的元素，则插入到顺序表最后
3、如果顺序表已满则不插入
4、如果顺序表为空，则将元素作为顺序表的第一个元素
函数原型：
void AddNodeLinearList(LINEARLIST* list,int elementPos,int elementInsert)
函数参数：
LINEARLIST* list：待插入元素的顺序表指针
int elementPos：指定元素
int elementInsert：待插入元素
返回值：
无返回值
异常：
传递空指针
*/
void AddNodeLinearList(LINEARLIST* list,int elementPos,int elementInsert)
{
//实际应用中，需测试list是否为空
int i,
j;
//已满，不插入
if(IsLinearListFull(list))
{
puts("The sequnue list is full");
return ;
}
//空表，插入到第一个元素位置处
if(IsLinearListEmpty(list))
{
list->CurrentLen=1;
list->List [0]=elementInsert;
}
i=SearchLinearList(list,elementPos);
if(!i)
{
//不存在指定元素
list->List[list->CurrentLen ]=elementInsert;
list->CurrentLen ++;
}
else
{
//存在指定元素
j=list->CurrentLen;
while(j>i)
{
list->List[j]=list->List[j-1];
j--;
}
list->List[i]=elementInsert;
list->CurrentLen ++;
}
return ;
}
/*
函数功能：
删除顺序表中指定的元素
1、如果是空表则不删除
2、如果不存在指定元素，则不删除
函数原型：
BOOL DeNodeLinearList(LINEARLIST* list,int element)
函数参数：
LINEARLIST* list：待处理的顺序表指针
int element：待删除的指定元素
返回值：
TRUE：成功删除元素
FALSE：未成功删除元素
异常：
传递空指针
*/
BOOL DeNodeLinearList(LINEARLIST* list,int element)
{
//实际应用中，需测试list是否为空
int i,
j;
//如果是空表则返回FALSE
if( IsLinearListEmpty(list))
{
return FALSE;
}
while(i=SearchLinearList(list,element))
{
j=i-1;
while(j<list->CurrentLen)
{
list->List[j]=list->List[j+1];
j++;
}
list->CurrentLen --;
}
return TRUE;
}
/*
函数功能：
返回指定索引位置处的值
函数原型：
int GetValueLinearList(LINEARLIST* list,int index)
函数参数：
LINEARLIST* list：待处理的顺序表的指针
int index：指定的索引位置
int* retValue:存储指定位置的值
返回值：
如果成功索引则返回TRUE，否则返回FALSE，并且将retValue置为0
异常：
传递空指针
*/
BOOL GetValueLinearList(LINEARLIST* list,int index,int* retValue)
{
//实际应用中，需测试list是否为空
if(IsLinearListEmpty(list)|| index > list->CurrentLen )
{
*retValue=0;
return FALSE;
}
else
{
*retValue=list->List[index-1];
return TRUE;
}
}
