顺序表的基本操作集（C语言版）

已于 2024-10-03 19:04:30 修改
阅读量287 收藏 3
点赞数 9
分类专栏： 数据结构 文章标签： 数据结构 c语言
于 2024-10-03 16:52:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tangguofeng/article/details/142693473
版权

/*
    顺序的操作集中一些常用的操作
    说明：顺序表的操作可以根据需要灵活的编写，操作接口比较多，这里只写了一些常用的基本接口 

    1、始化顺序表
        Status InitList_Sq(SqList &L, int size, int increment);    
    2、销毁顺序表
        Status DestroyList_Sq(SqList &L);
    3、判断顺序表是否为空
        Status ListEmpty_Sq(SqList L);     
    4、清空顺序表
        Status ClearList_Sq(SqList &L); 
    5、求顺序表的长度
        int ListLength_Sq(SqList L);     
    6、读取顺序表中指定的第 i 个元素
        Status GetElem_Sq(SqList L, int i, ElemType &e);         
    7、顺序表中查找指定元素 e，说明：成功时返回该元素在表中第一次出现的位置，否则返回 -1
        int Search_Sq(SqList L, ElemType e); 
    8、顺序表的第 i 个元素赋值为 e
        PutElem_Sq(SqList &L, int i, ElemType e);    
    9、在表尾添加一个元素
        Status Append_Sq(SqList &L, ElemType e);        
    10、在指定第 i 个元素之前插入元素
        Status ListInsert_Sq(SqList &L, int i, ElemType e);         
    11、删除表尾元素
        Status DeleteLast_Sq(SqList &L,int i, ElemType &e); 
    12、删除指定的第 i 个元素
        Status ListDelete_Sq(SqList &L,int i, ElemType &e); 
    13、遍历顺序表 L，说明：依次对每个元素调用函数 visit()
        Status ListTraverse_Sq(SqList L, Status(*visit)(ElemType e)); 

*/

#include<stdio.h>
#include<stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define PERROR -2
typedef int Status;

// 数据元素的类型，使用时需根据问题的需求定义。
typedef int ElemType;

//顺序表结构类型定义 
typedef struct {
    ElemType    *elem;    // 存储空间的基址
    int length;         // 表长 
    int size;            // 存储容量 
    int increment;        // 扩容增量
} SqList;

// 1、初始化顺序表 L 
Status InitList_Sq(SqList &L, int size, int inc){
    L.elem = (ElemType *)malloc(size * sizeof(ElemType));
    if (L.elem == NULL) return OVERFLOW;
    L.length = 0;
    L.size = size;
    L.increment = inc;
    return OK;
}

// 2、销毁顺序表 L
Status DestroyList_Sq(SqList &L) {        
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回，不再执行销毁操作 
    free(L.elem);    // 释放顺序表所占空间 
    L.elem = NULL;    // 避免指针悬挂 
    L.length = 0;
    L.size = 0;
    L.increment = 0;
    return OK;
}

// 3、判断顺序表 L 是否为空表
Status ListEmpty_Sq(SqList L) {
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    if(L.length == 0) {
        return TRUE;
    }else{
        return FALSE;
    } 
}

// 4、清空顺序表 L
Status ClearList_Sq(SqList &L) {
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    L.length = 0;
    return OK;
}

// 5、求顺序表的长度
int ListLength_Sq(SqList L) {
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    return L.length;
}
 
// 6、读取顺序表中指定的第 i 个元素
Status GetElem_Sq(SqList L, int i, ElemType &e) {
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    if(i<1 || i>L.length) return PERROR;    // 参数合法性检查，非法则返回
    e = L.elem[i-1];
    return OK;
}


// 7、在顺序表 L 顺序查找元素e
// 成功时返回该元素在表中第一次出现的位置，否则返回 -1
int Search_Sq(SqList L, ElemType e) {
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    int i = 0;
    while (i < L.length && L.elem[i] != e){
        i++;
    }
    if (i < L.length){
        return i;
    }else{
        return -1;
    }
}

// 8、把顺序表的第 i 个元素赋值为 e
Status PutElem_Sq(SqList &L, int i, ElemType e) {
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    if(i<1 || i>L.length) return PERROR;    // 参数合法性检查，非法则返回
    L.elem[i-1] = e; 
    return OK;
}

// 9、在顺序表 L 的表尾添加元素 e
Status Append_Sq(SqList &L, ElemType e) {
    ElemType *newbase;
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    if (L.length >= L.size){                // 满了需要扩容 
        newbase =  (ElemType*)realloc(L.elem, (L.size + L.increment)*sizeof(ElemType));
        if(newbase==NULL) return OVERFLOW;
        L.elem = newbase; 
        L.size += L.increment;
    }
    L.elem[L.length] = e;
    L.length++;
    return OK;
}

