数据结构day1

于 2023-03-07 21:14:48 发布
阅读量105 收藏 1
点赞数 1
文章标签： c语言 c++ 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dshycorz/article/details/129391831
版权

顺序表的各种操作

顺序表的操作包括增删改查，细分出来包括：

创建一个空的顺序表

向顺序表中插入数据

遍历并打印数据

判断顺序表是否为空

判断顺序表是否为满

删除顺序表中数据并返回数据

根据数据修改数据

根据位置修改数据

根据位置查找数据

根据数据查找位置

一、本程序的各种函数操作

  1. 头文件和全局变量声明

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

#define N 128
typedef int datatype;   //重定义

typedef struct         //定义一个结构体
{
    datatype data[N];
    int last;
}seqlist;

  1. 创建一个空的顺序表

//创建一个空的顺序表
seqlist *seqlistCreate()
{
    seqlist *s = (seqlist*)malloc(size(seqlist));
    s->last = -1;
    return s;
}

//创建结构体时要考虑到内存的存储位置
//如果存储在栈区，函数结束后，内存被释放，无法在主函数中对顺序表进行后续的操作 —— 不可行，不可取
//如果存储在静态区，主函数结束，内存才被释放，可以在主函数中对顺序表进行后续的操作，但会造成一定的资源浪费 —— 可行，不可取
//如果存储在堆区，由程序员自主申请，自主释放，可以在主函数中对顺序表进行后续的操作 —— 可行，可取

  1. 向顺序表中插入数据

//向顺序表中插入数据
void seqlistInsert(seqlist *s,datatype)
{
    //判断是否为满
    if(seqlistlsFull(s))
{
        printf("本顺序表以满\n");
    return ;
}
        //last自增
    s->last++;
        //插入数据到last的位置
    s->data[s->last]=value;
    return;    
}

  1. 遍历并打印数据

//打印顺序表里数据
void seqlistPrint(seqlist *s)
{
    int i=0;
    for(i=0;i<=s->last;i++)
{
    printf("%d",s->data[i]);
}
    putcahr(10);
    return;
}

  1. 判断顺序表是否为空

//判断顺序表是否为空
bool seqlistIsEmpty(seqlist *s)
{
    if(s->last<0)
{
    return true;
}
    else
{
    return false;
}

//return s->last<0?true:false;//三目运算符
}

  1. 判断顺序表是否为满

//判断顺序表是否为满
bool seqlistIsEmpty(seqlist *s)
{
    if(s->last==N-1)
{
    return true;
}
    else
{
    return false;
}

//return s->last==N-1?true:false;//三目运算符
}

  1. 删除顺序表中数据并返回数据

//删除顺序表中数据并返回数据在主函数打印删除的数
datatype seqlistDelete(seqlist *s)
{
//如果顺序表为空，就不执行后续操作
    if(seqlistIsEmpty(s))
    {
        printf("这个顺序表是空的\n");
        return (datatype)-1;
    }
//用del临时存放将要删除的数据
    datatype del = s->data[s->last];
//last自减，删除（不访问的）数据
        s->last--;
        return del;
}

  1. 根据数据修改数据

//根据数据修改数据
void seqlistModifyDataByData(seqlist *s,datatype oldValue,datatype newValue)
{
    int i = 0;
    bool iFind = false;
    if(seqlistEmpty(s))
    {
        printf("这个顺序表是空的");
        return;
    }
    for(i=0;i<=s->last;i++)
    {
        if(s->data[i]==oldValue)
            {
                s->data[i] = newValue;
                iFind = true;
            }
    }
if(!iFind)
{
printf("所需的数值未查找到")；
}
return;
}

  1. 根据位置修改数据

//根据位置修改数据
void seqlistModifyDataByPos(seqlist *s,int pos,datatype newValue)
{
    int i = 0;
    bool iFind = false;
    if(seqlistEmpty(s))
    {
        printf("这个顺序表是空的");
        return;
    }
    for(i=0;i<=last;i++)
    {
        if(i==pos)
            {
                s->data[i] = newValue;
                iFind = true;
            }
    }
if(!iFind)
{
printf("所需的数值未查找到")；
}
return;
}

  1. 根据位置查找数据

datatype seqlistSearchDataByPos(seqlist *s, int pos)
{
 if(seqlistIsEmpty(s)){
        printf("本顺序表为空\n");
        return (datatype)-1;
    }
    if(pos < 0 || pos > s->last){
        printf("the pos you choosed(%d) is invalid\n", pos);
        return (datatype)-1;
    }
    return s->data[pos];
}//在主函数中接收改函数返回的数据值。

  1. 根据数据查找（第一个）数据的位置

