线性表的顺序表示和实现

最新推荐文章于 2024-11-14 21:21:03 发布
最新推荐文章于 2024-11-14 21:21:03 发布
阅读量255 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62353814/article/details/130094323
版权

文章目录

前言

本文基于严蔚敏老师的《数据结构（C语言版）》（清华大学出版社）一书，将原书中使用C++编写的顺序表基本操作进行了C语言版本的重写，在CodeBlocks的C语言运行环境下测试无错误。

预定义常量和类型、结构体定义、函数声明

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
//预定义常量
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
#define OVERFLOW    -2
//预定义类型
typedef int Status;
typedef int ElemType;

/*---线性表的动态分配顺序存储结构定义---*/
#define LIST_INIT_SIZE  100                     //线性表存储空间的初始分配量
#define LISTINCREMENT   10                      //线性表存储空间的分配增量
typedef struct
{
	ElemType *elem;                 //存储空间基地址
	int     length;                 //当前长度
	int     listsize;               //当前分配的存储容量（以sizeof(ElemType)为单位）
}SqList;

/*全局变量定义*/
ElemType *p,*q;
//函数声明
Status InitList_Sq(SqList** L);                             //构造一个空的线性表L
Status DestroyList_Sq(SqList** L);                          //销毁线性表L
Status ClearList_Sq(SqList** L);                            //将线性表L重置为空表
Status ListEmpty_Sq(SqList L);                              //判定L是否为空表,是返回TRUE，否则返回FALSE
Status ListLength_Sq(SqList L);                             //求L的长度,返回L中数据元素个数
Status GetElem_Sq(SqList L, int i, ElemType *e);            //用e返回L中第i个数据元素的值
Status LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType x, ElemType y));         //在顺序表L中查找第1个与e满足关系compare()的数据元素的位序
//3个compare函数
Status greater(ElemType x, ElemType y);
Status equal(ElemType x, ElemType y);
Status less(ElemType x, ElemType y);
Status PriorElem_Sq(SqList L, ElemType cur_e, ElemType *pre_e);                                 //寻找cur_e的直接前驱
Status NextElem_Sq(SqList L, ElemType cur_e, ElemType *next_e);                                 //寻找cur_e的直接后继
Status ListInsert_Sq(SqList** L, int i, ElemType e);                                            //在顺序表中第i个位置之前插入新的数据元素e
Status ListDelete_Sq(SqList** L, int i, ElemType *e);                                           //删除顺序表的第i个数据元素，并用e返回其值
Status ListTraverse_Sq(SqList** L, Status (*visit)(ElemType e));                                //依次对L的每个数据元素调用函数visit()，一旦vixit()失败，则操作失败
//visit函数
Status Print(ElemType e);

测试主函数

