【数据结构 —— 线性表方法总结】

已于 2023-11-24 21:50:18 修改
阅读量175 收藏
点赞数 1
分类专栏： 嵌入式 文章标签： 数据结构 c语言
于 2023-11-24 21:45:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dreamer2176/article/details/134607441
版权

1、链表

1.1、线性表

  • 创建线性表：

    • 线性表示意图（图片来源于网络）：

      在这里插入图片描述

    • 创建线性表

      sqlink L;
      • sqlink 是结构体的指针

    • 申请堆空间

      L=(sqlist)malloc(sizeof(sqlist))

    • 判断创建是否成功

      if(L==0){
    printf("malloc erro");
    return -1;
}

    • 初始化线性表

      memset(L,0,sizeof(sqlist));

    • 给last赋值

      last->-1;

    • 返回值

      return L;

  • 向线性表中插入数据

    • 示意图（图片来源于网络）

      在这里插入图片描述

    • 判断线性表是否为满（full）

       if (L->last == N-1)
   {
    printf("the sqlist is full,inster erro\n");
    return -1;
   }

      定义数组中N为128#define N 128

      • 验证链表中的last的位置是不是链表的最后一个位置（是则满不是则空）

      • L->last为最后一个

      • N-1为链表的最后一个角标

    • 检查需要插入的位置是否合理（是否超出范围）

       if (pos<0||pos>L->last+1)
   {
    printf("this pos erro");
    return-1;
   }

      • 即现在输入的位置pos是否小于0会长是否大于链表的最大长度

      • L->last+1链表的角标从0开始算，因此此处的+1表示位置从1开始算

      • pos表示的是插入的位置

    • 移动元素、更新last位置

      for ( i = L->last; i >=pos; i--)
   {
     L->data[i+1]=L->data[i];
   } 
   L->data[pos]=vale;
   L->last++;
    return 0;
}
      • for循环的意思为：定位获取当前链表长度i的值，将pos之后的数字从后往前依次往后移动1个位置（每次）
      • for循环截至条件为：pos定位的位置
      • 通过移动次数更行last的位置

  • 清空线性表

    • 判断是否为空

      if(L==NULL){
    retun -1;
}

      若表L为空则表示没有清空的意义

    • 清空操作

      memset(L,0,sizeof(sqlist));

    • 重新设置last的位置

      L ->last ==NULL;

    • 返回

      return 0;

  • 判断线性表是否为空

    • 通过last判断，因为last始终处于最后一个，因此只需要验证last的位置即可

      if (L->last==-1)
    {
       printf("this sqlist is NULL")
       return -1;
    }

      若last的值还未发生改变，即last==-1时该表任然为空，反之不为空。

       else{
        printf("this sqlist not is NULL")
        return 0;
    }
}

  • 求线性表的长度

    • 判断链表是否为空

      if (L==NULL)
    {
    	printf("L is NULL")
        return -1;
	}

    • 不为空则根据last进行计算

    •  return (L->last+1);

  • 查询指定元素位置

    • 判断该线性表是否为空表

      if (L == NULL) {
    	printf("the sqlist is NILL")
        return -1;
    }

    • 通过遍历查找对应的值

       for (int i = 0; i <= L->last; i++) {
        if (L->data[i] == value) {
            return i;
        }
    }

    return -1;
}
      • 定位到最后一个值L->last并进行遍历和判断

  • 查看遍历线性表

    • 判断链表是否创建成功

      if (L==NULL)
    {
        return -1;
    }

    • 判断是否为空

      	if (L->last==-1)
    {
        printf("the sqlink is null");
    }

    • 遍历打印

       for (size_t i = 0; i < L->last; i++)
    {
        printf("%d",L->data[i]);
    }
    return 0;
}
      • size_t在.h文件中创建结构体时int的重命名

  • 释放空间

    • 判断是否为空

       if(L==NULL){
        printf("this is NULL");
        return -1;
    }

    • 释放空间

      	else{
        free(L);
        return 0;
    }

      ​ 直接使用free()即可

  • 删除指定位置的数据

    • 先判断是否创建成功

      if (L == NULL) {
        printf("this is error");
        return -1;
    }

    • 判断线性表是否为空

       if (L->last == -1) {
        printf("this is NULL");
        return -1;
    }

    • pos的位置是否合理

      if (pos > L->last || pos < 0) {
        printf("pos is error");
        return -1;
    }

    • 使用for循环移动

       for (int i = pos; i < L->last; i++) {
        L->data[i - 1] = L->data[i];
    }

    • 移动last的位置

      L->last--;

  • 数组合并

    • 遍历对比（可以使用上面的查询函数，也可以直接遍历）

      for (int i = 0; i < L->last; ++i) {
        for (int j = 0; j < S->last; ++j)

    • 新建一个变量来接受验证是否相同

      ret = (L->data[i] == S->data[j]);

    • 进行插入

      if (ret != 1) {
    L->data[lcoal + 1] = S->data[j];
    L->last++;
   }

      这里验证ret，如果相同即返回0ret

    • 返回

       return L->last;

    • 完整代码

      int list_merge(sqlink L, sqlink S) {
    int lcoal = L->last;
    int ret;
    for (int i = 0; i < L->last; ++i) {
        for (int j = 0; j < S->last; ++j) {
            ret = (L->data[i] == S->data[j]);
            if (ret != 1) {
                L->data[lcoal + 1] = S->data[j];
                L->last++;
            }
        }
    }
    return L->last;
}

  • 删除相同元素

    • 判断线性表是否为空

      if(L->last==0){
        return 0;
    }

    • 遍历比较

      for (int i = 0; i < L->last; ++i) {
        for (int j = L->last; j >= 0; --j) {
            ret=L->data[i]==L->data[j];

    • 删除重复元素

      if(ret ==1){
	for (int k = j; k < L->last; ++k) {
		L->data[k]=L->data[k+1];
}

    • 移动last

      L->last--;

    完整代码
    sqlist.h

#ifndef UNTITLED_SQLIST_H
#define UNTITLED_SQLIST_H

typedef int data_t;
#define N 128

typedef struct sqlist_t {
    data_t data[N];
    int last;
} sqlist, *sqlink;

sqlink sqlist_create();

int list_clear(sqlink L);

int list_empty(sqlink L);

int list_length(sqlink L);

int list_locate(sqlink L, data_t value);

int list_insert(sqlink L, data_t value, int pos);

int list_show(sqlink L);

int list_free(sqlink L);

int list_delete(sqlink L, int pos);

int list_merge(sqlink L,sqlink S);

int list_Delete_Duplicates(sqlink L);

#endif //UNTITLED_SQLIST_H

sqlist.c

#include <stdio.h>
#include <stdlib.h>
#include "sqlist.h"
#include <string.h>

sqlink sqlist_create() {
    sqlink L;
    L = (sqlink) malloc(sizeof(sqlist));

    if (L == NULL) {
        printf("malloc ERROR\n");
        return L;
    }

    memset(L, 0, sizeof(sqlist));
    L->last = -1;

    return L;
}

int list_clear(sqlink L) {
    if (L == NULL) {
        return -1;
    }

    memset(L, 0, sizeof(sqlist));
    L->last = -1;

    return 0;
}

int list_empty(sqlink L) {
    if (L == NULL) {
        return -1;
    } else {
        return (L->last == -1);
    }
}

int list_length(sqlink L) {
    if (L == NULL) {
        return -1;
    } else {
        return (L->last + 1);
    }
}

int list_locate(sqlink L, data_t value) {
    if (L == NULL) {
        return -1;
    }

    for (int i = 0; i <= L->last; i++) {
        if (L->data[i] == value) {
            return i;
        }
    }

    return -1;
}

int list_insert(sqlink L, data_t value, int pos) {
    if (L == NULL) {
        return -1;
    }

    if (L->last == N - 1) {
        printf("The sqlist is full, insert error.\n");
        return -1;
    }

    if (pos < 0 || pos > L->last + 1) {
        printf("Invalid position.\n");
        return -1;
    }

    for (int i = L->last; i >= pos; i--) {
        L->data[i + 1] = L->data[i];
    }

    L->data[pos] = value;
    L->last++;

    return 0;
}

int list_show(sqlink L) {
    if (L == NULL) {
        return -1;
    }

    if (L->last == -1) {
        printf("The sqlink is empty.\n");
        return 0;
    }

    for (int i = 0; i <= L->last; i++) {
        printf("%d ", L->data[i]);
    }
    printf("\n");

    return 0;
}

int list_free(sqlink L) {
    if (L == NULL) {
        printf("this is NULL");
        return -1;
    } else {
        free(L);
        return 0;
    }
}

int list_delete(sqlink L, int pos) {
    if (L == NULL) {
        printf("this erro");
        return -1;
    }

    if (L == -1) {
        printf("this is NILL");
        return -1;
    }

    if (pos > L->last || pos < 0) {
        printf("pos is erro");
        return -1;
    }
    for (int i = pos; i < L->last; ++i) {
        L->data[i - 1] = L->data[i];
        L->last--;
    }
}

int list_merge(sqlink L, sqlink S) {
    int lcoal = L->last;
    int ret;
    for (int i = 0; i < L->last; ++i) {
        for (int j = 0; j < S->last; ++j) {
            ret = (L->data[i] == S->data[j]);
            if (ret != 1) {
                L->data[lcoal + 1] = S->data[j];
                L->last++;
            }
        }

    }
    return L->last;

}
int list_Delete_Duplicates(sqlink L){
    if(L->last==0){
        return 0;
    }
    int ret;
    for (int i = 0; i < L->last; ++i) {
        for (int j = L->last; j >= 0; --j) {
            ret=L->data[i]==L->data[j];
            if(ret ==1){
                for (int k = j; k < L->last; ++k) {
                    L->data[k]=L->data[k+1];
                }
                L->last--;

            }
        }

    }
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "sqlist.h"
#include "sqlist.c"
#include <string.h>

int main(int argc, const char *argv[]) {
    sqlink L;
    L = sqlist_create();
    if (L == NULL) {
        return -1;
    }
    list_insert(L, 100, 0);
    list_insert(L, 100, 1);
    list_insert(L, 110, 1);
    list_show(L);
    return 0;
}
Dreamer2176
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的创建和基本操作
麻辣清汤的博客
09-14 9476
&&逻辑与 ||逻辑或 线性表是最基本、最简单、也是最常用的一种数据结构。 线性表结构中，数据元素之间通过一对一首位相接的方式连接起来。 具体实现时，线性表可 以采用不同的存储策略。 该方案将线性表存储在一片连续的空间里，通过data,len , 和max三个属性元素。 组织成为了一个结构： data: 给出线性存储空间的起始地址； max : 指明线性表存储空间最 len : 当前线性表里的数据元素个数。 为了讨论简化，我们假设每个数据元素是一个整数： .
线性表的创建
最新发布
qq_58476985的博客
12-01 1344
建一存储学生信息（包含姓名和年龄）的线性表，要求用顺序存储结构实现，实现查询、插入和删除学生信息并将该表中的信息显示出来。2、通过该程序使学生能掌握顺序表结构的定义、顺序表的创建过程、顺序表的特点，以及如何遍历顺序表。1、要求用顺序表实现。
线性表（C++数据结构）
weixin_48434899的博客
08-20 2477
文章目录数据描述 数据描述 数据可以用不同的形式进行描述或存储在计算机存储器中，最常见的数据描述方法有：公式化描述、链接描述、间接寻址和模拟指针。 数据结构的概念： 抽象数据类型。 公式化描述、链接描述、间接寻址和模拟指针。 单向链表、循环链表和双向链表。 ...
算法基础5 —— 线性表(链表的建立、输出、查找、插入、删除等操作)
smallrain6的博客
06-22 4165
线性表 定义：线性表是最基本的一种数据结构，是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 线性表中除了首元素和尾元素之外，每一个元素都有唯一的前驱和唯一的后续 线性表包括顺序表和链表，其中，可以将顺序表理解为数组 链表：链表由各结点组成，每个结点至少包括数据域和指针域。 在上图中的链表里，head 为头结点(一般不存放数据)，5所在结点为尾结点且其指针域为NULL 物理与逻辑 物理上连续指的是数据元素在计算机内存中的地址是连续的 逻辑上连续指的是人们想象中的元素相邻 链表
线性表详细讲述（带图）
m0_64413166的博客
11-18 2920
线性表，有手就可以学废
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构——线性表的实现.zip
09-18
本资料包“数据结构——线性表的实现.zip”着重介绍了线性表的两种常见实现方式：链表和数组。 1. 链表实现： 链表是一种物理存储单元非连续、非顺序的存储结构，它通过节点间的指针链接来表示元素之间的逻辑关系...
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
数据结构实验——线性表子系统
07-31
线性表是数据结构中最基础且重要的概念之一，它是由n(n≥0)个相同类型元素组成的有限序列。在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和...
线性表创建（最基础）
qq_52988578的博客
03-26 9292
线性表：是最基本、最简单、也是最常用的一种数据结构。 前提：在学习数据结构的时候命名不要使用拼音！这是初学者的经常犯得错误。 顺序表的创建： #include<stdio.h> #define N 10 typedef int SLDataType; typedef struct//创建顺序表 { SLDataType array[N]; int size; }SeqList; void SeqListInit(SeqList &L)//输入顺序表的值 { int
线性表12种基本操作
m0_50236851的博客
09-08 4338
线性表12种基本操作 @ 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matp
第02次作业-线性表
weixin_34342905的博客
03-24 297
一、PTA实验作业 题目一： 6-3jmu-ds- 顺序表删除重复元素 2. 设计思路（伪代码或流程图） 1.创建顺序表，采用for循环， 将从主函数传来的数组a【】录入到顺序表中， 其中循环次数n为顺序表的长度,for(i=0;i<n;i++) 2.输出顺序表，同样采用for循环，n与上同， 逐个输出//printf("%d",L->data[i]...
线性表的建立以及基本操作
热门推荐
ciganxian的专栏
05-29 1万+
#include #include #define MaxSize 50 typedef char ElemType; typedef struct { ElemType elem[MaxSize]; //存放顺序表中的元素 int length; //存放顺序表的长度 } SqList; void InitList(
线性表的创建(C)
SHAUNG_YUE的博客
05-22 6255
main.c #define _CRT_SECURE_NO_WARNINGS #include "header.h" #include "SqList.h" void main(void) {     SqList LA;  //建立线性表      InitList_Sq(&amp;LA);//初始化线性表 。。。。。。。。。。。。。。。。。//添加自己的程序代码        whil...
Day1-线性表的创建及简单操作
weixin_45030148的博客
03-09 302
一、线性表的基本操作 InitList(&L):初始化表--构造一个空的线性表。 Length(L):求表长--返回线性表L的长度，即L中数据元素的个数。 LocateElem(L,e):按值查找操作--在表L中查找给定关键字值得元素。 GetElem(L,i):按位查找操作--获取表L中第i个元素的值。 ListInsert(&L,i,e):插入操作--在表L中第i个位置上插入指定元素e。 ListDelete(&L,i,e):删除操作--删除表中第i个元素，并用e返回
c语言线性表创建步骤,实例详解C语言线性表的顺序与实现步骤
weixin_42322512的博客
05-18 3073
数据结构中，线性表是一种入门级的数据结构，线性表分为序列表和链表，在下文中爱站技术频道小编将实例详解C语言线性表的顺序与实现步骤，下面一起跟着爱站技术频道的步伐来学习吧！1.概述通常来说顺序表是在计算机的内存中以数组的形式保存的线性表，是用一组地址连续的存储单元依次存储数据元素的线性数据结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单...
c语言建立线性表（顺序储存，链式储存，循环，双向）全
qq_39838607的博客
09-02 1万+
c语言建立线性表 顺序储存 储存结构 初始化（建立）顺序表 查找操作 一、按值查找，找到返回对应的下标 二、按照下标返回元素 插入操作 一、在线性表尾部添加元素 二、在位置i处插入元素 三、顺序表（有序）插入，（如都是由小到大） 删除操作 一、删除位置i的元素,删除成功后，返回删除的值 二、删除值为val的第一个元素，没有返回-1 三、在非递减有序的有序表中删除多余的相同元素 其余操作 一、将线性表中的所有元素转置 二、两个有序的顺序表合并后任然有序 完整代码 链式储存 存储结构 建立链表 一、尾插法建立
哈夫曼树构建及数据结构基础——线性表、栈和队列
本文主要讨论了数据结构中的哈夫曼树及其构造方法，这是软件工程领域中的一个重要知识点。哈夫曼树是一种特殊的二叉树，通常用于数据压缩，其特点是每个叶子节点代表一个需要编码的字符，而内部节点的权重是其子节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值