int seqlistSearchPosByData(seqlist *s, datatype value){
    int i = 0;
    if(seqlistIsEmpty(s)){
        printf("the seqlist is empty\n");
        return -1;
    }
    for(i = 0; i <= s->last; i++){
        if(s->data[i] == value){
            return i;
        }
    }
    printf("the data you choosed(%d) is not exist\n", value);
    return -1;
}

  1. 在一个位置插入一个数

void seqlistlnsertbyPos(seqlist *s,int pos,datatype value)
{
    if(pos<0||pos>s->last+1)
    {
    printf("位置不合理\n");
    return ;
    }
    int i;
    for(i=s->last;i>=pos;i--)
    {
        s->data[i+1] = s->data[i];
    }
    s->data[pos]=value;
    s->last++;
    return;
}

13.删除某个位置的数，并返回这个数

datatype seqlistDeletetbyPos(seqlist *s,int pos)
{    
    
    if(pos < 0 || pos > N)
    {
    printf("位置不合理\n");
    return (datatype)-1;
    }
    int i;
    datatype del = s->data[pos];
    for(i=pos;i<=s->last;i++)
    {
        s->data[i] = s->data[i+1];
    } 
    s->last--;
    return del;
}

二、运行（在一个程序中）

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

#define N 128
typedef int datatype;
typedef struct
{
    datatype data[N];
    int last;
}seqlist;

seqlist *seqlistCreate();
void seqlistlnsert(seqlist *s, datatype value);
void seqlistPrint(seqlist*s);
datatype seqlistDelete(seqlist*s);
bool seqlistIsEmpty(seqlist *s);
bool seqlistIsFull(seqlist *s);
void seqlistModifyDataByData(seqlist *s,datatype oldValue,datatype newValue);

void seqlistModifyDataByPos(seqlist *s,int pos,datatype newValue);
void seqlistFindbyPos(seqlist *s,int pos);

void seqlistFindbyData(seqlist *s,datatype value);
void seqlistlnsertbyPos(seqlist *s,int pos,datatype value);
datatype seqlistDeletetbyPos(seqlist *s,int pos);



seqlist *seqlistCreate()
{
    seqlist *s = (seqlist*)malloc(sizeof(seqlist));
    s->last = -1;
    return s;
}

void seqlistlnsert(seqlist *s, datatype value)
{
    s->last++;
    s->data[s->last]=value;
    return;
}


void seqlistPrint(seqlist*s)
{
    int i=0;
        for (int i=0 ; i <= s->last; i++)
    {
        printf("%d ",s->data[i]);
    }
   putchar(10);
   return; 
}


datatype seqlistDelete(seqlist*s)
{
   if(seqlistIsEmpty(s))
   {
       printf("该文件为空\n");
       return (datatype)-1;
   }
    datatype del = s -> data[s->last];
    s->last--;

    return del;
}

bool seqlistIsEmpty(seqlist *s)
{
    if(s->last<0)
    {
        return true;
    }
    else
    {
        return false;
    }
    //return s->last <0?true:false;//三目运算符
}


bool seqlistIsFull(seqlist *s)
{
    if(s->last<N-1)
    {
        return true;
    }
    else
    {
        return false;
    }
    //return s->last <N-1?true:false;//三目运算符
}

void seqlistModifyDataByData(seqlist *s,datatype oldValue,datatype newValue)
{
    int i;
    bool iFind = false;
    if(seqlistIsEmpty(s))
    {
        printf("该文件为空\n");
       return ;
    }
    for(i=0;i<=s->last;i++)
    {
        if(s->data[i] == oldValue)
        {
            s->data[i] = newValue;
            iFind = true;
        }
    }
    if (!iFind)
    {
        printf("这个数据(%d)没有找到",oldValue);
    }
    return;
}

//根据位置修改
void seqlistModifyDataByPos(seqlist *s,int pos,datatype newValue)
{
    int i;
    bool iFind = false;
    if(seqlistIsEmpty(s))
    {
        printf("该文件为空\n");
       return ;
    }

    if(pos<0||pos>128)
    {
    printf("位置不合理\n");
    return ;
    }
        for(i=0;i<=s->last;i++)
    {
        if(i==pos)
        {
            s->data[i] = newValue;
            iFind = true;
        }
    }
    if (!iFind)
    {
        printf("这个位置(%d)没有找到",pos);
    }
    return;
}