int main()
{
    int i,j=10,k=18;
    ElemType e,pre_e,next_e;
    SqList Sq;          //创建结构体变量Sq
    SqList *L = &Sq;    //创建结构体指针L
    if(InitList_Sq(&L))
        printf("顺序表构造成功！\n");
    printf("该顺序表的长度为%d\n",ListLength_Sq(Sq));
    if(ListEmpty_Sq(Sq))
        printf("······\n该顺序表为空表！\n");
    else
        printf("······\n该顺序表不是空表！\n");
    for(i=0;i<L->listsize;i++)
    {
        L->elem[i] = i+1;
        L->length++;
    }
    printf("赋值成功！\n");
    if(ListEmpty_Sq(Sq))
        printf("······\n该顺序表为空表！\n");
    else
        printf("······\n该顺序表不是空表！\n");
    printf("该顺序表的长度为%d\n",ListLength_Sq(Sq));
    GetElem_Sq(Sq,j,&e);
    printf("顺序表中第%d个数据元素的值为%d\n",j,e);
    printf("第一个大于e的元素的位序为%d\n",LocateElem_Sq(Sq,e,greater));
    printf("第一个等于e的元素的位序为%d\n",LocateElem_Sq(Sq,e,equal));
    printf("第一个小于e的元素的位序为%d\n",LocateElem_Sq(Sq,e,less));
    if(ClearList_Sq(&L))
        printf("顺序表重置成功！\n");
    printf("该顺序表的长度为%d\n",ListLength_Sq(Sq));
    if(ListEmpty_Sq(Sq))
        printf("······\n该顺序表为空表！\n");
    else
        printf("······\n该顺序表不是空表！\n");
    for(i=0;i<L->listsize;i++)
    {
        L->elem[i] = i+1;
        L->length++;
    }
    printf("赋值成功！\n");
    if(ListEmpty_Sq(Sq))
        printf("······\n该顺序表为空表！\n");
    else
        printf("······\n该顺序表不是空表！\n");
    printf("该顺序表的长度为%d\n",ListLength_Sq(Sq));
    PriorElem_Sq(Sq,k,&pre_e);
    printf("%d的直接前驱为%d\n",k,pre_e);
    NextElem_Sq(Sq,k,&next_e);
    printf("%d的直接后继为%d\n",k,next_e);
    printf("在顺序表中第%d个位置之前插入新的数据元素%d\n",k,e);
    ListInsert_Sq(&L,k,e);
    printf("修改后的顺序表为：\n");
    for(i=0;i<L->length;i++)
    {
        printf("%d\t",L->elem[i]);
    }
    printf("\n删除顺序表的第%d个数据元素\n",k);
    ListDelete_Sq(&L,k,&e);
    printf("被删除的元素为%d\n",e);
    printf("修改后的顺序表为：\n");
    for(i=0;i<L->length;i++)
    {
        printf("%d\t",L->elem[i]);
    }
    printf("\n依次对顺序表的每个数据元素调用函数Print()，做输出操作：\n");
    ListTraverse_Sq(&L,Print);
    printf("\n操作完成，对顺序表进行销毁。\n");
    if(DestroyList_Sq(&L))
        printf("顺序表销毁成功！\n");
    return 0;
}

各基本操作的功能实现

