线性表操作函数实现（P19）---------顺序表示

最新推荐文章于 2022-01-13 00:43:17 发布
最新推荐文章于 2022-01-13 00:43:17 发布
阅读量694 收藏 2
点赞数
分类专栏： 数据结构（C语言）严蔚敏代码实现 文章标签： 数据结构 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012160436/article/details/49384429
版权

编译工具 ：Dev-c++5.11

本文参照数据结构(C语言)严蔚敏教材，使用顺序表实现教材第19页线性表操作函数接口（SqList.h），并且配有简单的测试项目（main.cpp）， 接口函数中除个别函数外其他函数都按照C语言编写习惯，函数正常退出时返回0，错误时返回-1.测试项目只对基本操作进行了基本测试，可能存在少量bug。

测试项目实现的基本功能：

1.程序刚启动时初始化一个顺序表；

2.输入对顺序表执行操作所对应的函数，执行相应操作；

3.输入10可以让顺序表恢复到程序刚运行时的数据；

4.输入11重新打印各函数对应的序号。


SqList.h文件内容

#include <stdio.h>

#include <stdlib.h>
#include <malloc.h>

#define LIST_INIT_SIZE 10
#define LIST_INCREMENT 5
#define ElemType int

typedef struct {
    int *elem;    //顺序表基地址
    int length;        //顺序表当前长度
    int list_size;    //顺序表容量
}SqList;

//1.初始化顺序表函数
int InitList(SqList &L)
{
    L.elem = (ElemType *)malloc(sizeof(ElemType) * LIST_INIT_SIZE);
    if(!L.elem){
        fprintf(stderr, "malloc error");
        return -1;
    }
    
    L.length = 0;
    L.list_size = LIST_INIT_SIZE;
    
    return 0;
}

//销毁顺序表(L==NULL)
int DestroyList(SqList &L)
{
    if(!L.elem){
        fprintf(stderr, "The SqList is null\n");
        return -1;
    }
    free(L.elem);
    L.elem = NULL;
    L.length = 0;
    L.list_size = 0;
    
    return 0;
    
}

//清空顺序表(顺序表首地址可能会变)
int ClearList(SqList &L)
{
/*    
    if(DestroyList(L) == -1){
        return -1;
    }
    if(InitList(L) == -1){
        return -1;
    }
*/    
    L.length = 0;
    return 0;
    
}

//判断顺序表是否为空 为空返回1  不为空返回0
int ListEmpty(const SqList &L)
{
    if(L.length == 0){
        return 1;
    }
    else{
        return 0;
    }
    
}

//获取顺序表中某个位置的元素
int GetElem(const SqList &L, int loc, ElemType &e)
{
    if(loc < 1 || loc > L.length){
        fprintf(stderr, "The loc must be [1,%d]\n",L.length);
        return -1;
    }
    e = L.elem[loc -1];
    return 0;
}

//获取顺序表中第一个与指定元素满足某种条件的元素下标
int LocateElem(const SqList &L, ElemType &e, int (*compare)(const ElemType first, const ElemType second))
{//int(*compare)(const ElemType first, const ElemType second)为指向函数的指针

    int i;
    for(i = 0; i < L.length; i++){
        if( (*compare)(L.elem[i], e) )
        //if( L.elem[i] == e)
            return i+1;
    }
    return 0;//若函数退出for循环 说明在L中没有找到满足compare关系的数据，故返回0；
    
}

//返回元素的前驱元素
int PriorElem(const SqList &L, ElemType cur_e, ElemType &prior_e)
{
    int i;
    for(i = 0; i < L.length; i++){
        if(L.elem[i] == cur_e){
            if(i-1 >= 0){
                prior_e = L.elem[i-1];
                return 0;    
            }
            else{
                fprintf(stderr, "The %d is first element in SqList.\n",cur_e);
                return -1;
            }
            
        }
    }
    fprintf(stderr, "The %d is not in SqList.\n", cur_e);
    return -1;
}

//返回元素的后继元素

int NextElem(const SqList &L, ElemType cur_e, ElemType &next_e)
{
    int i;
    for(i = 0; i < L.length; i++){
        if(L.elem[i] == cur_e){
            if(i != L.length-1){
                next_e = L.elem[i+1];
                return 0;
            }
            else{
                fprintf(stderr, "The %d is the last element in Sqlist.\n", cur_e);
                return -1;
            }
        }
    }
    fprintf(stderr, "The %d is not in SqList.\n", cur_e);
    return -1;
}

