数据结构-＞线性表

最新推荐文章于 2024-09-02 18:00:58 发布
最新推荐文章于 2024-09-02 18:00:58 发布
阅读量89 收藏
点赞数
文章标签： 数据结构 线性回归
原文链接：https://blog.csdn.net/minfanphd/article/details/117277239
版权

初始化线性表模块

SequentialListPtr sequentialListInit(int paraData[], int paraLength)
{
    SequentialListPtr resultPtr = (SequentialListPtr)malloc(sizeof(struct SequentialList));
    for (int i = 0; i < paraLength; i++)
    {
        resultPtr->data[i] = paraData[i];
    }
    resultPtr->actualLength = paraLength;

    return resultPtr;
}

展示线性表模块

void outputList(SequentialListPtr paraList)
{
    for (int i = 0; i < paraList->actualLength; i++) {
        printf("%d ", paraList->data[i]);
    }
    printf("\r\n");
}

void outputMemory(SequentialListPtr paraListPtr)
{
    printf("结构体的地址是: %ld\r\n", paraListPtr);
    printf("真实长度的地址是: %ld\r\n", &paraListPtr->actualLength);
    printf("数据的地址是: %ld\r\n", &paraListPtr->data);
    printf("真实数据的地址是: %ld\r\n", &paraListPtr->data[0]);
    printf("第二个数据的地址是: %ld\r\n", &paraListPtr->data[1]);
}

插入函数

void sequentialListInsert(SequentialListPtr paraListPtr, int paraPosition, int paraValue) 
{
    if (paraListPtr->actualLength >= LIST_MAX_LENGTH)
    {
        printf("不能插入元素: 表格已满。\r\n");
        return;
    }

    if (paraPosition < 0)
    {
        printf("不能插入元素: 不支持的类型。");
        return;
    }
    if (paraPosition > paraListPtr->actualLength)
    {
        printf("不能插入元素: %d 的位置比表的最大位置 %d 还要大。\r\n", paraPosition, paraListPtr->actualLength);
        return;
    }

    for (int i = paraListPtr->actualLength; i > paraPosition; i--) 
    {
        paraListPtr->data[i] = paraListPtr->data[i - 1];
    }
    paraListPtr->data[paraPosition] = paraValue;
    paraListPtr->actualLength++;
}

删减函数

int sequentialListDelete(SequentialListPtr paraListPtr, int paraPosition)
{
    if (paraPosition < 0)
    {
        printf("非法位置输入: %d.\r\n", paraPosition);
        return -1;
    }
    if (paraPosition >= paraListPtr->actualLength)
    {
        printf("无法删除该元素: 需要删除位置 %d 的元素比表最后一个元素 %d 的位置要大。\r\n", paraPosition, paraListPtr->actualLength);
        return -1;
    }
    int resultValue = paraListPtr->data[paraPosition];
    for (int i = paraPosition; i < paraListPtr->actualLength; i++)
    {
        paraListPtr->data[i] = paraListPtr->data[i + 1];
    }
    paraListPtr->actualLength--;
    return resultValue;
}

插入函数测试

void sequentialInsertTest()
{
    int i;
    int tempArray[6] = { 4, 6, 1, 8, 5, 9 };

    printf("---- 开始线性表插入测试 ----\r\n");

    SequentialListPtr tempList = sequentialListInit(tempArray, 6);
    printf("初始化后,线性表为: ");
    outputList(tempList);

    printf("现在在第一个位置前插入元素8, 插入后线性表为: ");
    sequentialListInsert(tempList, 0, 8);
    outputList(tempList);

    printf("现在在最后一个位置后插入元素9, 插入后线性表为: ");
    sequentialListInsert(tempList, 7, 9);
    outputList(tempList);

    printf("现在插入超过实际长度位置的元素10 \r\n");
    sequentialListInsert(tempList, 9, 10);
    printf("插入后线性表为:");
    outputList(tempList);

    for (i = 0; i < 6; i++) 
    {
        printf("插入 %d 中.\r\n", (i + 10));
        sequentialListInsert(tempList, 0, (i + 10));
        outputList(tempList);
    }

    printf("---- 线性表插入测试结束 ----\r\n");
}