//函数功能：构造一个空的线性表L
//函数参数：结构体指针L
//返回值：成功返回OK，失败返回OVERFLOW
Status InitList_Sq(SqList** L)
{
    (*L)->elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if(!(*L)->elem)     exit(OVERFLOW);         //存储分配失败
    (*L)->length = 0;                           //空表长度为0
    (*L)->listsize = LIST_INIT_SIZE;            //初始存储容量
    return OK;
}
//函数功能：销毁线性表L
//函数参数：二级结构体指针L
//返回值：成功返回OK，失败返回ERROR
Status DestroyList_Sq(SqList** L)
{
    free((*L)->elem);
    (*L)->elem = NULL;
    (*L)->length = 0;
    (*L)->listsize = 0;
    if(!(*L)->elem)
        return OK;
    else
        return ERROR;
}
//函数功能：将线性表L重置为空表
//函数参数：二级结构体指针L
//返回值：成功返回OK
Status ClearList_Sq(SqList** L)
{
    (*L)->length = 0;
    return OK;
}
//函数功能：判定L是否为空表
//函数参数：顺序表L
//返回值：是返回TRUE，否返回FALSE
Status ListEmpty_Sq(SqList L)
{
    if(L.length == 0)   return TRUE;
    else    return FALSE;
}
//函数功能：求L的长度
//函数参数：顺序表L
//返回值：返回L中数据元素个数
Status ListLength_Sq(SqList L)
{
    return L.length;
}
//函数功能：用e返回L中第i个数据元素的值
//函数参数：顺序表L，整型变量i，ElemType类型指针e
//返回值：L中第i个元素的值
Status GetElem_Sq(SqList L, int i, ElemType *e)
{
    *e = L.elem[i-1];
    return OK;
}
//函数功能：在顺序表L中查找第1个与e满足关系compare()的数据元素的位序
//函数参数：结构体变量L，ElemType类型变量e，函数指针compare
//返回值：成功返回相应位序，失败返回0
Status LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType x, ElemType y))
{
    int i=1;                        //i的初值为第一个元素的位序
    p = L.elem;                     //p的初值为第一个元素的存储位置
    while(i<=L.length && !(*compare)(*p++,e))    ++i;
    if(i<= L.length)    return i;
    else    return 0;
}
Status greater(ElemType x, ElemType y)      //寻找第一个大于e的元素
{
    if(x > y) return TRUE;
    else    return FALSE;
}
Status equal(ElemType x, ElemType y)        //寻找第一个等于e的元素
{
    if(x == y) return TRUE;
    else    return FALSE;
}
Status less(ElemType x, ElemType y)         //寻找第一个小于e的元素
{
    if(x < y) return TRUE;
    else    return FALSE;
}
//函数功能：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的直接前驱，否则操作失败，pre_e无定义
//函数参数：结构体变量L，ElemType类型变量cur_e，ElemType类型指针pre_e
//返回值：成功返回OK，失败返回ERROR
Status PriorElem_Sq(SqList L, ElemType cur_e, ElemType *pre_e)
{
    int i;
    for(i = 0;i < L.length;i++)
    {
        if(L.elem[i] == cur_e)
        {
            break;
        }
    }
    if (i == 0 || i == L.length)
    {
        if(i == 0)
        {
            printf("该元素没有前驱捏\n");
        }
        else
        {
            printf("该元素不是L的数据元素捏\n");
        }
        return ERROR;
    }
    *pre_e = L.elem[i - 1];
    return OK;
}
//函数功能：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的直接后继，否则操作失败，next_e无定义
//函数参数：结构体变量L，ElemType类型变量cur_e，ElemType类型指针next_e
//返回值：成功返回OK，失败返回ERROR
Status NextElem_Sq(SqList L, ElemType cur_e, ElemType *next_e)
{
    int i;
    for(i = 0;i < L.length;i++)
    {
        if(L.elem[i] == cur_e)
        {
            break;
        }
    }
    if (i == L.length-1 || i == L.length)
    {
        if(i == L.length-1)
        {
            printf("该元素没有直接后驱捏\n");
        }
        else
        {
            printf("该元素不是L的数据元素捏\n");
        }
        return ERROR;
    }
    *next_e = L.elem[i + 1];
    return OK;
}
//函数功能：在顺序表中第i个位置之前插入新的数据元素e
//函数参数：二级结构体指针L，整型变量i，ElemType变量e
//返回值：成功返回OK，失败返回ERROR或OVERFLOW
Status ListInsert_Sq(SqList** L, int i, ElemType e)
{
    if(i<1 || i>(*L)->length+1)     return ERROR;               //i值不合法,i的合法值为1<= i <=ListLength_Sq(L)+1
    if((*L)->length >= (*L)->listsize)                              //当前存储空间已满，增加分配
    {
        (*L)->elem = (ElemType *)realloc((*L)->elem, ((*L)->listsize + LISTINCREMENT) * sizeof(ElemType));          //新基地址
        if(!(*L)->elem)     exit(OVERFLOW);                     //存储分配失败
        (*L)->listsize += LISTINCREMENT;                        //增加存储容量
    }
    q = &((*L)->elem[i-1]);                                     //用指针q记录插入位置的地址
    for(p = &((*L)->elem[(*L)->length-1]);p>=q;--p)     *(p+1) = *p;                //插入位置及之后的元素右移
    *q = e;                                                 //插入e
    ++(*L)->length;                                             //线性表长度增加1
    return OK;
}
//函数功能：删除顺序表的第i个数据元素，并用e返回其值
//函数参数：二级结构体指针L，整型变量i，ElemType类型变量e
//返回值：成功返回OK，失败返回ERROR
Status ListDelete_Sq(SqList** L, int i, ElemType *e)
{
    if(i<1 || i>(*L)->length+1)     return ERROR;               //i值不合法
    p = &((*L)->elem[i-1]);                                      //p为被删除元素的位置
    *e = *p;                                                     //被删除元素的值赋给e
    q = (*L)->elem+(*L)->length-1;                              //表尾元素的位置
    for(++p;p<=q;++p)   *(p-1) = *p;                            //被删除元素之后的元素左移
    --(*L)->length;                                             //表长减1
    return OK;
}
//函数功能：依次对L的每个数据元素调用函数visit()，一旦vixit()失败，则操作失败
//函数参数：二级结构体指针L，Status类型函数指针visit
//返回值：成功返回OK
Status ListTraverse_Sq(SqList** L, Status (*visit)(ElemType e))
{
    int i;
    for(i=0;i<(*L)->length;i++)
    {
        (*visit)((*L)->elem[i]);
    }
    return OK;
}