//2.在顺序表末尾添加元素函数
int ListInsert(SqList &L, ElemType e)
{
    //若顺序表元素已满，则增加顺序表长度
    if(L.length >= L.list_size){
        ElemType *newbase =(ElemType*) realloc(L.elem, sizeof(ElemType)*(L.list_size + LIST_INCREMENT));
        if(!newbase) {
            perror("remalloc error");
            return -1;
        }
        
        L.elem = newbase;
        L.list_size = L.list_size + LIST_INCREMENT;
    }
    L.elem[L.length] = e;
    L.length++;
    
    return 0;
}

//3.在顺序表指定位置添加元素
int ListInsert(SqList &L, ElemType e, int loc)
{
    if(loc < 1 || loc > L.length+1) {//顺序表元素位置的插入范围[1,L.length+1]
        fprintf(stderr,"the loc must be [1,%d] !!!\n",L.length+1);
        return -1;
    }
    if(L.length >= L.list_size){//若当前长度已达到顺序表容量，则扩充顺序表
        ElemType *newbase = (ElemType*)realloc(L.elem, sizeof(ElemType)*(L.list_size + LIST_INCREMENT));
        if(!newbase) {
            perror("realloc error");
            return -1;
        }
        L.elem = newbase;
        L.list_size = L.list_size + LIST_INCREMENT;
    }
    
    if(ListEmpty(L)){//当顺序表为空时 直接插入即可
        L.elem[0] = e;
        L.length++;
        return 0;
    }

    
    int i;
    for(i = L.length-1; i > loc-1; i--){//插入元素需要移动元素， 故遍历顺序表次序从后到前
        L.elem[i+1] = L.elem[i];
    }
    L.elem[i+1] = L.elem[i];
    L.elem[i] = e;
    L.length++;//注意：插入完元素之后一定使顺序表长度加１
    
    return 0;
    
}

//删除顺序表指定位置的元素
int ListDelete(SqList &L, int loc, ElemType &e)
{
    if(ListEmpty(L)){
        fprintf(stderr, "The loc is null\n");
        return -1;
    }
    
    if(loc < 1 || loc > L.length){
        fprintf(stderr, "The loc must be [1, %d]\n", L.length);
        return -1;
    }
    e = L.elem[loc-1];
    int i;
    for(i = loc; i < L.length; i++){//i < L.length-1 注意不要把顺序表最后一个元素后面的值(不存在于顺序表中)
                                        //赋值给顺序表 最后一个元素
        
        L.elem[i-1] = L.elem[i] ;
    }
    L.length--;//删除完元素一定要使顺序表长度减1
    return 0;
}

//4.显示顺序表内容函数
void ShowList(const SqList &L)
{
    int i = 0;
    printf("%d elements:", L.length);
    for(i = 0; i < L.length; i++){
        printf("%d ",L.elem[i]);
    }
    
    return;

}


main.cpp内容

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

#include "SqList.h"

/*当ElemType类型改变是需要注意以下几点:
 *1.对ElemType输出均采用%d形式，输出的地方为ShowList()和GetElemType()之后的元素输出
 *2.在调用compary函数时，应该注意ElemType能否进行算术比较运算
 *  若不能进行，则需要修改ElemType比较类型 或者重载算术比较符
 *
 */

//比较两个数大小的函数  用于指针函数的 函数传递
int moreThen(const ElemType first, const ElemType second)
{
    //ElemType能够进行比较运行
    if(first > second)
        return 1;
    else
        return 0;
}

int equal(const ElemType first, const ElemType second)
{
    return( (first==second)?1:0 );
}

int lessThen(const ElemType first, const ElemType second)
{
    return( (first<second)?1:0 );
}

//构造初始顺序表并显示
void List_init_data (SqList &L)
{
    if(InitList(L) == -1){
        perror("InitList error");
        exit(EXIT_FAILURE);
    }
        
    int i = 0;
    for(i = 0; i < 10; i++){
        if(ListInsert(L, i * i) == -1){
        perror("ListInsert error");
        exit(EXIT_FAILURE);
        }
    }
    
    if(!ListEmpty(L)){
        ShowList(L);
        printf("\n");
    }
}

//测试ListInsert()
void list_insert(SqList &L)
{
    if(!L.elem){
        printf(" The SqList is not exit.\n");
        return ;
    }
    int loc;
    ElemType e;
    printf("Enter the location and data(loc data):") ;
    scanf("%d%d", &loc, &e);
    if( ListInsert(L, e, loc) == -1 ){
        fprintf(stderr, "List Insert error\n");
        //exit(1);
    }
    else{
        printf("After insert:");
        ShowList(L);
        printf("\n");
    }
    
    return ;
}
//测试 DestroyList()
void destroy_list(SqList &L){
    if(!L.elem){
        printf(" The SqList is not exit.\n");
        return ;
    }
    
    if(DestroyList(L) == -1){
        fprintf(stderr, "destroy list error\n");
        //exit(EXIT_FAILURE);
    }
    else {
        
        printf("After destroy list:");
        printf("elem=%p length=%d list_size=%d\n", L.elem, L.length, L.list_size);
    }
    
    return;
}
    