删减函数测试
 

void sequentialDeleteTest() 
{
    int tempArray[6] = { 4, 6, 1, 8, 5, 9 };

    printf("---- 开始线性表删除测试 ----\r\n");

    SequentialListPtr tempList = sequentialListInit(tempArray, 6);
    printf("初始化后, 线性表为: ");
    outputList(tempList);

    printf("删除第一个位置的元素后, 线性表为: ");
    sequentialListDelete(tempList, 0);
    outputList(tempList);

    printf("删除最后一个位置的元素后, 线性表为: ");
    sequentialListDelete(tempList, 5);
    outputList(tempList);

    printf("删除第二个位置的元素后, 线性表为: ");
    sequentialListDelete(tempList, 1);
    outputList(tempList);

    printf("删除倒数第二个个位置的元素后, 线性表为: ");
    sequentialListDelete(tempList, 4);
    outputList(tempList);

    printf("删除第负六个位置（非法位置）的元素后, 线性表为: ");
    sequentialListDelete(tempList, -6);
    outputList(tempList);

    printf("---- 线性表删除测试结束 ----\r\n");

    outputMemory(tempList);
}

辅助函数（定位，寻找，清除）

int getElement(SequentialListPtr paraListPtr, int paraPosition) 
{
    if (paraPosition < 0) 
    {
        printf("非法位置输入: %d.\r\n", paraPosition);
        return -1;
    }
    if (paraPosition >= paraListPtr->actualLength)
    {
        printf("无法删除该元素: 位置 %d 的元素比表实际长度 %d 还要大。\r\n", paraPosition, paraListPtr->actualLength);
        return -1;
    }
    return paraListPtr->data[paraPosition];
}
void clearList(SequentialListPtr paraListPtr)
{
    paraListPtr->actualLength = 0;
    free;
}

定位模块：

可以通过排序函数后利用二分查找完成，之后改完bug补。先浅放个稿子吧。

int comp(const void* a, const void* b)
{
    return *(int*)a - *(int*)b;
}
/*int locateElement(SequentialListPtr paraListPtr, int paraValue)
{
    
    qsort(paraListPtr->data, paraListPtr->actualLength, sizeof(int), comp);
    for (int i = 0; i < paraListPtr->actualLength; i++)
    {
        printf("%d ", paraListPtr->data[i]);
    }
}*/

运行展示：

完整代码展示：

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

#define LIST_MAX_LENGTH 10

int comp(const void* a, const void* b)
{
    return *(int*)a - *(int*)b;
}

typedef struct SequentialList 
{
    int actualLength;
    int data[LIST_MAX_LENGTH];
} *SequentialListPtr;

void outputList(SequentialListPtr paraList)
{
    for (int i = 0; i < paraList->actualLength; i++) {
        printf("%d ", paraList->data[i]);
    }
    printf("\r\n");
}

void outputMemory(SequentialListPtr paraListPtr)
{
    printf("结构体的地址是: %ld\r\n", paraListPtr);
    printf("真实长度的地址是: %ld\r\n", &paraListPtr->actualLength);
    printf("数据的地址是: %ld\r\n", &paraListPtr->data);
    printf("真实数据的地址是: %ld\r\n", &paraListPtr->data[0]);
    printf("第二个数据的地址是: %ld\r\n", &paraListPtr->data[1]);
}
SequentialListPtr sequentialListInit(int paraData[], int paraLength)
{
    SequentialListPtr resultPtr = (SequentialListPtr)malloc(sizeof(struct SequentialList));
    for (int i = 0; i < paraLength; i++)
    {
        resultPtr->data[i] = paraData[i];
    }
    resultPtr->actualLength = paraLength;

    return resultPtr;
}
void sequentialListInsert(SequentialListPtr paraListPtr, int paraPosition, int paraValue) 
{
    if (paraListPtr->actualLength >= LIST_MAX_LENGTH)
    {
        printf("不能插入元素: 表格已满。\r\n");
        return;
    }

    if (paraPosition < 0)
    {
        printf("不能插入元素: 不支持的类型。");
        return;
    }
    if (paraPosition > paraListPtr->actualLength)
    {
        printf("不能插入元素: %d 的位置比表的最大位置 %d 还要大。\r\n", paraPosition, paraListPtr->actualLength);
        return;
    }

    for (int i = paraListPtr->actualLength; i > paraPosition; i--) 
    {
        paraListPtr->data[i] = paraListPtr->data[i - 1];
    }
    paraListPtr->data[paraPosition] = paraValue;
    paraListPtr->actualLength++;
}