Status Print(ElemType e)
{
    printf("%d\t",e);
    return OK;
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
//预定义常量
#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
#define OVERFLOW    -2
//预定义类型
typedef int Status;
typedef int ElemType;

/*---线性表的动态分配顺序存储结构定义---*/
#define LIST_INIT_SIZE  100                     //线性表存储空间的初始分配量
#define LISTINCREMENT   10                      //线性表存储空间的分配增量
typedef struct
{
	ElemType *elem;                 //存储空间基地址
	int     length;                 //当前长度
	int     listsize;               //当前分配的存储容量（以sizeof(ElemType)为单位）
}SqList;

/*全局变量定义*/
ElemType *p,*q;
//函数声明
Status InitList_Sq(SqList** L);                             //构造一个空的线性表L
Status DestroyList_Sq(SqList** L);                          //销毁线性表L
Status ClearList_Sq(SqList** L);                            //将线性表L重置为空表
Status ListEmpty_Sq(SqList L);                              //判定L是否为空表,是返回TRUE，否则返回FALSE
Status ListLength_Sq(SqList L);                             //求L的长度,返回L中数据元素个数
Status GetElem_Sq(SqList L, int i, ElemType *e);            //用e返回L中第i个数据元素的值
Status LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType x, ElemType y));         //在顺序表L中查找第1个与e满足关系compare()的数据元素的位序
//3个compare函数
Status greater(ElemType x, ElemType y);
Status equal(ElemType x, ElemType y);
Status less(ElemType x, ElemType y);
Status PriorElem_Sq(SqList L, ElemType cur_e, ElemType *pre_e);                                 //寻找cur_e的直接前驱
Status NextElem_Sq(SqList L, ElemType cur_e, ElemType *next_e);                                 //寻找cur_e的直接后继
Status ListInsert_Sq(SqList** L, int i, ElemType e);                                            //在顺序表中第i个位置之前插入新的数据元素e
Status ListDelete_Sq(SqList** L, int i, ElemType *e);                                           //删除顺序表的第i个数据元素，并用e返回其值
Status ListTraverse_Sq(SqList** L, Status (*visit)(ElemType e));                                //依次对L的每个数据元素调用函数visit()，一旦vixit()失败，则操作失败
//visit函数
Status Print(ElemType e);