//测试ClearList()
void clear_list(SqList &L)
{
    if(!L.elem){
        printf(" The SqList is not exit.\n");
        return ;
    }
    
    if(ClearList(L) == -1){
        fprintf(stderr, "clear list error\n");
        //exit(EXIT_FAILURE);
    }
    else
        printf("elem=%p length=%d list_size=%d\n", L.elem, L.length, L.list_size);
        
    return;
}




//测试locateElem()
void locate_elem(const SqList &L)
{
    if(!L.elem){
        printf(" The SqList is not exit.\n");
        return ;
    }
    ElemType second;
    int funCount;
    int (*fun[])(ElemType ,ElemType ) = {//此处用到指向函数的指针，并把指向函数的指针用作fun数组成员
        moreThen,
        equal,
        lessThen
    };
    printf("Enter the second element:");
    scanf("%d", &second);
    printf("Enter the fun(0->moreThen,1->equal, 2->lessThen):");
    scanf("%d", &funCount);
    
    printf("The loc of %d(The compare is %d) in SqList is %d\n", second, funCount, LocateElem(L,second,(*fun[funCount])));
}
 
//测试PriorElem()  
void prior_elem(const SqList &L)
{
    if(!L.elem){
        printf(" The SqList is not exit.\n");
        return ;
    }
    ElemType cur_e;
    ElemType prior_e;
    printf("Enter your curent element:");
    scanf("%d", &cur_e);
    if( PriorElem(L, cur_e, prior_e) == -1){
        fprintf(stderr, "Not find the prior of %d.\n", cur_e);
        //exit(EXIT_FAILURE);
    }
    else
        printf("The prior of %d in SqList is %d\n", cur_e, prior_e);
}

//测试NextPrior()     
void next_prior(const SqList &L)
{
    if(!L.elem){
        printf(" The SqList is not exit.\n");
        return ;
    }
    ElemType cur_e;
    ElemType next_e;
    printf("Enter your element:");
    scanf("%d", &cur_e);
    if( NextElem(L, cur_e, next_e) == -1){
        fprintf(stderr, "Not find the next of %d.\n", cur_e);
        //exit(EXIT_FAILURE);
    }
    else
        printf("The next of %d in SqList is %d.\n", cur_e, next_e);
}


//测试ListDelete()
void list_delete(SqList &L)
{
    if(!L.elem){
        printf(" The SqList is not exit.\n");
        return ;
    }
    int loc;
    ElemType e;
    printf("Enter the loc in SqList that you want to delete:") ;
    scanf("%d", &loc);
    if( ListDelete(L, loc, e) == -1){
        fprintf(stderr, "The element of loc in SqList delete fail.\n");
        //exit(EXIT_FAILURE);
    }
    else{
        printf("The element of %d in SqList that you delete is %d\n", loc, e);
        if(!ListEmpty(L)){
            printf("After list delete, The List is:\n");
            ShowList(L);
            printf("\n");
        }
        else
            printf("After list delete, The List is null.\n");

    }
}

//测试GetElem()
void get_elem(const SqList &L)
{
    if(!L.elem){
        printf(" The SqList is not exit.\n");
        return ;
    }
    int loc;
    ElemType e;
    printf("\nEnter loc of the list that you want to get:");
    scanf("%d", &loc);
    if( GetElem(L,loc, e) == -1){
        fprintf(stderr, "Get elem of list error\n");
        //exit(EXIT_FAILURE);
    }
    else
        printf("The element of list in %d is %d\n", loc, e);    
}
//测试list_show()
void list_show(const SqList &L)
{
    if(!L.elem){
        printf(" The SqList is not exit.\n");
        return ;
    }
    
    ShowList(L);
    printf("\n");
}
        
void print()
{
    printf("\nthe number of command:\n");
    printf("\t0: Quit    ");
    printf("\t1: ListInsert\n");
    printf("\t2: DestroyList");
    printf("\t3: ClearList\n");
    printf("\t4: LocateElem");
    printf("\t5: PriorElem\n");
    printf("\t6: NextElem");
    printf("\t7: ListDelete\n");
    printf("\t8: GetElem");
    printf("\t9: ListShow\n");
    printf("\t10:ListInit");
    printf("\t11:print_cmd\n");

    
}

