数据结构（顺序表）（下）

最新推荐文章于 2023-04-08 16:13:17 发布
最新推荐文章于 2023-04-08 16:13:17 发布
阅读量272 收藏 4
点赞数 1
分类专栏： 基于Linux的C语言数据结构 文章标签： c++ 数据结构 c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59700590/article/details/126236097
版权

目录

1、前言

2.工程文件

        2.1：删除数据

                2.2修改数据

2.3:查找数据

        2.4：显示数据 。

2.4销毁顺序表

    3、主函数的编写

4、makefile的编写

        4.1总makefile

        4.2src中的makefile 

5、后记

1、前言

        在上一篇文章中我们写了两个函数分别为创建空间和插入数据，在这篇文章中，我们开始编写其他的函数，主函数和makefile我们在下一篇文章中进行编写，

2.工程文件

        2.1：删除数据

 我们还是先画一张图，我们要把88这个数据进行删除，那么我们要怎么删除呢？我们先来写一下伪代码

//在删除之前我们先要把我们要删除的数据进行保存，当然也可以不保存，看个人的习惯
//将pos以后的数据向前移动一位数据
for(int i=pos;i<count-1;i++)
{
    arr[i]=a[i+1];
}
//或者下面这种方式
for(int i=pos;i<count;i++)
{
    a[i-1]=a[i];
}
count--;

我们接下来在我们原来的list.c中继续编写我们的子函数

