C语言初阶数据结构（一）动态顺序表

已于 2023-03-31 19:31:16 修改
阅读量619 收藏 3
点赞数
文章标签： c语言
于 2022-04-18 15:21:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54469537/article/details/124227957
版权

其实前面文章的动态通讯录本质其实也是动态顺序表

该动态链表的主要功能实现如下(完整代码在最后)：

1.初始化化顺序表

void SeqListInit(SL* ps)
{
    ps->a = NULL;
    ps->size = 0;
    ps->capacity = 0;
}

这里使用typedf重新定义了类型(int) 后续如果需要插入其他类型时，只需改动int即可，结构体表里顺序表中包含三个元素：1.数据a。 2.统计有效数据个数的size。 3.顺序表的容量capacity。

typedef int SQDataType;
typedef struct SeqList
{
    SQDataType* a;
    int size;//有效数据的个数
    int capacity;//顺序表的容量
}SL;

2.头插法

每次插入数据前需要先检查容量，所以定义一个检查容量的函数Check_Capacity，满了就进行增容

void Check_Capacity(SL* ps)
{
    if (ps->size == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        SQDataType* pf = (SQDataType*)realloc(ps->a,sizeof(SQDataType) * newcapacity);
        if (pf == NULL)
        {
            perror("");
            return;
        }
        else
        {
            ps->a = pf;
        }
        ps->capacity = newcapacity;
    }
    
}

头插法功能实现思路：从最后一个元素开始，依次向后移动，直到第一个结点值也被移动后，直接将x赋值给a[0]即可。

void SeqListPushFront(SL* ps, SQDataType x)
{
    Check_Capacity(ps);
    int end = ps->size - 1;
    while (end>=0)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[0] = x;
    ps->size++;
}

3.尾插法：先判断容量，再进行插入，直接插入到size位置即可

void SeqListPushBack(SL* ps, SQDataType x)
{
    Check_Capacity(ps);
    ps->a[ps->size] = x;
    ps->size++;
}

4.头删数据：从第二个结点开始，依次向前覆盖，最后size-1即可。

void SeqListPopFront(SL* ps)
{
    assert(ps->size > 0);
    int start = 0;
    while (start <ps->size)
    {
        ps->a[start] = ps->a[start + 1];
        start++;
    }
    ps->size--;
}

5.尾删数据：直接将size--即可。

void SeqListPopBack(SL* ps)
{
    assert(ps->size > 0);
    ps->size--;
}

6.查找数据：对顺序表进行遍历，如果找到数据就返回其下标，如果没找到就返回-1

int  SeqListSearch(SL* ps, SQDataType x)
{
    int i = 0;
    for (i = 0; i<ps->size; i++)
    {
        if (ps->a[i] == x)
        {
            return i;
        }
    }
    return -1;
}

7.随机插入：一般与查找数据功能连用，如果查找的数据存在，且返回的坐标用pos接收，直接将pos后面的数据从后向前依次向后移动一位，然后将要插入的数据直接保存再pos位置即可。

void SeqListInsert(SL* ps, int pos, SQDataType x)
{
    Check_Capacity(ps);
    assert(pos < ps->size);
    int end = ps->size - 1;
    while (end >= pos)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[pos] = x;
    ps->size++;
}

8.随机删除：与查找数据功能连用，用pos接收查找到的数据的坐标，然后从pos后面的第一个结点开始依次向前覆盖即可。

void SeqListErase(SL* ps, int pos)
{
    assert(pos < ps->size);
    while (pos<ps->size)
    {
        ps->a[pos] = ps->a[pos + 1];
        pos++;
    }
    ps->size--;
}

9.修改数据：查找数据后用pos接收返回坐标，直接将要修改的数据赋值给pos即可（覆盖pos原来的数据）

void SeqListModify(SL* ps,int pos, SQDataType x)
{
    assert(pos<ps->size);
    ps->a[pos] = x;
}

10.打印数据：依次遍历打印顺序表

void SeqListPrint(SL* ps)
{
    int i = 0;
    for (i = 0; i < ps->size; i++)
    {
        printf("%d ", ps->a[i]);
    }
    printf("\n");
}

11.销毁顺序表

void DistroySeqList(SL* ps)
{
    free(ps->a);
    ps->a = NULL;
}

注：assert的使用以及每次size的变化需要注意

补充一下#pragma once 、#if   、#ifdef   、#ifndef 

1.#pragma once  防止被重定义   等价于 

2.#ifndef  

       中间是定义

#endif

3.#if  常量表达式

语句