int main(int argc, char *argv[])
{
    SqList L;
    List_init_data(L);
    
    int cmd;
    print();
    printf("\n======Please enter your command:");
    scanf("%d", &cmd);
    
    while(cmd) {
        switch(cmd){
            case 0:
                cmd = 0;
                break;
            case 1:
                list_insert(L);
                break;
            case 2:
                destroy_list(L);
                break;
            case 3:
                clear_list(L);
                break;
            case 4:
                locate_elem(L);
                break;
            case 5:
                prior_elem(L);
                break;
            case 6:
                next_prior(L);
                break;
            case 7:
                list_delete(L);
                break;
            case 8:    
                get_elem(L);
                break;
            case 9:
                list_show(L);
                break;
            case 10:
                List_init_data(L);
                break;
            case 11:
                print();
                break;
            default:
                printf("Unknown number %d\n", cmd);
        }
        
        
        printf("\n======Please enter your command:");
        scanf("%d", &cmd);
    }
    
    //程序正常退出时输出标志
    printf("\nThe end, GoodBye...\n");
    return 0;
}


llliuyx
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表操作函数
xxxmy
10-28 2450
//构造函数，分配m个存储单元的顺序空间 templete SqList::SqList(int m) { len =0 ; if (m==0)     elem=NULL; else        elem = new ElemType [m]; size=m; } //顺序表复制 templete SqList::SqList(const SqList&r) {
线性表基本操作函数定义
05-13
线性表基本操作函数定义，创建、清空、初始化等操作函数集锦
《C语言及程序设计》实践项目——数组与函数应用
weixin_34343689的博客
05-01 333
返回：贺老师课程教学链接 【项目1-有序数组中插入数据（函数版）】　　有一个足够“大”的数组a，其中已经存储了n个呈升序排列的数据。调用函数insert(a, n, m)，可以将数m插入到a中的合适位置，使其仍然保持升序，并且返回值为数组中有效数字的个数（即原先的n加1）。　　例如，若a中数据为1 7 8 17 23 24 59 62 101，n=9，...
c语言线性表子函数调用,线性表的插入函数
weixin_36002349的博客
05-24 679
该楼层疑似违规已被系统折叠隐藏此楼查看此楼//SY2-2.CPP #include #define MAXSIZE 100void Disp_A(int A[],int num) /*输出向量*/{if(num==0) return; /*如果向量为空直接返回*/for(int i=0;icout<cout<} int insert(int A[],int ...
c语言组线性表主函数的调用,C语言大作业有序线性表精选.doc
weixin_39800957的博客
05-22 422
C语言大作业有序线性表精选作业名称：有序线性表学 院：教育实验学院班 级：HC001505学 号：2015300074姓 名：祖陆晗团队组成：祖陆晗西北工业大学2016年1月8日请填写以下十项内容，将表格按页对齐(插入空行)，勿删除任何部分。1、问题与背景(描述程序所要解决的问题或应用背景)数组是程序设计中常用的数据结构，但使用数组时必须先定义好数组长度，这个长度一经定义就...
线性表的链式实现-----单链表
07-02
这些函数的实现涉及到链表的基本操作，如指针操作和内存管理。在C语言中，这些操作需要特别注意内存泄漏和空指针引用的问题。例如，在删除节点后，需要更新指针以确保链表的连续性，并且在不再需要节点时，应使用`...
数据结构学习--线性表及其应用--顺序表
06-25
7. 主函数`main`是整个程序的入口，它调用了上述所有的函数，以实现对顺序表的一系列操作。 通过这样的实验，学习者能够更好地理解顺序表的特性和基本操作，为后续学习更复杂的数据结构如树、图等打下坚实的基础。...
线性表的基本操作-node-04-硬连接.ev4.rar
最新发布
03-25
在本教程"线性表的基本操作-node-04-硬连接"中，我们将会深入探讨线性表的核心概念、实现方式以及如何进行基本的操作。 线性表的特点在于其元素之间的顺序关系，这种顺序可以是一维的，每个元素都有一个前驱和后继...
线性表的基本操作-11-用户组相关操作.ev4.rar
03-25
线性表可以采用顺序存储或链式存储两种方式，这里我们主要关注其基本操作，如添加、删除、查找和修改用户组信息。 线性表的操作主要包括以下几类： 1. 插入操作：在线性表的任意位置插入一个新元素。例如，当创建...
算法与数据结构(一)：线性表（C++实现）
qq_41918762的博客
10-19 923
文章目录算法与数据结构(一)：线性表（C++实现）头文件定义线性表类的成员变量和成员函数头文件类成员函数的实现主函数参考：算法分析与设计(C++描述) 石志国、刘冀伟、姚亦飞编著 算法与数据结构(一)：线性表（C++实现） 在计算机内存中存放线性表的最简单和最常用的方式使用一组地址上连续的存储单元依次存储线性表的每一个元素。使线性表中相邻的元素存放在地址中相邻的物理存储单元中，这种存储结构称作顺序...
线性表与13个基本操作的实现
热门推荐
BruthYU的博客
09-24 2万+
一、宏定义解释 ElemType ：线性表数据元素数据类型 LIST_INIT_SIZE : 线性表初始数据元素容量 Status ：函数返回值（一般替换int型） error ：0 INFEASIBLE ：0 OK ：0二、线性表结构体typedef struct { ElemType *elem;
C/C++实现单链表的基本操作(严书p19的操作函数用于链表)
peRFect的博客
06-28 481
首先是常用函数的定义，预定义常量和类型，后面要用 文件comfun.h #ifndef COMFUN_H #define COMFUN_H #include<iostream> #include<cstdio> #include<cstdlib> #include<cmath> #define overlow -2 #define OK 1 #define TRUE 1 #define FALSE 0 #define ERROR 0 using namespa
《数据结构》第二章线性表
weixin_46438851的博客
01-13 846
关于顺序表和线性表最全的介绍
数据结构书p19页，顺序表的划分
04-23 320
这是线性表的一种顺序存储结构--顺序表的一个应用，对于顺序表要熟练掌握它的定义，需要一段连续的内存空间来存储，即用数组来存储，然后还要熟练掌握顺序表的插入，删除，初始化，取表元，及按值查找。。。。。。 （一）对于线性表的基本操作： （1）初始化：构造空表。 Init_List(L); （2）求表长：球线性表中元素的个数。 ...
线性表之顺序表的基本操作
hua_you_qiang的博客
02-16 1452
线性表的定义 线性表是具有相同数据类型的 n(n>=0)n(n>= 0)n(n>=0)个数据元素的有限序列，其中nnn为表长，当n=0n=0n=0时线性表是一个空表。若用LLL命名线性表，则其一般表示为L=(a1,a2,...,ai,ai+1,...,an)L=(a_1,a_2,...,a_i,a_{i+1}, ..., a_n)L=(a1​,a2​,...,ai​,ai+1​,...,an​)式中，a1a_1a1​是唯一的"第一个"数据元素，又称表尾元素。除第一个元素外，每个元素有且仅有
实验一：线性表的基本操作实现及其应用
M_Mango的博客
04-14 812
一、实验目的 1、   熟练掌握线性表的结构特点，掌握顺序表的基本操作。 2、   巩固C++相关的程序设计方法与技术。 3、   学会使用顺序表解决实际问题。 二、实验内容 顺序表的建立与操作实现 建立n个元素的顺序表（n的大小和表里数据自己确定），实现相关的操作：输出，插入，删除，查找等功能。编写完整程序实现，程序语言不限定，使用技术形式不定。三、实验步骤 1、依据实验内容分别说明实验程序中用...
c语言可以用函数创建线性表,通过C语言调用函数的方式来实现线性表的基本操作.doc...
weixin_39921087的博客
05-20 619
通过C语言调用函数的方式来实现线性表的基本操作.doc下载提示(请认真阅读)1.请仔细阅读文档，确保文档完整性，对于不预览、不比对内容而直接下载带来的问题本站不予受理。2.下载的文档，不会出现我们的网址水印。3、该文档所得收入(下载+内容+预览)归上传者、原创作者；如果您是本文档原作者，请点此认领！既往收益都归您。文档包含非法信息？点此举报后获取现金奖励！下载文档到电脑，查找使用更方便9.9积分还...
第7周 C语言及程序设计提高例程-26 实现线性表基本操作的函数
时缔&实验室
05-10 1068
问题及答案： /*删除指定位置上的数据*/ #include #define SIZE 100 int deletedate(int[],int,int); int n=10; //数组中实际有用的数据 int main() { int a[SIZE]={25,45,36,48,89,57,65,25,26,16}; int i,locate; scanf("%d",&lo
线性表与顺序表详解-C++实现
在C++中，可以使用结构体或类来定义线性表的元素，通过动态内存分配来创建链表，或者使用数组来实现顺序表。对于顺序表，可以利用STL中的`std::vector`容器，对于链表，可以使用`std::list`容器。 理解并熟练掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值