线性表的实现

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 64  //宏定义
typedef int datatype;
//线性表的结构体定义，连续存储空间，last用于表明最后一个数据元素的存储元素
typedef struct list
{
//线性表是一个连续存储空间，用数组表示
    datatype data[N];
//连续存储空间，last用于表明最后一个数据元素的存储元素
    int last;
}sqlist;//tyedef关键字表示 sqlist替代 struct sqlist 
//给线性结构分配空间
sqlist * creat_list();
//为线性结构插入元素(在线性空间的最后一个元素之后插入)
int insert_list(sqlist * L,datatype value);//函数第一个形参需传入结构体指针，第二个形参传入的是插入的元素值
//判断线性结构是否满
int full_list(sqlist * L);
//打印输出线性结构内容
void show_list(sqlist * L);
//删除线性结构元素,删除线性空间最后一个元素
int del_list(sqlist * L);
//判断线性结构是否为空
int empty_list(sqlist * L);
//向线性结构按位置插入元素  需传入的参数为 构造体，插入位置，插入元素值
int add_pos_list(sqlist * L ,int pos,datatype value);
//删除指定位置元素
int del_pos_list(sqlist * L,int pos);
//根据数值更改数据元素
int change_bynum(sqlist * L,datatype old,datatype new);
//查找元素
int find_list(sqlist * L, datatype value);
//查找元素，删除重复项，比如输入1234554321，执行此函数之后是12345
void purge_list(sqlist *L);
void unio_list(sqlist *L1,sqlist *L2);
//L1和L2两个线性表，将两个线性表拼接在一起，比如L1：12345，
//L2：345678，执行函数结果为L1：12345678， L2：345678
int main(int argc, const char *argv[])
{
    //定义sqlist结构体指针，并将由creat_list()开辟的内存空间首地址赋值给指针L
    sqlist * L1 = creat_list();
    sqlist * L2 = creat_list();
    //判断是否成功调用creat_list()
    if((L1=creat_list()) == NULL)
    {
        printf("函数调用失败");
        //如果满足判断条件，表示creat_list()调用失败，返回值为-1，函数结束
        return -1;
    }
    if((L2=creat_list()) == NULL)
    {
        printf("函数调用失败");
        //如果满足判断条件，表示creat_list()调用失败，返回值为-1，函数结束
        return -1;
    }
    insert_list(L1,1);
    insert_list(L1,2);
    insert_list(L1,3);
    insert_list(L1,4);
    insert_list(L1,5);
    insert_list(L1,7);
    insert_list(L1,8);
    insert_list(L2,1);
    insert_list(L2,3);
    insert_list(L2,4);
    insert_list(L2,5);
    insert_list(L2,9);
    insert_list(L2,2);
    insert_list(L2,8);
    unio_list(L1,L2);
    show_list(L1);
    show_list(L2);
    free(L1);
    free(L2);
    return 0;
}

//给线性结构分配空间
sqlist * creat_list()
{
    sqlist * L = NULL;
    //sizeof表示结构体所占用的字节数，malloc该函数分配了的字节数，并返回了指向这块内存的指针。如果分配失败，则返回一个空指针（NULL）
    L = (sqlist *)malloc(sizeof(sqlist));
    //如果分配空间失败，返回以下内容
    if (NULL == L)
    {
        printf("空间创建失败\n");
        return NULL;
    }
    L->last = -1;
    //需要返回值类型为结构体指针
    return L;
}

//为线性结构插入元素
int insert_list(sqlist * L,datatype value)
{
    //判断线性体元素是否已满
    if(full_list(L))
    {
        printf("线性结构已存满\n");
    insert_list(L,1);
        return -1;
    }
    //L->last表示结构体中的last的值
    L->data[L->last+1]=value;
//连续存储空间，last用于表明最后一个数据元素的存储元素
    L->last++;
    return 0;
}
//判断线性表是否满
int full_list(sqlist * L)
{
    //last从0开始，需要<N-1，当等于N-1时表示表空间已满
    return L->last==N-1?1:0;
}

//打印输出线性结构内容
void show_list(sqlist * L)
{
    int i;
    //遍历结构体
    for(i = 0; i <= L->last; i++)
    {
        printf("%d ",L->data[i]);
    }
    printf("\n");
}

//删除线性结构元素
int del_list(sqlist * L)
{
    //判断线性表是否满
    if(empty_list(L))
    {
        printf("线性空间已空，没有元素");
        return -1;
    }
    if(empty_list(L))
    L->last--;
    return 0;
}

//判断线性结构是否为空
int empty_list(sqlist * L)
{
    return L->last == -1 ?1:0;
}

//向线性结构按位置插入元素
int add_pos_list(sqlist * L ,int pos,datatype value)
{
    int i;
    if(full_list(L))
    {
        printf("线性结构已存满\n");
        return -1;
    }
    if(pos < 0||pos > L->last+1)
    {//判断如果所查找位置已超出线性表空间，注意在last+1（即在最后一个元素之后插入也满足线性表）
        printf("超出范围，插入失败\n");
        return -1;
    }
    for(i = L->last+1; i > pos; i--)
    {
        L->data[i] = L->data[i-1];
    }
    L->data[pos] = value;
    L->last++;
    return 0;
}

//删除指定位置元素
int del_pos_list(sqlist * L,int pos)
{
    int i;
    //判断线性表是否为空
    if(empty_list(L))
    {
        printf("线性空间为空，无法删除\n");
        return -1;
    }
    if(pos < 0 || pos >L->last)
    {
        printf("超出范围，无法删除\n");
        return -1;
    }
    for(i = pos; i < L->last; i++)
    {
        L->data[i] = L->data[i+1];
    }
    L->last--;
    return 0;
}


//根据数值更改数据元素，根据特定值进行替换
int change_bynum(sqlist * L,datatype old, datatype new)
{
    int i;
    for(i = 0; i <= L->last;i++)
    {
        if(old == L->data[i])
        {
            L->data[i] = new;
        }
    }
    return 0;
}


//查找元素，根据特定值
int find_list(sqlist * L, datatype value)
{
    int i;
    for(i = 0; i <= L->last;i++)
    {
        if(L->data[i] == value)
            return 1;
    }
    return 0;
}
//查找元素，删除重复项，比如输入1234554321，执行此函数之后是12345
void purge_list(sqlist *L)
{
    int i,j;
    for(i = 0; i < L->last; i++)
    {
        for(j = i + 1; j <=L->last; j++)
        {
            if(L->data[i] == L->data[j])
            {
                del_pos_list(L,j);
                j--;
            }
        }
    }
}


//L2：345678，执行函数结果为L1：12345678， L2：345678
//L1和L2两个线性表，将两个线性表拼接在一起，比如L1：12345，
void unio_list(sqlist *L1,sqlist *L2)
{
    int i,j;
    for(i = 0; i <= L2->last; i++)
    {
        if(find_list(L1,L2->data[i]) == 0)
        {
            insert_list(L1,L2->data[i]);
        }
    }
}