【算法和数据结构】_17_小算法_线性结构：顺序表

/*
本程序用来测试数据结构中的线性结构：顺序表
*/

#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;
    }
}