int main()
{
    int i,j=10,k=18;
    ElemType e,pre_e,next_e;
    SqList Sq;          //创建结构体变量Sq
    SqList *L = &Sq;    //创建结构体指针L
    if(InitList_Sq(&L))
        printf("顺序表构造成功！\n");
    printf("该顺序表的长度为%d\n",ListLength_Sq(Sq));
    if(ListEmpty_Sq(Sq))
        printf("······\n该顺序表为空表！\n");
    else
        printf("······\n该顺序表不是空表！\n");
    for(i=0;i<L->listsize;i++)
    {
        L->elem[i] = i+1;
        L->length++;
    }
    printf("赋值成功！\n");
    if(ListEmpty_Sq(Sq))
        printf("······\n该顺序表为空表！\n");
    else
        printf("······\n该顺序表不是空表！\n");
    printf("该顺序表的长度为%d\n",ListLength_Sq(Sq));
    GetElem_Sq(Sq,j,&e);
    printf("顺序表中第%d个数据元素的值为%d\n",j,e);
    printf("第一个大于e的元素的位序为%d\n",LocateElem_Sq(Sq,e,greater));
    printf("第一个等于e的元素的位序为%d\n",LocateElem_Sq(Sq,e,equal));
    printf("第一个小于e的元素的位序为%d\n",LocateElem_Sq(Sq,e,less));
    if(ClearList_Sq(&L))
        printf("顺序表重置成功！\n");
    printf("该顺序表的长度为%d\n",ListLength_Sq(Sq));
    if(ListEmpty_Sq(Sq))
        printf("······\n该顺序表为空表！\n");
    else
        printf("······\n该顺序表不是空表！\n");
    for(i=0;i<L->listsize;i++)
    {
        L->elem[i] = i+1;
        L->length++;
    }
    printf("赋值成功！\n");
    if(ListEmpty_Sq(Sq))
        printf("······\n该顺序表为空表！\n");
    else
        printf("······\n该顺序表不是空表！\n");
    printf("该顺序表的长度为%d\n",ListLength_Sq(Sq));
    PriorElem_Sq(Sq,k,&pre_e);
    printf("%d的直接前驱为%d\n",k,pre_e);
    NextElem_Sq(Sq,k,&next_e);
    printf("%d的直接后继为%d\n",k,next_e);
    printf("在顺序表中第%d个位置之前插入新的数据元素%d\n",k,e);
    ListInsert_Sq(&L,k,e);
    printf("修改后的顺序表为：\n");
    for(i=0;i<L->length;i++)
    {
        printf("%d\t",L->elem[i]);
    }
    printf("\n删除顺序表的第%d个数据元素\n",k);
    ListDelete_Sq(&L,k,&e);
    printf("被删除的元素为%d\n",e);
    printf("修改后的顺序表为：\n");
    for(i=0;i<L->length;i++)
    {
        printf("%d\t",L->elem[i]);
    }
    printf("\n依次对顺序表的每个数据元素调用函数Print()，做输出操作：\n");
    ListTraverse_Sq(&L,Print);
    printf("\n操作完成，对顺序表进行销毁。\n");
    if(DestroyList_Sq(&L))
        printf("顺序表销毁成功！\n");
    return 0;
}
//函数功能：构造一个空的线性表L
//函数参数：结构体指针L
//返回值：成功返回OK，失败返回OVERFLOW
Status InitList_Sq(SqList** L)
{
    (*L)->elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    if(!(*L)->elem)     exit(OVERFLOW);         //存储分配失败
    (*L)->length = 0;                           //空表长度为0
    (*L)->listsize = LIST_INIT_SIZE;            //初始存储容量
    return OK;
}
//函数功能：销毁线性表L
//函数参数：二级结构体指针L
//返回值：成功返回OK，失败返回ERROR
Status DestroyList_Sq(SqList** L)
{
    free((*L)->elem);
    (*L)->elem = NULL;
    (*L)->length = 0;
    (*L)->listsize = 0;
    if(!(*L)->elem)
        return OK;
    else
        return ERROR;
}
//函数功能：将线性表L重置为空表
//函数参数：二级结构体指针L
//返回值：成功返回OK
Status ClearList_Sq(SqList** L)
{
    (*L)->length = 0;
    return OK;
}
//函数功能：判定L是否为空表
//函数参数：顺序表L
//返回值：是返回TRUE，否返回FALSE
Status ListEmpty_Sq(SqList L)
{
    if(L.length == 0)   return TRUE;
    else    return FALSE;
}
//函数功能：求L的长度
//函数参数：顺序表L
//返回值：返回L中数据元素个数
Status ListLength_Sq(SqList L)
{
    return L.length;
}
//函数功能：用e返回L中第i个数据元素的值
//函数参数：顺序表L，整型变量i，ElemType类型指针e
//返回值：L中第i个元素的值
Status GetElem_Sq(SqList L, int i, ElemType *e)
{
    *e = L.elem[i-1];
    return OK;
}
//函数功能：在顺序表L中查找第1个与e满足关系compare()的数据元素的位序
//函数参数：结构体变量L，ElemType类型变量e，函数指针compare
//返回值：成功返回相应位序，失败返回0
Status LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType x, ElemType y))
{
    int i=1;                        //i的初值为第一个元素的位序
    p = L.elem;                     //p的初值为第一个元素的存储位置
    while(i<=L.length && !(*compare)(*p++,e))    ++i;
    if(i<= L.length)    return i;
    else    return 0;
}
Status greater(ElemType x, ElemType y)      //寻找第一个大于e的元素
{
    if(x > y) return TRUE;
    else    return FALSE;
}
Status equal(ElemType x, ElemType y)        //寻找第一个等于e的元素
{
    if(x == y) return TRUE;
    else    return FALSE;
}
Status less(ElemType x, ElemType y)         //寻找第一个小于e的元素
{
    if(x < y) return TRUE;
    else    return FALSE;
}
//函数功能：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的直接前驱，否则操作失败，pre_e无定义
//函数参数：结构体变量L，ElemType类型变量cur_e，ElemType类型指针pre_e
//返回值：成功返回OK，失败返回ERROR
Status PriorElem_Sq(SqList L, ElemType cur_e, ElemType *pre_e)
{
    int i;
    for(i = 0;i < L.length;i++)
    {
        if(L.elem[i] == cur_e)
        {
            break;
        }
    }
    if (i == 0 || i == L.length)
    {
        if(i == 0)
        {
            printf("该元素没有前驱捏\n");
        }
        else
        {
            printf("该元素不是L的数据元素捏\n");
        }
        return ERROR;
    }
    *pre_e = L.elem[i - 1];
    return OK;
}
//函数功能：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的直接后继，否则操作失败，next_e无定义
//函数参数：结构体变量L，ElemType类型变量cur_e，ElemType类型指针next_e
//返回值：成功返回OK，失败返回ERROR
Status NextElem_Sq(SqList L, ElemType cur_e, ElemType *next_e)
{
    int i;
    for(i = 0;i < L.length;i++)
    {
        if(L.elem[i] == cur_e)
        {
            break;
        }
    }
    if (i == L.length-1 || i == L.length)
    {
        if(i == L.length-1)
        {
            printf("该元素没有直接后驱捏\n");
        }
        else
        {
            printf("该元素不是L的数据元素捏\n");
        }
        return ERROR;
    }
    *next_e = L.elem[i + 1];
    return OK;
}
//函数功能：在顺序表中第i个位置之前插入新的数据元素e
//函数参数：二级结构体指针L，整型变量i，ElemType变量e
//返回值：成功返回OK，失败返回ERROR或OVERFLOW
Status ListInsert_Sq(SqList** L, int i, ElemType e)
{
    if(i<1 || i>(*L)->length+1)     return ERROR;               //i值不合法,i的合法值为1<= i <=ListLength_Sq(L)+1
    if((*L)->length >= (*L)->listsize)                              //当前存储空间已满，增加分配
    {
        (*L)->elem = (ElemType *)realloc((*L)->elem, ((*L)->listsize + LISTINCREMENT) * sizeof(ElemType));          //新基地址
        if(!(*L)->elem)     exit(OVERFLOW);                     //存储分配失败
        (*L)->listsize += LISTINCREMENT;                        //增加存储容量
    }
    q = &((*L)->elem[i-1]);                                     //用指针q记录插入位置的地址
    for(p = &((*L)->elem[(*L)->length-1]);p>=q;--p)     *(p+1) = *p;                //插入位置及之后的元素右移
    *q = e;                                                 //插入e
    ++(*L)->length;                                             //线性表长度增加1
    return OK;
}
//函数功能：删除顺序表的第i个数据元素，并用e返回其值
//函数参数：二级结构体指针L，整型变量i，ElemType类型变量e
//返回值：成功返回OK，失败返回ERROR
Status ListDelete_Sq(SqList** L, int i, ElemType *e)
{
    if(i<1 || i>(*L)->length+1)     return ERROR;               //i值不合法
    p = &((*L)->elem[i-1]);                                      //p为被删除元素的位置
    *e = *p;                                                     //被删除元素的值赋给e
    q = (*L)->elem+(*L)->length-1;                              //表尾元素的位置
    for(++p;p<=q;++p)   *(p-1) = *p;                            //被删除元素之后的元素左移
    --(*L)->length;                                             //表长减1
    return OK;
}
//函数功能：依次对L的每个数据元素调用函数visit()，一旦vixit()失败，则操作失败
//函数参数：二级结构体指针L，Status类型函数指针visit
//返回值：成功返回OK
Status ListTraverse_Sq(SqList** L, Status (*visit)(ElemType e))
{
    int i;
    for(i=0;i<(*L)->length;i++)
    {
        (*visit)((*L)->elem[i]);
    }
    return OK;
}