#endif     如果#if后面的常量表达式为真，则执行下列语句，如果为加不执行

4.#ifdef    +宏定义

语句

#endif       如果#ifdef后面定义过就执行下面的语句，没定义过就不执行

其实用随机插入以及随机删除就可以实现头插尾插，头删尾删等功能。比如头插时:

void SeqListPushFront(SL*ps,SQLTDatatype x)
{
    SeqListInsert(ps,a[0],x);
}

UU们有不会的地方可以私信或者评论，1天内会回复嗷~

各位看官老爷们~如有帮助可以留下你的赞嘛~

头文件:SeqList

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SQDataType;
typedef struct SeqList
{
    SQDataType* a;
    int size;//有效数据的个数
    int capacity;//顺序表的容量
}SL;

//顺序表的初始化 打印 销毁
void SeqListInit(SL* ps);
void SeqListPrint(SL* ps);
void DistroySeqList(SL* ps);

//顺序表的增删改查等功能
//尾插  头插  尾删  头删 随机插入 随即删除  查找  删除
void SeqListPushBack(SL* ps,SQDataType x);
void SeqListPushFront(SL* ps, SQDataType x);
void SeqListPopBack(SL* ps);
void SeqListPopFront(SL* ps);
void SeqListInsert(SL* ps,int pos, SQDataType x);
void SeqListErase(SL* ps,int pos);
int  SeqListSearch(SL* ps, SQDataType x);
void SeqListModify(SL* ps, int pos, SQDataType x);
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#pragma once
typedef int SQDataType;
typedef struct SeqList
{
    SQDataType* a;
    int size;//有效数据的个数
    int capacity;//顺序表的容量
}SL;

//顺序表的初始化 打印 销毁
void SeqListInit(SL* ps);
void SeqListPrint(SL* ps);
void DistroySeqList(SL* ps);

//顺序表的增删改查等功能
//尾插  头插  尾删  头删 随机插入 随即删除  查找  删除
void SeqListPushBack(SL* ps,SQDataType x);
void SeqListPushFront(SL* ps, SQDataType x);
void SeqListPopBack(SL* ps);
void SeqListPopFront(SL* ps);
void SeqListInsert(SL* ps,int pos, SQDataType x);
void SeqListErase(SL* ps,int pos);
int  SeqListSearch(SL* ps, SQDataType x);
void SeqListModify(SL* ps, int pos, SQDataType x);

源文件SeqList.c（函数实现）

#include"SeqList.h"
//初始化顺序表
void SeqListInit(SL* ps)
{
    ps->a = NULL;
    ps->size = 0;
    ps->capacity = 0;
}

//打印顺序表
void SeqListPrint(SL* ps)
{
    int i = 0;
    for (i = 0; i < ps->size; i++)
    {
        printf("%d ", ps->a[i]);
    }
    printf("\n");
}
//销毁顺序表
void DistroySeqList(SL* ps)
{
    free(ps->a);
    ps->a = NULL;
}

//增容
void Check_Capacity(SL* ps)
{
    if (ps->size == ps->capacity)
    {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        SQDataType* pf = (SQDataType*)realloc(ps->a,sizeof(SQDataType) * newcapacity);
        if (pf == NULL)
        {
            perror("");
            return;
        }
        else
        {
            ps->a = pf;
        }
        ps->capacity = newcapacity;
    }
    
}
//尾插法
void SeqListPushBack(SL* ps, SQDataType x)
{
    Check_Capacity(ps);
    ps->a[ps->size] = x;
    ps->size++;
}

//头插法
void SeqListPushFront(SL* ps, SQDataType x)
{
    Check_Capacity(ps);
    int end = ps->size - 1;
    while (end>=0)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[0] = x;
    ps->size++;
}

//尾删
void SeqListPopBack(SL* ps)
{
    assert(ps->size > 0);
    ps->size--;
}

//头删
void SeqListPopFront(SL* ps)
{
    assert(ps->size > 0);
    int start = 0;
    while (start <ps->size)
    {
        ps->a[start] = ps->a[start + 1];
        start++;
    }
    ps->size--;
}

//随机插入
void SeqListInsert(SL* ps, int pos, SQDataType x)
{
    Check_Capacity(ps);
    assert(pos < ps->size);
    int end = ps->size - 1;
    while (end >= pos)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[pos] = x;
    ps->size++;
}

//随机删除
void SeqListErase(SL* ps, int pos)
{
    assert(pos < ps->size);
    while (pos<ps->size)
    {
        ps->a[pos] = ps->a[pos + 1];
        pos++;
    }
    ps->size--;
}