//创建顺序表
int my_malloc_func(SeqList **ppList)
{
    //入参检查
    if(NULL == ppList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //开辟空间
    *ppList=(SeqList *)malloc(sizeof(SeqList));
    //查看开间开辟与否
    if(NULL==*pList)
    {
        printf("mallo error: ");
        return MALLOC_ERROR;
    }
    //初始化开辟的空间值
    memset(*ppList,'\0',sizeof(SeqList));
    return OK;

}

//在顺序表中插入数据
//函数第一个参数是结构体指针，第二个是插入的位置，第三个参数是要插入的数据
int my_insert(SeqList *pList,int pos ,int Newdata)
{
    //还是入参检查
    if(NULL == pList)
    {
        printf("creat error: ");
        return CREAT_ERROR;
    }
    //判断插入的位置是否合适
    if(pos<0 || pos>=count)
    {
        printf("pos error: ")
        return POS_ERROR;
    }
    //在插入的时候我们还要注意我们的顺序表是否满了，
    //因为插入是要有空余位置才能插入
    if(10==pList->count)
    {
        printf("full error: ");
        return FULL ERROR;
    }
    //开始插入
    //将pos以后的数据向后移一个
    for(int i=pList->count-1;i>=pos;i--)
    {
        pList->arr[i+1]=pList->a[i];
    }
    pList->arr[pos]=Newdata;
    pList->count++;
    return OK;
}


//删除数据函数
//参数1 结构体指针
//参数2 位置
// 参数3 保存删除数据的值
int my_delete(SeqList *pList,int pos,data_type *pdeledata)
{
    //入参检查
    if(NULL==pList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //判断删除的位置
    //不能删除0以下和大于等于count的位置
    if(pos<0 || pos>=pList->count)
    {
        printf("pos error: ");
        return POS_ERROR;
    }
    //还有一种情况就是表空的情况下是不能删除的
    if(0==pList->count)
    {
        printf("empty error: ");
        return EMPTY_ERROR;
    }
    //保存要删除的数据
    *pdeldata=pList->arr[pos];
    //执行删除
    for(int i=pos;i<pList->count-1;i++)
    {
        pList->arr[i]=pList->arr[i+1];
    }
    //更新count中的值
    pList->count--;
    return OK;
}

         我们接下来更新一下我们的库文件

#ifndef _LIST_H
#define _LIST_H
//引入头文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//创建结构体
//数据类型的定义
typedef int data_type
struct seqlist
{
    data_type arr[10];
    data_type count;
}SeqList;

//定义错误枚举，在这里我把我们接下来可能出现的错误进行定义，以便我们可以快速查找错误
enum value
{
    EMPTY_ERROR=-7,
    FULL_ERROR,
    POS_ERROR,
    CREAT_ERROR,
    NULL_ERROR,
    MALLOC_ERROR,
    ERROR,
    OK
};

//函数说明
int my_mollac_func(SeqList **ppList);//开辟空间函数
int my_insert(SeqList *pList,int pos,int Newdata);//插入函数
int my_delete(SeqList *pList,int pos,int *pdeldata);//删除数据



#endif

                2.2修改数据

//创建顺序表
int my_malloc_func(SeqList **ppList)
{
    //入参检查
    if(NULL == ppList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //开辟空间
    *ppList=(SeqList *)malloc(sizeof(SeqList));
    //查看开间开辟与否
    if(NULL==*pList)
    {
        printf("mallo error: ");
        return MALLOC_ERROR;
    }
    //初始化开辟的空间值
    memset(*ppList,'\0',sizeof(SeqList));
    return OK;

}

//在顺序表中插入数据
//函数第一个参数是结构体指针，第二个是插入的位置，第三个参数是要插入的数据
int my_insert(SeqList *pList,int pos ,int Newdata)
{
    //还是入参检查
    if(NULL == pList)
    {
        printf("creat error: ");
        return CREAT_ERROR;
    }
    //判断插入的位置是否合适
    if(pos<0 || pos>=count)
    {
        printf("pos error: ")
        return POS_ERROR;
    }
    //在插入的时候我们还要注意我们的顺序表是否满了，
    //因为插入是要有空余位置才能插入
    if(10==pList->count)
    {
        printf("full error: ");
        return FULL ERROR;
    }
    //开始插入
    //将pos以后的数据向后移一个
    for(int i=pList->count-1;i>=pos;i--)
    {
        pList->arr[i+1]=pList->a[i];
    }
    pList->arr[pos]=Newdata;
    pList->count++;
    return OK;
}


//删除数据函数
//参数1 结构体指针
//参数2 位置
// 参数3 保存删除数据的值
int my_delete(SeqList *pList,int pos,data_type *pdeledata)
{
    //入参检查
    if(NULL==pList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //判断删除的位置
    //不能删除0以下和大于等于count的位置
    if(pos<0 || pos>=pList->count)
    {
        printf("pos error: ");
        return POS_ERROR;
    }
    //还有一种情况就是表空的情况下是不能删除的
    if(0==pList->count)
    {
        printf("empty error: ");
        return EMPTY_ERROR;
    }
    //保存要删除的数据
    *pdeldata=pList->arr[pos];
    //执行删除
    for(int i=pos;i<pList->count-1;i++)
    {
        pList->arr[i]=pList->arr[i+1];
    }
    //更新count中的值
    pList->count--;
    return OK;
}

//修改数据
int my_revise(SeqList *pList,int pos,int Newdata)
{
    //入参检查
    if(NULL==pList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //判断位置是否合适
    if(pos<0 || pos>=pList->count)
    {
        printf("pos error : ");
        return POS_ERROR;
    }
    //修改数据
    pList->arr[pos]=Newdata;
    return OK;
}

更新一下库文件

#ifndef _LIST_H
#define _LIST_H
//引入头文件
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//创建结构体
//数据类型的定义
typedef int data_type
struct seqlist
{
    data_type arr[10];
    data_type count;
}SeqList;

//定义错误枚举，在这里我把我们接下来可能出现的错误进行定义，以便我们可以快速查找错误
enum value
{
    EMPTY_ERROR=-7,
    FULL_ERROR,
    POS_ERROR,
    CREAT_ERROR,
    NULL_ERROR,
    MALLOC_ERROR,
    ERROR,
    OK
};

//函数说明
int my_mollac_func(SeqList **ppList);//开辟空间函数
int my_insert(SeqList *pList,int pos,int Newdata);//插入函数
int my_delete(SeqList *pList,int pos,int *pdeldata);//删除数据
int my_revise(SeqList *pList,int pos,int Newdata);



#endif

2.3:查找数据

我们直接上代码，其中的一些注意点我将会在代码中说明

//创建顺序表
int my_malloc_func(SeqList **ppList)
{
    //入参检查
    if(NULL == ppList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //开辟空间
    *ppList=(SeqList *)malloc(sizeof(SeqList));
    //查看开间开辟与否
    if(NULL==*pList)
    {
        printf("mallo error: ");
        return MALLOC_ERROR;
    }
    //初始化开辟的空间值
    memset(*ppList,'\0',sizeof(SeqList));
    return OK;

}

//在顺序表中插入数据
//函数第一个参数是结构体指针，第二个是插入的位置，第三个参数是要插入的数据
int my_insert(SeqList *pList,int pos ,int Newdata)
{
    //还是入参检查
    if(NULL == pList)
    {
        printf("creat error: ");
        return CREAT_ERROR;
    }
    //判断插入的位置是否合适
    if(pos<0 || pos>=count)
    {
        printf("pos error: ")
        return POS_ERROR;
    }
    //在插入的时候我们还要注意我们的顺序表是否满了，
    //因为插入是要有空余位置才能插入
    if(10==pList->count)
    {
        printf("full error: ");
        return FULL ERROR;
    }
    //开始插入
    //将pos以后的数据向后移一个
    for(int i=pList->count-1;i>=pos;i--)
    {
        pList->arr[i+1]=pList->a[i];
    }
    pList->arr[pos]=Newdata;
    pList->count++;
    return OK;
}


//删除数据函数
//参数1 结构体指针
//参数2 位置
// 参数3 保存删除数据的值
int my_delete(SeqList *pList,int pos,data_type *pdeledata)
{
    //入参检查
    if(NULL==pList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //判断删除的位置
    //不能删除0以下和大于等于count的位置
    if(pos<0 || pos>=count)
    {
        printf("pos error: ");
        return POS_ERROR;
    }
    //还有一种情况就是表空的情况下是不能删除的
    if(0==pList->count)
    {
        printf("empty error: ");
        return EMPTY_ERROR;
    }
    //保存要删除的数据
    *pdeldata=pList->arr[pos];
    //执行删除
    for(int i=pos;i<pList->count-1;i++)
    {
        pList->arr[i]=pList->arr[i+1];
    }
    //更新count中的值
    pList->count--;
    return OK;
}

//修改数据
int my_revise(SeqList *pList,int pos,int Newdata)
{
    //入参检查
    if(NULL==pList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //判断位置是否合适
    if(pos<0 || pos>=pList->count)
    {
        printf("pos error : ");
        return POS_ERROR;
    }
    //修改数据
    pList->arr[pos]=Newdata;
    return Ok;
}


//查找函数
//第一个参数依旧是我们的结构体指针
//第二个参数是查找的数据
/*第三个数据是我要着重讲的，我们在查找的时候可能会有多个数据符合，这时我们在主函数中
定义一个数组用来存放数据的下标，这样可以把所有的数据找到*/
int my_search(SeqList *pList,int searchdata,int *pdata)
{
    int i,j=0;
    if(NULL==*pList)
    {
        printf("null_error:");
        return NULL_error;
    }
    if(NULL==pdata)
    {
        printf("creat error:");
        return CREAT_ERROR;
    }
    for(i=0;i<pList->count;i++)
    {
        if(searchdata==pList->arr[i])
        {
            *(pdata+j)=i;
            j++;
        }
    }
    return j;
}

   读者可以自己更新一下库文件，篇幅问题我只在最后更新库文件了，如果读者想要自己去验证一下每个函数可以自行更新。

        2.4：显示数据 。

                我们在这个函数中，将顺序表进行打印，其实比较简单，就是一个for循环

//创建顺序表
int my_malloc_func(SeqList **ppList)
{
    //入参检查
    if(NULL == ppList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //开辟空间
    *ppList=(SeqList *)malloc(sizeof(SeqList));
    //查看开间开辟与否
    if(NULL==*pList)
    {
        printf("mallo error: ");
        return MALLOC_ERROR;
    }
    //初始化开辟的空间值
    memset(*ppList,'\0',sizeof(SeqList));
    return OK;

}

//在顺序表中插入数据
//函数第一个参数是结构体指针，第二个是插入的位置，第三个参数是要插入的数据
int my_insert(SeqList *pList,int pos ,int Newdata)
{
    //还是入参检查
    if(NULL == pList)
    {
        printf("creat error: ");
        return CREAT_ERROR;
    }
    //判断插入的位置是否合适
    if(pos<0 || pos>=count)
    {
        printf("pos error: ")
        return POS_ERROR;
    }
    //在插入的时候我们还要注意我们的顺序表是否满了，
    //因为插入是要有空余位置才能插入
    if(10==pList->count)
    {
        printf("full error: ");
        return FULL ERROR;
    }
    //开始插入
    //将pos以后的数据向后移一个
    for(int i=pList->count-1;i>=pos;i--)
    {
        pList->arr[i+1]=pList->a[i];
    }
    pList->arr[pos]=Newdata;
    pList->count++;
    return OK;
}


//删除数据函数
//参数1 结构体指针
//参数2 位置
// 参数3 保存删除数据的值
int my_delete(SeqList *pList,int pos,data_type *pdeledata)
{
    //入参检查
    if(NULL==pList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //判断删除的位置
    //不能删除0以下和大于等于count的位置
    if(pos<0 || pos>=count)
    {
        printf("pos error: ");
        return POS_ERROR;
    }
    //还有一种情况就是表空的情况下是不能删除的
    if(0==pList->count)
    {
        printf("empty error: ");
        return EMPTY_ERROR;
    }
    //保存要删除的数据
    *pdeldata=pList->arr[pos];
    //执行删除
    for(int i=pos;i<pList->count-1;i++)
    {
        pList->arr[i]=pList->arr[i+1];
    }
    //更新count中的值
    pList->count--;
    return OK;
}

//修改数据
int my_revise(SeqList *pList,int pos,int Newdata)
{
    //入参检查
    if(NULL==pList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //判断位置是否合适
    if(pos<0 || pos>=pList->count)
    {
        printf("pos error : ");
        return POS_ERROR;
    }
    //修改数据
    pList->arr[pos]=Newdata;
    return Ok;
}


//查找函数
//第一个参数依旧是我们的结构体指针
//第二个参数是查找的数据
/*第三个数据是我要着重讲的，我们在查找的时候可能会有多个数据符合，这时我们在主函数中
定义一个数组用来存放数据的下标，这样可以把所有的数据找到*/
int my_search(SeqList *pList,int searchdata,int *pdata)
{
    int i,j=0;
    if(NULL==*pList)
    {
        printf("null_error:");
        return NULL_error;
    }
    if(NULL==pdata)
    {
        printf("creat error:");
        return CREAT_ERROR;
    }
    for(i=0;i<pList->count;i++)
    {
        if(searchdata==pList->arr[i])
        {
            *(pdata+j)=i;
            j++;
        }
    }
    return j;
}

//显示函数
int my_display(SeqList *pList)
{
    if(NULL==pList)
    {
        printf(:null error:");
        return NULL_ERROR;
    }
    for(int i=0;i<pList->count;i++)
    {
        printf("%2d",pList->arr[i]);
    }
    return OK;
}

2.4销毁顺序表

        销毁顺序表主要运用了malloc函数和堆区的特点，在堆区由程序员开辟空间，释放空间也得程序员自己手动释放

//创建顺序表
int my_malloc_func(SeqList **ppList)
{
    //入参检查
    if(NULL == ppList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //开辟空间
    *ppList=(SeqList *)malloc(sizeof(SeqList));
    //查看开间开辟与否
    if(NULL==*pList)
    {
        printf("mallo error: ");
        return MALLOC_ERROR;
    }
    //初始化开辟的空间值
    memset(*ppList,'\0',sizeof(SeqList));
    return OK;

}

//在顺序表中插入数据
//函数第一个参数是结构体指针，第二个是插入的位置，第三个参数是要插入的数据
int my_insert(SeqList *pList,int pos ,int Newdata)
{
    //还是入参检查
    if(NULL == pList)
    {
        printf("creat error: ");
        return CREAT_ERROR;
    }
    //判断插入的位置是否合适
    if(pos<0 || pos>=count)
    {
        printf("pos error: ")
        return POS_ERROR;
    }
    //在插入的时候我们还要注意我们的顺序表是否满了，
    //因为插入是要有空余位置才能插入
    if(10==pList->count)
    {
        printf("full error: ");
        return FULL ERROR;
    }
    //开始插入
    //将pos以后的数据向后移一个
    for(int i=pList->count-1;i>=pos;i--)
    {
        pList->arr[i+1]=pList->a[i];
    }
    pList->arr[pos]=Newdata;
    pList->count++;
    return OK;
}


//删除数据函数
//参数1 结构体指针
//参数2 位置
// 参数3 保存删除数据的值
int my_delete(SeqList *pList,int pos,data_type *pdeledata)
{
    //入参检查
    if(NULL==pList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //判断删除的位置
    //不能删除0以下和大于等于count的位置
    if(pos<0 || pos>=count)
    {
        printf("pos error: ");
        return POS_ERROR;
    }
    //还有一种情况就是表空的情况下是不能删除的
    if(0==pList->count)
    {
        printf("empty error: ");
        return EMPTY_ERROR;
    }
    //保存要删除的数据
    *pdeldata=pList->arr[pos];
    //执行删除
    for(int i=pos;i<pList->count-1;i++)
    {
        pList->arr[i]=pList->arr[i+1];
    }
    //更新count中的值
    pList->count--;
    return OK;
}

//修改数据
int my_revise(SeqList *pList,int pos,int Newdata)
{
    //入参检查
    if(NULL==pList)
    {
        printf("null error: ");
        return NULL_ERROR;
    }
    //判断位置是否合适
    if(pos<0 || pos>=pList->count)
    {
        printf("pos error : ");
        return POS_ERROR;
    }
    //修改数据
    pList->arr[pos]=Newdata;
    return Ok;
}


//查找函数
//第一个参数依旧是我们的结构体指针
//第二个参数是查找的数据
/*第三个数据是我要着重讲的，我们在查找的时候可能会有多个数据符合，这时我们在主函数中
定义一个数组用来存放数据的下标，这样可以把所有的数据找到*/
int my_search(SeqList *pList,int searchdata,int *pdata)
{
    int i,j=0;
    if(NULL==*pList)
    {
        printf("null_error:");
        return NULL_error;
    }
    if(NULL==pdata)
    {
        printf("creat error:");
        return CREAT_ERROR;
    }
    for(i=0;i<pList->count;i++)
    {
        if(searchdata==pList->arr[i])
        {
            *(pdata+j)=i;
            j++;
        }
    }
    return j;
}

//显示函数
int my_display(SeqList *pList)
{
    if(NULL==pList)
    {
        printf(:null error:");
        return NULL_ERROR;
    }
    for(int i=0;i<pList->count;i++)
    {
        printf("%2d",pList->arr[i]);
    }
    return OK;
}

// 销毁函数
int my_release(SeqList **ppList)
{
    if(NULL==ppList)
    {
        printf("null error:");
        return NULL_ERROR;
    }
    if(NULL==*ppList)
    {
        printf("creat error:");
        return CREAT_ERROR;
    }
    free(*ppList);
    *ppList=NULL;
}

    3、主函数的编写

        如果你看到这里恭喜你，我们已经完成了所有的子函数的编写，接下来读者可以自行编写主函数了，也可以模仿我的主函数的写法，万变不离其宗，

#include "../include/list.h"

int main()
{
    int ret;
    //开辟空间
    SeqList *pList=NULL;
    ret=my_malloc_func(&pList);
    if(ret<0)
    {
        return error;
    }
    printf("申请成功");
    //实现插入数据到顺序表中
    data_type data,pos;
    while(1)
    {
        printf("请输入插入的数据\n");
        scanf("%d",&pos);
        printf("请输入要插入的数据\n");
        scanf("%d",&data);
        if(pos==-1)
        {
            printf("插入完成\n");
            break;
        }
        my_insert(pList,pos,data);
        printf("显示顺序表");
        my_diaplay(pList);
    }
    //销毁顺序表
    my_release(pList);
    return 0;
}
//其他的子函数可以根据读者自己的习惯进行调用即可，我如果全部调用，代码实在是太多了
//还请理解一下我，这篇文章的篇幅实在太长，我下面还要写makefile，大家多多包涵

4、makefile的编写

        这个C语言的工程足够大了，我们接下来把我们学过的makefile用一下

        4.1总makefile

MYAPP:=main
OBJS:=list.o text.o
CC:=gcc
CFLGAS:=-c -g -Wall

export MYAPP OBJS CC CFLGAS

ALL:
    make -C src
    make -C obj
.PHONY.clean
clean:
    $(RM) obj/*.o
    $(RM) bin/*

        4.2src中的makefile 

ALL:$(OBJS)
    mv *.o ../obj/
list.o:list.c:
    $(CC) $(CFLGAS) $< -o $@
main.o:main.c
    $(CC) $(CFLGAS) $< -o $@

        4.3：obj中的makefile

        

ALL:$(MYAPP)
    mv * ../bin
$(MYAPP):$(OBJS)
    $(CC) $^ -o $@

5、后记

 我花费了两篇文章带大家认识顺序表和编写了顺序表的子函数以及主函数还把我们学的makefile运用了一下，我带大家敲了了一遍代码，说实话，如果只讲理论可能写不了这么多，但是大家学数据结构还是运用的多，所以我还是把代码敲了出来，也许在这些代码中有一些错误，如果大家看出来了还请告诉我，好了顺序表完结了，撒花，我们下一篇开单链表，我还会再开一个专栏讲IO感兴趣的同学也可以去看看，有不足的地方还请各位大佬帮我指出来

 

 

                

学习C语言之路
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【C语言->数据结构与算法】->关于主函数带参
欢迎来到新世界
02-18 830
这篇文章会简单介绍一下关于主函数的参数。 在Sublime中，当你敲int main时直接回车会出现以下代码???? int main(int argc, char const *argv[]) { /* code */ return 0; } (int argc, char const *argv[]) 即为主函数的参数。 主函数的参数个数只能是两个，且类型只能int 和 char **。 第...
数据结构顺序表操作示例
09-04
数据结构中的顺序表是一种基本的线性数据结构，它的特点是所有元素存储在一块连续的内存空间中，元素之间的逻辑顺序与物理顺序一致。在顺序表上进行操作时，主要有插入和删除等基本操作。 1. **插入操作**： 在...
【数据结构】顺序表基本操作
℉f的博客
04-08 1371
顺序表基本操作
【数据结构与算法】顺序表的基本操作实现
一以贯之的努力 不得懈怠的人生
09-19 3363
🔥 本文由程序喵正在路上原创，CSDN首发！💖 系列专栏：数据结构与算法🌠 首发时间：2022年9月19日🌟 一以贯之的努力 不得懈怠的人生。
线性表之顺序表（干货满满的分享来啦~内含顺序表全部函数代码~
vpurple_的博客
07-29 408
干货满满的分享来啦！！欢迎光临，这里是媛仔的数据结构进阶之路~
合工大数据结构顺序表实验
04-14
本实验“合工大数据结构顺序表实验”聚焦于数据结构中的一个重要基础概念——顺序表。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们...
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
数据结构顺序表c++代码
12-06
本文将深入探讨“数据结构顺序表”的概念以及如何使用C++实现它的基本操作，包括创建、查找、插入和删除。 顺序表，顾名思义，是元素在内存中按照线性顺序排列的数组。它具有连续的存储空间，每个元素都有一个固定...
数据结构C++顺序表
03-04
本主题聚焦于一种基础且重要的数据结构——顺序表，尤其关注如何在C++中实现这一概念。 顺序表是一种线性数据结构，其中元素在内存中按顺序存储。在C++中，我们可以使用数组来实现顺序表。这种结构的优点是访问速度...
数据结构-main函数
张建波专栏
02-09 2806
//#include "stdx.h"#include "Menu.h"#include "fx.h"#include #include int main(){     Menu MainMenu[11];    //主菜单    MainMenu[1].Name="运动会分数统计";  //菜单项赋值     MainMenu[2].Name="一元多项式计算";     MainMenu[3]
[数据结构]顺序表的实现-C++
炼丹师
05-16 686
因为要考研，所以开始复习数据结构，每看完一个知识点，就用C++实现一下，以便加深印象 第一个知识点是顺序表，就是封装对一个数组的操作，排序什么的等到后边复习到了再来补充，现在只有增删改查 因为之前都是用java写各种项目作业什么的，所以C++语法忘得差不多的，正在慢慢捡回来，正好趁这次机会重新看了一下模板类，就用模板类实现了 //SequenceTable.h #p
数据结构：线性表中的顺序表(定长顺序表)
Kobe51920的博客
01-04 510
顺序表的概念： 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中（简单的讲就是逻辑相邻...
顺序表的常规函数
Sneexy的博客
04-26 434
struct SeqList//结构体定义顺序表 { int data[100]; int length; }; void InitList(SeqList *&s)//初始化 { s=(SeqList *)malloc(sizeof(SeqList)); s->length=0; } void Insert(SeqList *&s,int num)//
数据结构之顺序表（c语言版）
cgl_dong的博客
11-29 621
数据结构之顺序表 线性表是最简单的数据结构，而顺序表又是最简单的线性表，其基本思想是用一段地址连续的储存单元依次存储线性表的数据元素; 数组就是线性表，不过通常作为内置的数据结构，顺序表用数组为底层容器，优点在于可以动态增加删除元素，还可以自定义查找。 一、C语言实现 #include<stdio.h> #include<stdlib.h> # define MAXSIZE...
数据结构初阶——顺序表
热门推荐
m0_64607843的博客
04-29 1万+
博客写到这里，关于C语言的相关内容就告一段落了，从这篇开始，跟我一起进入一个全新的领域吧。把顺序表的代码放到了结尾。击鼓进军数据结构！！！
数据结构顺序表和链表
最新发布
09-06
数据结构中，顺序表和链表是两种不同的存储结构。 顺序表是一种线性结构，它通过一段物理地址连续的存储单元来存储数据元素，并且采用数组的形式进行存储。顺序表在数组上完成数据的增删查改操作，同时记录表的长度...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

学习C语言之路

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

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

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

打赏作者

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

抵扣说明：

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

余额充值