Status Print(ElemType e)
{
    printf("%d\t",e);
    return OK;
}

测试结果

顺序表构造成功！
该顺序表的长度为0
······
该顺序表为空表！
赋值成功！
······
该顺序表不是空表！
该顺序表的长度为100
顺序表中第10个数据元素的值为10
第一个大于e的元素的位序为11
第一个等于e的元素的位序为10
第一个小于e的元素的位序为1
顺序表重置成功！
该顺序表的长度为0
······
该顺序表为空表！
赋值成功！
······
该顺序表不是空表！
该顺序表的长度为100
18的直接前驱为17
18的直接后继为19
在顺序表中第18个位置之前插入新的数据元素10
修改后的顺序表为：
1       2       3       4       5       6       7       8       9       10      11      12      13      14      15
        16      17      10      18      19      20      21      22      23      24      25      26      27      28
        29      30      31      32      33      34      35      36      37      38      39      40      41      42
        43      44      45      46      47      48      49      50      51      52      53      54      55      56
        57      58      59      60      61      62      63      64      65      66      67      68      69      70
        71      72      73      74      75      76      77      78      79      80      81      82      83      84
        85      86      87      88      89      90      91      92      93      94      95      96      97      98
        99      100
删除顺序表的第18个数据元素
被删除的元素为10
修改后的顺序表为：
1       2       3       4       5       6       7       8       9       10      11      12      13      14      15
        16      17      18      19      20      21      22      23      24      25      26      27      28      29
        30      31      32      33      34      35      36      37      38      39      40      41      42      43
        44      45      46      47      48      49      50      51      52      53      54      55      56      57
        58      59      60      61      62      63      64      65      66      67      68      69      70      71
        72      73      74      75      76      77      78      79      80      81      82      83      84      85
        86      87      88      89      90      91      92      93      94      95      96      97      98      99
        100