// 10、在顺序表 L 的指定第 i 个元素之前插入元素
Status ListInsert_Sq(SqList &L, int i, ElemType e){
    ElemType *newbase;
    int l,r;
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    if(i < 1 || i > L.length) return PERROR;    // 数合法性检查，非法则返回
    if (L.length >= L.size){                    // 满了需要扩容 
        newbase =  (ElemType*)realloc(L.elem, (L.size + L.increment)*sizeof(ElemType));
        if(newbase==NULL) return OVERFLOW;
        L.elem = newbase; 
        L.size += L.increment;
    }
    l = i-1;                                     // l为插入位置
    for(r = L.length-1; r >= l; r--){
        L.elem[r+1] = L.elem[r];                 //插入位置及之后的元素后移
    }
    L.elem[l] = e;                                 //插入e
    L.length++;                                    //表长加 1
    return OK;
}
// 11、删除表尾元素
Status DeleteLast_Sq(SqList &L, ElemType &e) {
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    if(L.length == 0) return ERROR;            // 空表，无法删除 
    e = L.elem[L.length - 1];
    L.length--;
    return OK;
}

// 12、在顺序表 L 中删除指定的第 i 个元素，并用 e 将其返回
Status ListDelete_Sq(SqList &L, int i, ElemType &e)
{
    int r;        // 后面的元素移位迭代用变量 
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    if(i < 1 || i > L.length) return ERROR;        // 参数合法性检查，非法则返回
    e = L.elem[i-1];                            // 将第 i 个元素交给 e 
    for(r = i;r < L.length;r--){
        L.elem[r-1] = L.elem[r];                // 将删除位置之后的元素依次前移
    } 
    L.length--;                    //表长减一
    return OK;
}

// 13、遍历顺序表 L ，依次对每个元素调用函数 visit()
Status ListTraverse_Sq(SqList L, Status(*visit)(ElemType e)) {
    if((L.elem != NULL)&&(L.size == 0))return PERROR;    // 参数合法性检验，防止实参未初始化时就使用的野指针
    if(L.elem == NULL)return PERROR;    // 参数合法性检查，顺序表已销毁则返回 
    if (L.length == 0) return ERROR;    // 空表不再遍历访问 
    for (int i = 0; i < L.length; i++) {
        visit(L.elem[i]);
    }
    return OK;
}

// 测试用函数：打印顺序表的全部元素 
Status PrintList(ElemType e) {
    printf("%d\t",e);
    return OK;
}