//根据位置查找数据
void seqlistFindbyPos(seqlist *s,int pos)
{
    int i;
    bool flag = false;

    if(pos<0||pos>128)
    {
    printf("位置不合理\n");
    return ;
    }
        for(i=0;i<=s->last;i++)
    {
        if(i==pos)
        {
           printf("下标为%d的数值为：%d\n",pos,s->data[i]);
           flag=true;
        }
    }
    if (!flag)
    {
        printf("这个位置(%d)没有找到\n",pos);
    }
    return;
}

//根据数据查找位置
void seqlistFindbyData(seqlist *s,datatype value)
{
        int i;
    bool iFind = false;

        for(i=0;i<=s->last;i++)
    {
        if(s->data[i]==value)
        {
           printf("数值%d的下标为：%d\n",value,i);
           iFind=true;
        }
    }
    if (!iFind)
    {
        printf("这个数值(%d)没有找到\n",value);
    }
    return;
}


//在顺序表之间添加数据
void seqlistlnsertbyPos(seqlist *s,int pos,datatype value)
{
    if(pos<0||pos>s->last+1)
    {
    printf("位置不合理\n");
    return ;
    }
    int i;
    for(i=s->last;i>=pos;i--)
    {
        s->data[i+1] = s->data[i];
    }
    s->data[pos]=value;
    s->last++;
    return;
}


//在顺序表之间按下标删除数据
datatype seqlistDeletetbyPos(seqlist *s,int pos)
{
    
    printf("位置不合理\n");
    if(pos < 0 || pos > (s->last+1))
    {
    printf("位置不合理\n");
    return (datatype)-1;
    }
    int i;
    datatype del = s->data[pos];
    for(i=pos;i<=s->last;i++)
    {
        s->data[i] = s->data[i+1];
    } 
    s->last--;


    return del;
}


int main(int argc, char const *argv[])
{
    seqlist *s = seqlistCreate();
    seqlistlnsert(s,123);
    seqlistlnsert(s,126);
    seqlistlnsert(s,1);
    seqlistlnsert(s,16);
    seqlistlnsert(s,500);
    //seqlistPrint(s);
   // seqlistDelete(s);

    //printf("删除的数据为：%d\n",seqlistDelete(s));
    //seqlistModifyDataByData(s,1,126);
   // seqlistModifyDataByPos(s,3,999);
   //seqlistFindbyPos(s,2);

   //seqlistFindbyData(s,126);
    seqlistPrint(s);
    seqlistlnsertbyPos(s,3,1000);
    seqlistPrint(s);
    printf("%d\n",seqlistDeletetbyPos(s,2));
    seqlistPrint(s);
    free(s);
    return 0;
}

三、分文件编译