依次对顺序表的每个数据元素调用函数Print()，做输出操作：
1       2       3       4       5       6       7       8       9       10      11      12      13      14      15
        16      17      18      19      20      21      22      23      24      25      26      27      28      29
        30      31      32      33      34      35      36      37      38      39      40      41      42      43
        44      45      46      47      48      49      50      51      52      53      54      55      56      57
        58      59      60      61      62      63      64      65      66      67      68      69      70      71
        72      73      74      75      76      77      78      79      80      81      82      83      84      85
        86      87      88      89      90      91      92      93      94      95      96      97      98      99
        100
操作完成，对顺序表进行销毁。
顺序表销毁成功！
荧惑explorer
关注
专栏目录
2.2 线性表的顺序表示和实现
m0_59440926的博客
11-06 870
线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。线性表的这种机内表示称作线性表的或(sequential mapping),通常，称这种存储结构的线性表为。采用顺序表表示的线性表，表中逻辑位置相邻的数据元素将存放到存储器中物理地址相邻的存储单元之中，即以元素在计算机内“物理位置相邻”来表示线性表中数据元素之间的逻辑关系。假设线性表的每个元素需占用L个存储单元，并以所占的第一个单元的存储地址作为数据元。
线性表的顺序表示和实现以及线性表的链式表示和实现
qq_39826006的博客
08-02 650
在执行链表的插入、删除操作时，需要被操作节点的前驱节点和后继节点，如果被操作节点是头节点，则它没有前驱节点，需要额外特殊处理，因此为了方便插入和删除操作所以给单链增加一个空的头节点。线性表的顺序存储结构的特点是逻辑关系上相邻的两个元素在物理位置上也相邻，因此可以随机存取表中的任一元素，它的存储位置可以用一个简单、直观的公式来表示。若干个元素节点通过指针域连接起来，形成的线性表结构称为链式表，简称链表，节点中只有一个指向后继元素的指针域，这种链表也被称为单向链表。size_t cnt;size_t cap;.
线性表顺序表示和实现（C语言)
热门推荐
世纪末的架构师的博客
09-23 4万+
线性表顺序表示和实现 线性表是最常用且最简单的一种数据结构。简而言之，一个线性表是n个数据元素的有限序列 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。 实现工具：dev 顺序表示要实现的功能： 1.构造一个空的线性表 2. 对线性表进行赋值 3. 对线性表进行销毁 4. 对线性表进行重置 5. 判断线性表是否为空 6. 获取线性表的长度 7. 获取线性表某一位置对应的元素 8. 在线性表某一位置插入元素 9. 删除线性表某一位置的元素 10. 求线性表某一元素的前驱 11. 求线
线性表的顺序表示和实现（详解）
weixin_52439435的博客
04-01 1964
这么有趣的线性表你不学还是不会？ 线性表的顺序表示又称为顺序存储结构或顺序映像。 顺序表的定义：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构。 简而言之，逻辑上相邻，物理上也相邻。 顺序存储方法：用一组地址连续的存储单元依次存储线性表的元素，可通过数组V[n] 来实现。 顺序表类型的定义 define MAXSIZE 100 //最大长度 typedef struct { ElemType *elem; //指向数据元素的基地址 int length;.
【线性表】线性表的顺序表示和实现
m0_74102736的博客
01-20 556
【代码】【线性表】线性表的顺序表示和实现。
线性表的顺序表示及实现
1+1=王的博客
11-09 1287
线性表的顺序表示及实现线性表的定义和特点1. 定义2.线性表的逻辑特征线性表的顺序表示顺序表的基本实现总结 线性表的定义和特点 1. 定义 线性表（Linear List）：由n（n>=0）个具有相同特性的数据元素（结点）a1,a2, … , 组成的有限序列。 其中数据元素的个数n定义为表的长度； 当n = 0 时称为空表； 将非空的线性表（n>0）记作：（a1 , a2 , … ,...
四、【线性表】线性表的顺序表示和实现
fujz123的博客
05-26 909
线性表的顺序表示 前文我们提到过线性表是逻辑结构，只说明了数据元素之间的相互关系，想要使用线性表，我们还需要在计算机上表示出这些数据元素以及元素之间的关系。而对于同一种逻辑结构，可以有多种存储结构来实现它。线性表作为一种基础的数据结构，可以用顺序存储和链式存储两种不同方式来实现，本节主要说明线性表的顺序表示。 1 线性表的顺序表示和实现 1.1 顺序表的定义 线性表的顺序存储又称为顺序表， 它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。顺序表的特
线性表顺序表示和实现2 --2.4下篇
qq_63429769的博客
07-23 315
线性表顺序表示和实现
【数据结构 c语言版 】线性表的顺序表示和实现
shijiuhuaR的博客
09-21 637
线性表的顺序表示和实现
数据结构之线性表的顺序表示和实现
05-28
以上就是关于“数据结构之线性表的顺序表示和实现”的主要知识点，以及可能的代码实现结构。通过这三个文件，我们可以学习如何在C++中实现一个基本的顺序表，并对其进行操作。这不仅有助于理解数据结构的基础，也为...
C语言线性表的顺序表示与实现实例详解
12-31
通常来说顺序表是在计算机的内存中以数组的形式保存的线性表，是用一组地址连续的存储单元依次存储数据元素的线性数据结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存...
java计算文本相似度算法总结
sunsiny
11-14 530
计算两个字符串之间的最小单字符编辑（插入、删除、替换）次数。这是一种衡量字符串差异性的方法，常用于拼写检查和模糊匹配。：一种基于 Jaro 相似度的改进算法，特别适用于拼写检查和模糊匹配。：计算两个字符串之间的最长公共子序列长度，常用于文本差异比较。：通过计算两个字符串的 n-gram 向量的余弦夹角来评估它们的相似度。：基于子串的字符串相似度计算方法，计算它们共有的Q-gram（长度为Q的连续子串）的数量，然后将这个数量除以两个字符串中Q-gram数量较少的那个，得到相似度的比例。
16 合并区间
weixin_47521269的博客
11-12 725
【代码】16 合并区间。
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1082
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1507
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
每日小题--买股票的最佳时机
最新发布
m0_74977981的博客
11-14 443
毋庸置疑，一定需要数组遍历结束后才能确定这么一个买入点和卖出点，所以此时想要提升算法的话就要找到一个只需要遍历一遍就能出结果的方法，即将时间复杂度控制在O(n)；遍历数组的过程中去找数组中是否存在一个低价点，并且在低价点的基础上去判断有无上升空间；即杜绝了{4，3，2，1}的情况出现，买入后无法卖出。在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。后出价最高的一天卖出，简而言之，就是找到一个比起始小，并且结尾在一个有最大差距的位置；
算法每日双题精讲——滑动窗口（长度最小的子数组，无重复字符的最长子串）
A Charmer 的博客
11-11 1483
本文聚焦算法中的滑动窗口算法，通过“长度最小的子数组”和“无重复字符的最长子串”两道经典题目进行精讲。滑动窗口利用双指针界定动态窗口，在数组或字符串上滑动以求解。对于“长度最小的子数组”，初始化指针与变量，通过移动指针扩展与收缩窗口，找到满足和≥目标的最小子数组长度。“无重复字符的最长子串”则借助集合记录窗口内字符，根据字符重复性移动指针并更新最长子串长度。文章展示了滑动窗口算法在处理此类问题时的高效性与灵活性，文末还设置投票环节，引导读者思考算法关键难点，助力读者深入理解滑动窗口算法。
14 最长连续序列
weixin_47521269的博客
11-11 575
O1这个算法的时间复杂度是 O(n)，因为每个数字最多只会被处理一次，符合题目要求的时间复杂度。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值