int main(){
    int i, e, state;
    SqList L;
    printf("1.初始化顺序表\n");
    printf("2.销毁顺序表\n");
    printf("3.判断顺序表是否为空\n");
    printf("4.清空顺序表\n");
    printf("5.求顺序表的长度\n");
    printf("6.读取顺序表中指定的第 i 个元素\n");
    printf("7.在顺序表中查找指定元素\n");
    printf("8.将顺序表的第 i 个元素赋值为 e\n");
    printf("9.在顺序表中的表尾添加一个元素\n");
    printf("10.在指定第 i 个元素之前插入元素\n");
    printf("11.删除表尾元素\n");
    printf("12.删除指定的第 i 个元素\n");
    printf("13.打印顺序表中的全部元素\n");
    do{
        printf("请输入你要进行的操作：\n");
        scanf("%d",&i);
        switch(i){
            case 1 :
                    state = InitList_Sq(L, 10, 5); 
                    if(state == OK){
                        printf("顺序表初始化成功。\n");
                    }else{
                        printf("顺序表初始化失败！\n"); 
                    }
                    break;
            case 2 :
                    state = DestroyList_Sq(L);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else{
                        printf("顺序表销毁成功。\n"); 
                    }
                    break;
            case 3 :
                    state = ListEmpty_Sq(L);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else if(state == TRUE){
                        printf("队列为空！\n"); 
                    }else if(state == FALSE){
                        printf("队列不为空!\n"); 
                    }
                    break;
            case 4 :
                    state = ClearList_Sq(L);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else{
                        printf("已为您清空队列。\n");
                    }
                    break;
            case 5 :
                    state =  ListLength_Sq(L);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else{
                        printf("当前顺序表中共有 %d 个元素！\n",state); 
                    }
                    break; 
            case 6 :
                    printf("请输入将需要读取的是第几个元素：\n");
                    scanf("%d",&i);
                    state = GetElem_Sq(L, i, e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else{
                        printf("顺序表中第 %d 个元素是： %d \n",i,e); 
                    }
                    break;
            case 7 :
                    printf("请输入将想要查找的元素：\n");
                    scanf("%d",&e);
                    state = Search_Sq(L, e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else if(state == -1){
                        printf("顺序表没有这个元素！\n"); 
                    }else{
                        printf("查找成功：您要找的元素是顺序表的第 %d 个元素。\n",state); 
                    }
                    break;
            case 8 :
                    printf("请输入更换的元素的位置：\n");
                    scanf("%d",&i);
                    printf("请输入您想将元素更换为：\n");
                    scanf("%d",&e);
                    state = PutElem_Sq(L, i, e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else{
                        printf("元素更换成功。\n"); 
                    }
                    break;
            case 9 :
                    printf("请输入您想在表尾追加的元素为：\n");
                    scanf("%d",&e);
                    state = Append_Sq(L, e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else if(state == OK){
                        printf("元素 %d 追加成功。\n",e); 
                    }else{
                        printf("元素 %d 追加失败！\n",e); 
                    }
                    break;
            case 10 :
                    printf("请输入您想在第几个元素前插入元素：\n");
                    scanf("%d",&i);
                    printf("请输入您想插入的元素为：\n");
                    scanf("%d",&e);
                    state = ListInsert_Sq(L, i, e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else if(state == OK){
                        printf("元素 %d 追加成功。\n",e); 
                    }else{
                        printf("元素 %d 追加失败！\n",e); 
                    }
                    break; 
            case 11 :
                    state = DeleteLast_Sq(L, e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else if(state == OK){
                        printf("顺序表表尾元素已成功删除。\n"); 
                    }else{
                        printf("顺序表内没有元素，不能执行删除表尾元素操作！\n");
                    }
                    break;
            case 12 :
                    printf("请输入您删除的是顺序表中的第几个元素：\n");
                    scanf("%d",&i);
                    state = ListDelete_Sq(L, i, e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else if(state == OK){
                        printf("指定的元素已成功删除。\n"); 
                    }else{
                        printf("顺序表内没有元素，不能执行删除表尾元素操作！\n");
                    }
                    break;
            case 13 :
                    state = ListTraverse_Sq(L, PrintList);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行顺序表的初始化操作！\n"); 
                    }else if(state == ERROR){
                        printf("当前的顺序表为空表。\n"); 
                    }else{
                        printf("\n"); 
                    }
                    break;
        }
    }while(i>=1&&i<=13);
    return 0;
}

tangguofeng
关注
专栏目录
【数据结构】线性表的类型定义及顺序表的基本操作（C语言）
ly020111的博客
11-18 2726
1.抽象数据类型 ADT List { 数据对象：D = { ai | ai属于元素集,（i = 1，2，...，n,n>=0）} 数据关系：R = { <ai-1,ai> | ai-1,ai属于D,（i = 2,3,...,n）} 基本操作： InitList(&L); DestroyList(&L); ListInsert(&L,i,e); ..... }ADT
【数据结构】【C语言】------- 顺序表
m0_63601181的博客
05-13 2351
前言 大家好，我是Abert。 这篇文章和大家分享C语言实现数据结构的顺序表。顺序表也是之后的数据结构的学习的基础，整体实现过程也不复杂，和通讯录类似。下面我们一起来学习顺序表吧！！！ 文章目录 1、程序基本框架的搭建与讲解 1.1 文件的创建 1.2 变量的创建与声明 2、各种功能的实现及逻辑关系的讲解 2.1 菜单 2.2 尾插 2.3 头插 2.4 尾删 2.5 头删...
pta顺序表操作集
Lyriv的博客
10-27 3831
顺序打印顺序表L里面的数据元素。打印要求：“顺序表的值为：”（按顺序打印顺序表中的数据元素，每个数据元素之后有一个空格，打印结束之后打印换行符）（5）bool Delete( List L, int i)：将位序为i的元素删除并返回true。若参数i指向非法位置，则打印“位序i不存在元素”（其中i是参数值）并返回false。（3）Position Find( List L, ElementType X )：在线性表L中查找X，若找到，则返回线性表中X的位置；
c语言顺序表所需的头文件,数据结构【顺序表】
weixin_35143455的博客
05-23 2279
1、线性表定义线性表是一种线性结构。线性结构的特点是数据元素之间是一种线性关系，数据元素“一个接一个的排列”。在一个线性表中数据元素的类型是相同的，或者说线性表是由同一类型的数据元素构成的线性结构。在实际问题中线性表的例子是很多的，如学生情况信息表是一个线性表：表中数据元素的类型为学生类型; 一个字符串也是一个线性表：表中数据元素的类型为字符型，等等。综上所述，线性表定义如下：线性表是具有相同数据...
【数据结构】顺序表
炸掉地球的博客
05-04 1068
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，这种存储结构称为顺序存储结构。顺序表一般情况下采用数组存储，在数组上完成数据的增删查改等基本操作。
链表的基本操作--c语言
qq_51533157的博客
06-25 5989
链表是数据结构中一种最基本的数据结构，它是用链式存储结构实现的线性表。它较顺序表而言在插入和删除时不必移动其后的元素。现在给你一些整数，然后会频繁地插入和删除其中的某些元素，会在其中某些时候让你查找某个元素或者输出当前链表中所有的元素。 下面给你基本的算法描述： 图1：链表类型的定义以及获得链表元素的算法描述 图2：链表的插入算法描述 图3：链表的删除算法描述 图4：链表的创建算法描述 输入 输入数据只有一组，第一行有n+1个整数，第一个整数是这行余下的整数数目n，后面是n个整
顺序表创建、查找、插入、删除操作集（c语言实现）
Runningcabbage的博客
09-04 4353
顺序表创建、查找、插入、删除操作集（c语言实现） 刚开始学数据结构，看c语言版本的，但看书总是想不通，网上荡的资源也是错的（而且错的很离谱）就自己试着操作了一下，发现还是很棘手的。我编写的每个函数参数都是用指向结构的指针来操作，这样的可以保证改变主调函数中的实参，并且用了malloc（）函数对内存块进行了分配。 ps：小白一个，新手有不足之处请见谅… #include<stdio.h>...
数据结构与算法PTA 6-1【顺序表】（C语言）
wyxcyy的博客
11-10 1501
数据结构与算法PTA 6-1【顺序表】（C语言）/合并顺序表list1和list2/ 重置（清空）顺序表/如果顺序表为空，则返回1，否则返回0/ 如果顺序表已满则返回1，否则返回0/返回顺序表的长度
6-2 顺序表操作集 (20分) C语言
ccccm__的博客
03-31 1359
本题要求实现顺序表的操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef int Positi...
数据结构C语言篇-顺序表基本运算编程实现
qq_43717119的博客
06-08 1825
打卡第一天——线性表基本运算 顺序表基本运算编程实现线性结构的特点：一、线性表的定义二、线性表的类型定义三、线性表的顺序表示四、顺序存储结构的线性表类C语言表示：线性表的静态分配顺序存储结构顺序表的插入算法顺序表的删除算法五、删除算法的时间复杂度六、代码实现 （ps：此次练习主要是C语言练习，代码在文章末尾） 数据结构的形式定义： 数据结构名称=（D，S） 其中D为数据元素的有限集，S是D上关系的有限集 线性结构的特点： 在数据元素的非空有限集中， （1）存在唯一的一个被称做“第一个”的数据元素； （2）存
C语言顺序表基本操作集.cpp
09-20
顺序表的基本操作代码
数据结构C语言完成顺序表基本操作
04-25
在这个主题中，我们专注于使用C语言实现顺序表的基本操作。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。下面我们将详细探讨这个主题。 1. **顺序表的概念**： 顺序表是由数组支持...
顺序表的插入c语言版的
06-04
在C语言中，实现顺序表的插入操作是一项常见的编程任务，对于初学者来说尤其重要，因为这能帮助理解数据结构的基本原理。在这个主题中，我们将深入探讨顺序表的概念、其插入操作的原理以及如何用C语言实现这一操作。...
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 257
【代码】数据结构-线性表-课设实验-手机销售。
【笔记】数据结构12
m0_52024881的博客
09-29 472
看到的社区的一个知识总结，这里记录一下。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1061
本文介绍了数据结构中的AVL树，给出了C++的代码实现
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 271
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
深入理解 C# 中的集合与数据结构
最新发布
qq_45728381的博客
10-02 942
在日常开发中，集合与数据结构是处理数据的基础工具。C# 提供了一系列强大而灵活的集合类型，帮助我们存储、访问和管理数据。这篇文章将带你了解 C# 中常用的数组、列表、字典、队列、栈、集合和链表的特性和用法。
数据结构-C语言实现线性表的顺序存储结构
m0_60984906的博客
09-23 354
数据结构与算法使用C语言实现线性表的顺序存储结构
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

tangguofeng

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值