//seqlist.c
#include "seqlist.h"
//
seqlist *seqlistCreate()
{
    seqlist*s = (seqlist*) malloc(sizeof(seqlist)); 
    s->last = -1;
    return s;
}
//
void seqlistlnsert(seqlist *s, datatype value)
{
    s->last++;
    s->data[s->last]=value;
    return;
}
//
void seqlistPrint(seqlist*s)
{
    for(int i=0;i<=s->last;i++)
    {
        printf("%d ",s->data[i]);
    }
    printf("\n");
    return ;
}
//
bool seqlistIsFull(seqlist *s)
{
    if(s->last==N-1)
    {
        return true;
    }
    else
    {
        return false;
    }
}
//
bool seqlistIsEmpty(seqlist *s)
{
    if(s->last<0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
//
datatype seqlistDelete(seqlist*s)
{
    //判断是否为空
    if(seqlistIsEmpty(s))
    {
        printf("该文件为空");
        return (datatype)-1;
    }
    datatype del = s -> data[s->last];
    s->last--;
    return del;
}
//
void seqlistModifyDataByData(seqlist *s,datatype oldValue,datatype newValue)
{
    
    int i = 0;
    bool flag = false;
    
    if(seqlistIsEmpty(s))
    {
        printf("该文件为空");
        return ;
    }
    for(i=0;i<=s->last;i++)
    {
        if(s->data[i] == oldValue)
        {
            s->data[i] = newValue;
            flag = true;
        }
    }
if(!flag)
{
    printf("为查找到该数值\n");
}
return;
}
//
void seqlistModifyDataByPos(seqlist *s,int pos,datatype newValue)
{
    
    int i = 0;
    bool flag = false;
    
    if(seqlistIsEmpty(s))
    {
        printf("该文件为空");
        return ;
    }

    if(pos>128||pos<0)
    {
        printf("该输入不合法\n");
        return;
    }


    for(;i<=s->last;i++)
    {
        if(i== pos)
        {
            s->data[i] = newValue;
            flag = true;
        }
    }
if(!flag)
{
    printf("为查找到该数值\n");
}
return;
}

//
datatype seqlistFindbyPos(seqlist *s,int pos)
{
        if(pos>128||pos<0)
    {
        printf("该输入不合法\n");
        return -1;
    }
        return s->data[pos];
}
//
datatype seqlistFindbyData(seqlist *s,int value)
{
    bool flag = false;
    for(int i=0;i<s->last;i++)
    {
        if(s->data[i]==value)
        {
            return i;
            flag = true;
        }
    }
    if (!flag)
    {
        printf("未查找到该下标");
    }
    return (datatype)-1;
}
//
void seqlistlnsertbyPos(seqlist *s,int pos,datatype value)
{
    if(pos<0||pos>s->last+1)
    {
    printf("位置不合理\n");
    return ;
    }
    int i;
    for(i=s->last;i>=pos;i--)
    {
        s->data[i+1] = s->data[i];
    }
    s->data[pos]=value;
    s->last++;
    return;
}
//
datatype seqlistDeletetbyPos(seqlist *s,int pos)
{    
    
    if(pos < 0 || pos > N)
    {
    printf("位置不合理\n");
    return (datatype)-1;
    }
    int i;
    datatype del = s->data[pos];
    for(i=pos;i<=s->last;i++)
    {
        s->data[i] = s->data[i+1];
    } 
    s->last--;
    return del;
}

//seqlist.h
#ifndef __FUN_H__
#define __FUN_H__


#include<stdlib.h>
#include<stdio.h>
#include<stdbool.h>
#define N 128

typedef int datatype;

typedef struct 
{
    datatype data[N];
    int last;
}seqlist;

//函数的声明
seqlist *seqlistCreate();
void seqlistlnsert(seqlist *s, datatype value);
void seqlistPrint(seqlist*s);
datatype seqlistDelete(seqlist*s);
bool seqlistIsEmpty(seqlist *s);
bool seqlistIsFull(seqlist *s);
void seqlistModifyDataByData(seqlist *s,datatype oldValue,datatype newValue);

void seqlistModifyDataByPos(seqlist *s,int pos,datatype newValue);
datatype seqlistFindbyPos(seqlist *s,int pos);

datatype seqlistFindbyData(seqlist *s,int value);
datatype seqlistDeletetbyPos(seqlist *s,int pos);
void seqlistlnsertbyPos(seqlist *s,int pos,datatype value);


#endif

//main.c
#include"seqlist.h"
int main(int argc, char const *argv[])
{
    datatype s = seqlistCreate();
    seqlistlnsert(s,1);
    seqlistlnsert(s,3);
    seqlistlnsert(s,9);
    seqlistlnsert(s,12);
    seqlistlnsert(s,76);
    seqlistlnsert(s,29);
    seqlistPrint(s);
    putchar(10);
    printf("%d\n",seqlistDelete(s));
    seqlistPrint(s);
    printf("*********************************\n");
    seqlistModifyDataByData(s,9,66666);
    seqlistPrint(s);
    seqlistModifyDataByPos(s,1,77777);
    seqlistPrint(s);
    printf("*********************************\n");
    printf("%d\n",seqlistFindbyPos(s,3));
    printf("%d\n",seqlistFindbyData(s,1));
    printf("*********************************\n");
    seqlistlnsertbyPos(s,1,199);
    seqlistPrint(s);
    printf("%d\n",seqlistDeletetbyPos(s,0));
    seqlistPrint(s);
    free(s);
    return 0;
}



//Makefile
OBJ=seqlist

${OBJ}:${OBJ}.o main.o

%*.o:%*.c

.PHONY:clean
clean:
    ${RM} *.o ${OBJ}

四、运行结果

霜华初柒
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【SeqList】线性表代码实现总结
小鱼的专栏
09-08 3348
前言： 本文是在学习了线性表的实现后，理解国嵌数据结构与算法教程后，自己实现的线性表这种简单的数据结构，并且是可复用于任意类型数据
数据结构Day2
CCCHQHQ的博客
03-28 121
其中学生的数据包括：姓名、性别、职业s/S、分数。教师的数据包括：姓名、性别、职业t/T、职务。1>if(条件) 条件是价格的比较 (p+j)->price (p+j+1)->price。在堆区申请5个连续的存储空间，实现车辆信息的输入（品牌，颜色，价格）交换的是*(p+j) 和*(p+j+1) 对应的整体信息。printf("请输入姓名：");printf("请输入性别：");printf("请输入分数：");printf("请输入职务：");例如： (p+j)表示整个车的地址。3>调用函数对价格排序。
数据结构笔记-线性表
Don2100的博客
08-25 637
线性表 线性表结构 线性表定义 typedef int T; // 数据元素的数据类型。 struct SeqList{ T* data; // 数据元素的开始地址。 int len; // 当前长度。 int max; // 线性表的最大长度。 }; 线性表操作 SeqList* SL_Create(int maxlen){// 创建一个顺序表，与SqLst_Free()配对。 S...
线性表的顺序存储与实现
qq_45405490的博客
09-24 200
感觉顺序表hin接近数组，可以当做是数组与一个数字变量组成的结构体。 下面写出几个基本用法 顺序表 typedef struct { datatype data[MAX]; int last; }Seq; 顺序表初始化 书上只给出一个函数 SeqList *init_SeqList() { SeqList *L; L = (SeqList*)malloc...
c语言管理信息系统不用链表,C语言学生信息管理系统 (单链表版)【无图，未调试】...
weixin_42562124的博客
05-18 257
//以顺序表作为存储结构，设计和实现课程成绩管理的完整程序。程序包括如下功能。//1.建立学生成绩表，包含学生的学号、姓名和成绩。//2.可以显示所有学生成绩。//3.可以计算学生的总数。//4.可以按学号和序号查找学生。//5.可以在指定位置插入学生成绩数据。//6.可以删除指定位置的学生数据。//7.可以把学生成绩按从高到低的顺序排序。//作者： yinlinqvan//操作系统：Mac OS...
数据结构day10
weixin_61180910的博客
08-19 101
图
12.20 day1 数据结构
12-20
12.20 day1 数据结构
数据结构 Day 3 主函数
06-12
main.c
数据结构 Day 3 预处理
06-12
head.h
Day4div1数据结构1
08-03
本讲座主要探讨了在数据结构领域中，特别是面向Div1级别的竞赛者，如何有效地处理和利用树的特性来解决问题。 首先，树的分治策略是树形问题解决的一个重要方法。与序列分治类似，将大问题分解为小问题进行解决，但...
数据结构 Day 3 功能函数
06-12
function.c
数据结构（Day1）思维导图
最新发布
03-11
数据结构（Day1）思维导图
【数据结构】Day51
08-03
【数据结构】Day51和Day52的内容主要聚焦在数据结构中的树，特别是二叉树和表达式树。在这一部分的学习中，我们将深入理解这两种重要的数据结构及其应用。 4.2 叉树（Binary Trees） 二叉树是一种特殊类型的树，...
【数据结构】Day71
08-03
【数据结构】Day71和Day72的内容主要讨论了AVL树的双旋转操作，这是在平衡二叉搜索树（Balanced Binary Search Tree）中一个重要的调整策略，用于维护树的高度平衡。AVL树是一种特殊的二叉搜索树，其特点是每个节点...
【数据结构】Day31
08-03
在数据结构的学习中，表（List）是一种基础且重要的数据组织形式，它能够有效地存储和管理数据。在Day31的课程中，我们关注了表的抽象数据类型（ADT）及其常用操作。表ADT通常用于处理一系列元素，其中每个元素都有...
【数据结构】Day61
08-03
【数据结构】Day61-63探讨的主题是二叉查找树（Binary Search Tree, BST）及其特殊类型AVL树的插入操作与平衡调整。二叉查找树是一种自平衡的二叉搜索树，其特点在于每个节点的关键字值遵循左小右大的规则，即对于...
【数据结构】Day21
08-03
在计算机科学中，数据结构和算法的分析是至关重要的，因为它们直接影响到程序的效率和性能。本节主要讨论了如何计算运行时间，特别是在数据结构相关的算法中。这里提出了四个一般法则来帮助我们理解并估算代码执行的...
【数据结构】Day11
08-03
1. 如果存在正常数c和 2. 如果存在正常数c和 1. 如果我们传统的不等式来计算增率，那么第个定义是说T(N)的增率于等于 2. 第个定义 3. 第三个定义
数据结构C语言day
08-27
- *1* *2* *3* [数据结构-C语言代码 day 5-多项式加法](https://blog.csdn.net/yydslty/article/details/124612624)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值