void sequentialInsertTest()
{
    int i;
    int tempArray[6] = { 4, 6, 1, 8, 5, 9 };

    printf("---- 开始线性表插入测试 ----\r\n");

    SequentialListPtr tempList = sequentialListInit(tempArray, 6);
    printf("初始化后,线性表为: ");
    outputList(tempList);

    printf("现在在第一个位置前插入元素8, 插入后线性表为: ");
    sequentialListInsert(tempList, 0, 8);
    outputList(tempList);

    printf("现在在最后一个位置后插入元素9, 插入后线性表为: ");
    sequentialListInsert(tempList, 7, 9);
    outputList(tempList);

    printf("现在插入超过实际长度位置的元素10 \r\n");
    sequentialListInsert(tempList, 9, 10);
    printf("插入后线性表为:");
    outputList(tempList);

    for (i = 0; i < 6; i++) 
    {
        printf("插入 %d 中.\r\n", (i + 10));
        sequentialListInsert(tempList, 0, (i + 10));
        outputList(tempList);
    }

    printf("---- 线性表插入测试结束 ----\r\n");
}

int sequentialListDelete(SequentialListPtr paraListPtr, int paraPosition)
{
    if (paraPosition < 0)
    {
        printf("非法位置输入: %d.\r\n", paraPosition);
        return -1;
    }
    if (paraPosition >= paraListPtr->actualLength)
    {
        printf("无法删除该元素: 需要删除位置 %d 的元素比表最后一个元素 %d 的位置要大。\r\n", paraPosition, paraListPtr->actualLength);
        return -1;
    }
    int resultValue = paraListPtr->data[paraPosition];
    for (int i = paraPosition; i < paraListPtr->actualLength; i++)
    {
        paraListPtr->data[i] = paraListPtr->data[i + 1];
    }
    paraListPtr->actualLength--;
    return resultValue;
}
void sequentialDeleteTest() 
{
    int tempArray[6] = { 4, 6, 1, 8, 5, 9 };

    printf("---- 开始线性表删除测试 ----\r\n");

    SequentialListPtr tempList = sequentialListInit(tempArray, 6);
    printf("初始化后, 线性表为: ");
    outputList(tempList);

    printf("删除第一个位置的元素后, 线性表为: ");
    sequentialListDelete(tempList, 0);
    outputList(tempList);

    printf("删除最后一个位置的元素后, 线性表为: ");
    sequentialListDelete(tempList, 5);
    outputList(tempList);

    printf("删除第二个位置的元素后, 线性表为: ");
    sequentialListDelete(tempList, 1);
    outputList(tempList);

    printf("删除倒数第二个个位置的元素后, 线性表为: ");
    sequentialListDelete(tempList, 4);
    outputList(tempList);

    printf("删除第负六个位置（非法位置）的元素后, 线性表为: ");
    sequentialListDelete(tempList, -6);
    outputList(tempList);

    printf("---- 线性表删除测试结束 ----\r\n");

    outputMemory(tempList);
}
int locateElement(SequentialListPtr paraListPtr, int paraValue)
{
    for (int i = 0; i < paraListPtr->actualLength; i++)
    {
        if (paraListPtr->data[i] == paraValue)
        {
            return i;
        }
    }

    return -1;
}

/*int locateElement(SequentialListPtr paraListPtr, int paraValue)
{
    
    qsort(paraListPtr->data, paraListPtr->actualLength, sizeof(int), comp);
    for (int i = 0; i < paraListPtr->actualLength; i++)
    {
        printf("%d ", paraListPtr->data[i]);
    }
}*/