//查找
int  SeqListSearch(SL* ps, SQDataType x)
{
    int i = 0;
    for (i = 0; i<ps->size; i++)
    {
        if (ps->a[i] == x)
        {
            return i;
        }
    }
    return -1;
}

//修改
void SeqListModify(SL* ps,int pos, SQDataType x)
{
    assert(pos<ps->size);
    ps->a[pos] = x;
}

源文件text.c（功能测试）


#include"SeqList.h"
void menu()
{
    printf("*************************************\n");
    printf("**1.尾插数据             2.头插数据 \n");
    printf("**3.删除尾数据           4.删除首数据\n");
    printf("**5.随机插入数据         6.随机删除数据\n");
    printf("**7.查找数据             8.修改数据**\n");
    printf("**9.打印数据             0.退出程序\n");
    printf("*************************************\n");
    printf("请输入你的选择:>\n");
}
int main()
{
    SL s;
    int x = 0;
    int input = 0;
    int pos = 0;
    SeqListInit(&s);
    do
    {
        menu();
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            printf("请输入你要插入的数据，以-1结束\n");
            do
            {
                scanf("%d", &x);
                if (x != -1)
                {
                    SeqListPushBack(&s, x);
                }
            } while (x != -1);
            break;
        case 2:
            printf("请输入你要插入的数据，以-1结束\n");
            do
            {
                scanf("%d", &x);
                if (x != -1)
                {
                    SeqListPushFront(&s, x);
                }
            } while (x != -1);
            break;
        case 3:
            SeqListPopBack(&s);
            break;
        case 4:
            SeqListPopFront(&s);
            break;
        case 5:
            printf("请输入你要插入的数据\n");
            do
            {
                scanf("%d", &x);
                if (x != -1)
                {
                    printf("请输入你要插入的下标,以-1结束：\n");
                    scanf("%d", &pos);
                    SeqListInsert(&s,pos,x);
                }
            }while (x != -1);
            break;
        case 6:
            printf("请输入你要删除的下标，以-1结束：\n");
            do
            {
                scanf("%d", &x);
                if (x != -1)
                {
                    SeqListErase(&s, x);
                }
            } while (x != -1);
            break;
        case 7:
            printf("请输入你要查找的数据，以-1结束：\n");
            do
            {
                scanf("%d", &x);
                if (x != -1)
                {
                    int ret=SeqListSearch(&s, x);
                    if (ret == -1)
                    {
                        printf("该数字不存在\n");
                    }
                    else
                    {
                        printf("该数字存在，且下标为:%d", ret);
                    }
                }
            } while (x != -1);
            break;
        case 8:
            printf("请输入你要修改的数据\n");
            do
            {
                scanf("%d", &x);
                if (x != -1)
                {
                    printf("请输入你要修改的下标,以-1结束：\n");
                    scanf("%d", &pos);
                    SeqListModify(&s, pos, x);
                }
            } while (x != -1);
            break;
        case 9:
            SeqListPrint(&s);
            break;
        case 0:
            printf("退出程序!\n");
            break;
        default:
            printf("输入错误，请重新输入!\n");
            break;
        }
    } while (input);
    DistroySeqList(&s);
    return 0;
}
程序猿小马
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构】之 动态顺序表（C语言）（含完整代码）
weixin_53936115的博客
12-18 1203
顺序表概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下用数组存储。在数组上完成数据的增删查改。 代码解析： 1.准备工作 1.首先对一些头文件的引用和创建一个结构体，结构体包含一个数组，size表示该数组目前有多少个元素，capacity表示目前数组能存多少个元素。例如： #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include&l...
【数据结构初阶】顺序表
m0_60624580的博客
10-25 2251
前言前言线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表的数据在存储的时候是成一条线性相互紧邻存放的。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，是连续的一条直线。但是在物理结构上（内存）并不一定是连续的。线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是在物理上是线性连续的，链表是不连续的。
动态顺序表（C语言实现）
cw412524的博客
11-13 780
数据结构动态顺序表（C语言实现），干货满满！
C语言实现动态顺序表
MJ813的专栏
09-06 416
/*********************************************************************************** xxx.h: Copyright (c) , Inc.(2016), All rights reserved. Purpose: C语言实现动态顺序表 Author: MaJing Reviser: yyy Cre
【数据结构】C语言实现动态顺序表
weixin_43550839的博客
07-19 337
大概之后的数据结构博客就都使用多文件操作了。 一.顺序表功能实现以及数据定义 #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #include<stdio.h> #include<stdlib.h> #include<string.h> #include<Windows.h> #define N 100 typede...
C语言实现数据结构算法初阶算法
最新发布
06-15
1. **顺序表**：顺序表是一种基本的数据结构，它的元素在内存中是连续存储的。C语言中，我们可以使用数组来实现顺序表。在实际应用中，插入和删除操作可能涉及大量的元素移动，效率较低，但在特定场景如全量数据处理...
C语言初阶-(单向链表)
03-08
适用于数据结构初学者使用 线性表的单链表存储结构，整个链表的存取必须从头指针开始进行，头指针指示链表中第一个结点 (第一个数据元素的存储映像，也称首元结点)的存储位置。同时，由于最后一个数据元素没有 直接...
C语言-数据结构-线性表
xufang461010923的专栏
05-07 1075
最近在学习自考课程中的《数据结构》，课程代码为02331，使用的教程是2012年版的（主编：苏仕华）。一开始学习时，有些困难，因为我没学习过C，教材中的算法虽然能理解，但不能完全吃透。 所以，又转去恶补C的基础知识，如：数组，指针，结构体，宏定义，typedef…等等。 现在回来了，再看这些算法容易多了，自己将“顺序表”的基本运算补充实现了，贴上来，给有相同经历的考生一点点帮助。 1. 线性表的基...
[数据结构笔记]二叉树初阶
niokia0v0的博客
01-28 1907
null
动态通讯录（用顺序表实现）
晶凌玄夜的博客
04-13 1668
利用顺序表实现动态通讯录，实质就是一个动态顺序表，基本代码和顺序表大致 相同，涉及到结构体的创建，初始化，插入，删除，查找等功能。 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<string.h> //定...
C语言实现顺序表（动态）
2301_76269963的博客
03-06 1139
C语言实现顺序表（动态）
学习记录：第二章 线性表的顺序存储_顺序表_初始化（静态分配以及动态分配）（代码、图示、C++）
weixin_45790081的博客
05-01 1201
本文给出了顺序表的静态分配和动态分配相关代码，以及动态分配的图示助于理解，代码实现使用的是C语言在线工具。无概念解释，初学者建议配合书本食用。
数据结构初阶 ---- 顺序表的(C语言)实现
m0_71722065的博客
08-18 1517
数据结构初阶 ---- 顺序表的动态实现
简单动态顺序表
小康的博客
12-03 463
简单的动态顺序表需实现的接口函数有增删改查； 一个简单的顺序表就是数组 动态的顺序表较静态顺序表而言，更加的节省空间，不够加扩容，不会造成过多的浪费。 最后需释放扩容的空间 删除又包含头删，尾删，任意位置删除。 增加又包含头插，尾插，任意位置插入。
我们天天在使用的通讯录原来是这样实现的呀——C语言实现简单静态通讯录和动态通讯录（基于顺序表）
未见花闻的博客
09-25 997
⭐️前面的话⭐️ 大家好！在生活中大家一定离不开通讯录或类似功能的联系人列表，比如QQ好友列表，微信朋友列表。在这篇文章中我会详细介绍如何使用C语言来搭建一个简单的通讯录，包括静态通讯录和动态通讯录。
数据结构—动态顺序表
HysteriaD的博客
10-12 889
动态顺序表？可能没有你想象的那么难。
c语言_struct SeqList 与 typedef struct用法
binnnnnnn_的博客
03-26 2325
struct SeqList 的用法 struct SeqList { ElemType data[SEQ_INIT_SIZE];//数据元素个数 int cursize;//空间 }; int main() { struct SeqList myseq; struct SeqList *pseq; struct SeqList seqar[10]; return 0; } typedef struct 的用法 typedef struct { ElemType data[SEQ_I.
如何对顺序表进行创建和赋值，调用？c语言 数据结构
热门推荐
qq_42018605的博客
10-13 1万+
先要对顺序表的存储方式有个了解，它与数组存储的不同之处在于，这个的储存是连续的，并且是动态存储的。 1、首先对先对SqList进行预定义   2、省略了其他的预定义。大致的创立和赋值代码如下，先是声明个顺序表a,然后对其进行分配空间，用malloc函数，   for循环是对顺序表里的数据经行赋值，强调一点，对顺序表的数据元素的表示方式为：a.elem[i]，这个与数组的下标表示类似 ...
C语言实现数据结构基础：顺序表篇
"本资源是一系列关于数据结构在C语言中的实现教程，主要关注线性表这一基础数据结构。首先，作者引入了`struct List`，它包含了`elemType`类型的指针`list`，表示线性表中的元素，以及两个整型变量`size`和`maxSize`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值