int getElement(SequentialListPtr paraListPtr, int paraPosition) 
{
    if (paraPosition < 0) 
    {
        printf("非法位置输入: %d.\r\n", paraPosition);
        return -1;
    }
    if (paraPosition >= paraListPtr->actualLength)
    {
        printf("无法删除该元素: 位置 %d 的元素比表实际长度 %d 还要大。\r\n", paraPosition, paraListPtr->actualLength);
        return -1;
    }
    return paraListPtr->data[paraPosition];
}
void clearList(SequentialListPtr paraListPtr)
{
    paraListPtr->actualLength = 0;
    free;
}
void main() 
{
    sequentialInsertTest();
    sequentialDeleteTest();
}

 

什么都不会的小C
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线性表--顺序表及链表
bujuan827的专栏
08-15 1551
本文包含以下内容： 一、线性表的介绍以及抽象ADT 二、顺序表及顺序表的实现 三、链表及链表的实现 四、顺序表和链表的比较 五、总结 参考书目：《数据结构与算法分析》【美】Clifford A.Shaffer著 一、线性表的介绍以及抽象ADT 1.什么是线性表？ 关键字：线性、有序、有限。 所谓线性，是一个元素接着一个元素，就像一条线那样排放。而不是离散散乱的，
线性表
、Edgar的博客
09-08 1136
1.线性表的定义 线性结构是n(n≥0)个结点的有穷序列(a0, a1, ..., an-1)。a0被称为起始结点， an-1被称为终端结点，i称为ai的序号或位置。对任意一对相邻结点ai和ai+1(0≤i≤n-2)，ai被称为ai+1的直接前驱，ai+1称为ai的直接后继。其实结点只有直接后继，终端结点只有直接前驱。线性结构中的每个结点代表一个数据元素。在不同的实际问题中，结点代表的数据元素是...
C_线性表(ADT)-顺序表的表示和实现
Cynical丶Gary_博客
07-14 7203
基本操作的实现：单个顺序表的构造，判空，插入，删除，排序，清空，销毁，返回前驱以及后继 线性表基本操作： 1.InitList(&L) /*操作结果：构造一个空的线性表*/ 2.DestroyList(&L) /*初始条件：线性表L已存在*/ /*操作结果：销毁线性表L*/ 3.ClearList(&L) /*初始条件：线性表L已存在*/ /*操作结果：将L重置为空表*/ 4.
数据结构-线性表-1顺序线性表
weixin_49895102的博客
03-21 1150
#include<stdio.h> /*线性表的特点：同一性、有穷性、有序性*/ //线性表的抽象数据类型：数据元素、结构关系、基本操作 //基本操作：InitList/ListLength/GetData/InsList/DelList/Locate/DestroyList/ClearList/EmptyList //增删改查+基本属性 #define MAXSIZE 100 #define ElemType char //线性表的线性存储结构（如果是空表last值是-1) type.
数据结构--线性表顺序存储
Seinlvan的博客
09-29 689
1 线性表定义 由零个或多个数据元素组成的有限序列。 数学定义 若将线性表记为（a1,…,ai-1,ai,ai+1,…an）,则表中ai-1领先于ai,ai领先于ai+1,称ai-1是ai的直接前驱元素,ai+1是ai的直接后继元素。 所以线性表元素的个数n(n>=0)定义为线性表的长度，当n=0时，称为空表。 2 抽象数据类型 ADT 一个数学模型及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。 ADT 抽象数据类型名 Data 数据元素
数据结构--线性表问题总结
qq_74896248的博客
09-17 521
for循环语句中的逻辑错误，在这个逻辑中其实只循环了一次，第一次如果判断成功，不报错，而只要不是第一次能判断成功，那么都回到else语句中，直接return -1。问题：在find函数中，for循环中不可以写作int i=0；应该在for循环外部定义再在for循环赋值。而当查找为1时，即第一次if内语句未实现，而else语句实现，就会报错。一种可能，vs2010支持不是c99，无法在for中定义。
数据结构 --- 线性表
weixin_47833373的博客
04-21 1042
线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。
数据结构-----线性表
m0_64904378的博客
01-14 1464
线性表是具有相同数据类型的数据元素的一个有限序列。该序列所含的数据元素的个数是线性表的长度，一般使用 n 来表示。当 n=0 的时候，该线性表为空表。需要注意的是，线性表中的元素位置是使用下标来标注，生活中说的元素第 i 个元素，一般在线性表的下标中的 i-1 的位置，线性表中的元素下标是从 0 开始，而我们所说的数据位序是从1开始。从线性表的定义可以得到以下特性：1.有穷性：一个线性表中的元素个数是有限的。2.一致性： 一个线性表中的元素的性质相同。（即元素中的数据类型相同）3.序列性。
数据结构--线性表--思维导图.pdf
08-29
数据结构--线性表--思维导图.pdf 该资源主要讲解了数据结构中的线性表，包括线性表的定义、基本操作、顺序表和链表的存储方式、操作效率比较等。 线性表的定义： 线性表是一种逻辑结构，表示元素之间一对一相邻的...
数据结构--线性表.cpp
03-08
数据结构--线性表.cpp
《数据结构》第二章算法设计题--线性表 定义线性表节点的结构.pdf
04-18
数据结构算法设计题--线性表节点结构设计 本文主要讲解了数据结构中线性表的节点结构设计，涉及到链表的合并、插入、删除等操作。下面是对该知识点的详细讲解： 1. 链表的节点结构设计 链表是一种常见的数据结构...
数据结构学习--线性表及其应用--顺序表
06-25
线性表是数据结构的基础，它是由n（n>=0）个相同类型元素构成的有限序列。线性表按照存储方式可以分为顺序表和链表。顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种...
数据结构--线性表PPT学习教案.pptx
10-05
线性表是数据结构的基础，它是一个包含n个相同类型数据元素的有限序列，通常表示为(a1, a2, a3, ..., an)。在实际应用中，线性表非常常见，比如数学中的数列、英文字母表或者电话号码簿等。线性表的特征在于每个元素...
【数据结构-二维前缀和】【列维护优化】力扣3212. 统计 X 和 Y 频数相等的子矩阵数量
sjsjs11的博客
09-02 403
我觉得列优化的核心思路是，由于在计算前缀和中，之前的列字符数都会被用到，也就是说在遍历不同行的时候，列的字符数是在前一行的列的字符数加上目前行的字符数得来的。所以在每一行遍历的时候，置s1和s2为0，然后逐渐累加，可以看作这个前缀和矩阵，随着列的遍历，一条条竖下来的元素铺成一个前缀和矩阵，最后进行统计X和Y相等的频数。输入： grid = [[“X”,“Y”,“.”],[“Y”,“.”,“.”]]输入： grid = [[“X”,“X”],[“X”,“Y”]]‘X’ 和 ‘Y’ 的频数相等。
数据结构-顺序表-详解
2401_86587256的博客
08-29 1266
数据结构初阶部分，顺序表的详解。
9/2 pandas数据结构介绍
最新发布
m0_58285219的博客
09-02 613
1.对于Series ：当对象相加时，如果存在不同的索引对，则结果的索引是所有索引的并集，对于不重叠的标签，会导致缺失值 obj1 + obj2。注：在重构时，标签只含新的指定序列中的标签，新的和原来的匹配则保留，不匹配则删除原来的，添加新的。2.对于DataFrame：会将行和列的索引同时进行匹配，得到的行列索引是所有索引的并集，不重叠的标签，会导致缺失值。data.drop(["a”，“b"]，axis="index或columns"）担当索引不为整数索引时，可用data[-1]来提取最后一个数据。
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 902
数组，双链表实现队列，附完整代码
数据结构-线性表详解
"沈阳工程学院信息工程系的数据结构课件，主要涵盖了线性表的概念、表示及实现" 在计算机科学中，数据结构是组织和管理数据的重要工具，它研究如何高效地存储、检索和操作数据。线性表是数据结构中最基础也是最常用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值