C语言线性表

于 2023-05-07 21:18:22 发布
阅读量213 收藏 1
点赞数
分类专栏： 数据结构 文章标签： c语言 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/you_well/article/details/130532135
版权

文章目录

线性表

定义： 由n（n>=0）个相同类型的元素组成的有序集合。
L=（a_{1},）

线性表中元素个数n，称为线性表的长度。当n=0时，为空表。
a1是唯一的“第一个""数据元素，an是唯一的“最后一个”数据元素。
ai-1为ai的直接前驱， ai+1为ai 的直接后继.

线性表的特点

表中元素的个数是有限的。
元素的数据类型都相同，意味着每一个元素占用相同大小的空间
表中元素具有逻辑上的顺序性，在序列中各元素排序有其先后顺序

线性表的顺序表示（顺序表）

在这里插入图片描述
逻辑上相邻的两个元素在物理位置上也相邻。
顺序表的定义

#define MaxSize 50	//定义线性表的长度
typedef struct{
	ElemType data[MaxSize];  //顺序表的元素
	int len;				//顺序表的当前长度
}SqList;					//顺序表的类型定义

优点：
 1.可以随机存取（根据表头元素地址和元素序号）表中任意一个元素。
 2.存储密度高，每个结点只存储数据元素。

缺点：
 1.插入和删除操作需要移动大量元素。
 2.线性表变化较大时，难以确定存储空间的容量。
 3.存储分配需要一整段连续的存储空间，不够灵活。

插入操作

在这里插入图片描述

最好情况:在表尾插入元素，不需要移动元素，时间复杂度为O(1)。

最坏情况:在表头插入元素，所有元素依次后移，时间复杂度为O(n)。

平均情况:在插入位置概率均等的情况下，平均移动元素的次数为n/2，时间复杂度为O(n)

代码片段

//判断插入位置i是否合法（满足1<=i<=len+1）
//判断存储空间是否已装满（即插入x后是否会超出数组长度）
for(int j=L.len;j>=i;j--)	//将最后一个元素到第o个元素一次后移一位
	L.data[j]=L.data[j-1];
L.data[i-1]=x;		//空出的位置i处放入x
L.len++;			//线性表的长度加1

注意
线性表的第一个元素的数组下标是0.
插入操作

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

#define MaxSize 50
typedef int ElemType;//顺序表中元素的类型
//静态分配
typedef struct {
    ElemType data[MaxSize];//定义的数组，用来存元素
    int length;//当前顺序表中有多少给个元素
}SqList;

//L代表顺序表，i代表插入的位置，从1开始，e表示要插入的元素
bool ListInsert(SqList &L,int i,ElemType e)
{
    if(i<1 || i>L.length+1) //判断插入的位置是否合法
        return false;
    if(L.length>=MaxSize)    //元素存储满了，不可以再存储了
        return false;
    for(int j=L.length;j>=i;j--)//移动顺序表中的元素，依次往后移动
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;//数组下标从0开始，插入第一个位置，访问的下标为0
    L.length++;
    return true;//插入成功，返回True
}
//打印顺序表元素
void PrintList(SqList &L)
{
    for(int i=0;i<L.length;i++)
    {
        printf("%3d",L.data[i]);//要求所有元素打印到一排
    }
    printf("\n");
}
int main()
{
    SqList L;//顺序表的名称
    bool ret;//查看返回值，布尔型是True或者False
    ElemType del;//用来存要删除的元素
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;//总共3个元素
    ret=ListInsert(L,2,60);//往第二个位置插入60这个元素
    if(ret)
    {
        printf("插入成功\n");
        PrintList(L);//打印成功后的顺序表

    }
    else
    {
        printf("插入失败\n");
    }
}

运行结果
在这里插入图片描述

删除操作

在这里插入图片描述

最好情况:删除表尾元素，不需要移动元素，时间复杂度为O(1)。

最坏情况:删除表头元素，之后的所有元素依次前移，时间复杂度为O(n)

平均情况:在删除位置概率均等的情况下，平均移动元素的次数为(n-1)/2,时间复杂度为O(n)。

代码片段

//判断删除位置i是否合法（满足1<=i<=len）
e=L.data[i-1];	//将被删除的元素赋值给e
for(int j=i;j<L.len;j++)	//将删除位置后的元素依次前移
	L.data[j-1]=L.data[j];
L.len--;				//线性表长度减一

注意
插入和删除时，i的合法范围是不一样的。
删除操作

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

#define MaxSize 50
typedef int ElemType;//顺序表中元素的类型
//静态分配
typedef struct {
    ElemType data[MaxSize];//定义的数组，用来存元素
    int length;//当前顺序表中有多少给个元素
}SqList;

//L代表顺序表，i代表插入的位置，从1开始，e表示要插入的元素
bool ListDelete(SqList &L,int i,ElemType &e)
{
    if(i<1 || i>L.length+1) //如果删除的位置不合法
        return false;
    if(L.length==0)     //顺序表中没有元素，无需删除
        return false;
     e=L.data[i-1];	//获取顺序表中对应的元素，赋值给e
    for(int j=i;j<L.length;j++)//从i的位置，一次把元素往前覆盖
        L.data[j-1]=L.data[j];
    L.length--;//删除一个元素，顺序表长度减1
    return true;
    }
//打印顺序表元素
void PrintList(SqList &L)
{
    for(int i=0;i<L.length;i++)
    {
        printf("%3d",L.data[i]);//要求所有元素打印到一排
    }
    printf("\n");
}
int main()
{
    SqList L;//顺序表的名称
    bool ret;//查看返回值，布尔型是True或者False
    ElemType del;//用来存要删除的元素
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;//总共3个元素
    ret=ListInsert(L,1,del);/删除第一个位置的元素，并把元素输出
    if(ret)
    {
        printf("删除成功\n");
        printf("删除的元素是：%d\n",del)
        PrintList(L);//打印成功后的顺序表

    }
    else
    {
        printf("删除失败\n");
    }
}

查找操作

查找操作

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

#define MaxSize 50
typedef int ElemType;//顺序表中元素的类型
//静态分配
typedef struct {
    ElemType data[MaxSize];//定义的数组，用来存元素
    int length;//当前顺序表中有多少给个元素
}SqList;

//查找成功返回位置，位置从1开始，查找失败，返回0
int LocateElem(SqList L,ElemType e)
{
	int i;
	for(i=0;i<L.length;i++)	//顺序表遍历
	{
		if(L.data[i]==e
			return i+1;		//加1就是元素在顺序表中的位置
	}
	return 0;
}
int main()
{
    SqList L;//顺序表的名称
    bool ret;//查看返回值，布尔型是True或者False
    ElemType del;//用来存要删除的元素
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;//总共3个元素
	int elem_pose;
	elem_pose=LocateElem(L,60);
	if(elem_pose)
	{
		printf("查找成功\n");
		printf("元素的位置是%d\n",ret);
	}
	else{
		printf("查找失败\n")；
	}
}

动态分配

#define InitSize 100 //表长度的初始定义
typedef struct
{
	ElemType *data;//指示动态分配数组的指针
	int MaxSize.length;//数组的最大容量和当前个数
}SeqList;				//动态分配数组顺序表的类型定义

C的初始动态分配语句：

L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize);

C++的初始动态分配语句：

L.data=new ElemType[InitSize];

动态分配的数组还是属于顺序存储结构。

全部代码

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

#define MaxSize 50
typedef int ElemType;//顺序表中元素的类型
//静态分配
typedef struct {
    ElemType data[MaxSize];//定义的数组，用来存元素
    int length;//当前顺序表中有多少给个元素
}SqList;

//L代表顺序表，i代表插入的位置，从1开始，e表示要插入的元素
bool ListInsert(SqList &L,int i,ElemType e)
{
    if(i<1 || i>L.length+1) //判断插入的位置是否合法
        return false;
    if(L.length>=MaxSize)    //元素存储满了，不可以再存储了
        return false;
    for(int j=L.length;j>=i;j--)//移动顺序表中的元素，依次往后移动
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;//数组下标从0开始，插入第一个位置，访问的下标为0
    L.length++;
    return true;//插入成功，返回True
}
//打印顺序表元素
void PrintList(SqList &L)
{
    for(int i=0;i<L.length;i++)
    {
        printf("%3d",L.data[i]);//要求所有元素打印到一排
    }
    printf("\n");
}

bool ListDelete(SqList &L,int i,ElemType &e)
{
    if(i<1 || i>L.length)   //如果删除的位置不合法
        return false;
    if(L.length==0)         //顺序表中没有元素，无需删除
        return false;
    e=L.data[i-1];          //获取顺序表中对应的元素，赋值给e
    for(int j=i;j<L.length;j++) //从i的位置，一次把元素往前覆盖
    
        L.data[j-1]=L.data[j];
    L.length--;             //删除一个元素，顺序表长度减1
    return true;
    
}
//查找成功返回位置，位置从1开始，查找失败，返回0
int LocateElem(SqList L,ElemType e)
{
    int i;
    for(i=0;i<L.length;i++)//遍历顺序表
        if(L.data[i]==e)
            return i+1; //加1就是元素在顺序表中的位置
    return 0;
}
int main()
{
    SqList L;//顺序表的名称
    bool ret;//查看返回值，布尔型是True或者False
    ElemType del;//用来存要删除的元素
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.length=3;//总共3个元素
    ret=ListInsert(L,2,60);//往第二个位置插入60这个元素
    if(ret)
    {
        printf("插入成功\n");
        PrintList(L);//打印成功后的顺序表

    }
    else
    {
        printf("插入失败\n");
    }


    //删除操作
    ret=ListDelete(L,1,del);//删除第一个位置的元素，并把元素输出
    if(ret)
    {
        printf("删除成功\n");
        printf("删除的元素值：%d\n",del);
        PrintList(L);
    }
    else
    {
        printf("删除失败\n");
    }
    int elem_pose;
    elem_pose=LocateElem(L,60);
    if(elem_pose)
    {
        printf("查找成功\n");
        printf("元素位置为%d\n",ret);

    }
    else{
        printf("查找失败\n");
    }
    return 0;
}

练习

#include <stdlib.h>
#include <stdio.h>
struct student{
	int num;
	char name[20];
	char sex;
};//声明一个结构体类型
int main()
{
	struct student s;
	scanf("%d%s %c",&s.num,s.name,&s.sex);
	printf("%d %s %c\n",s.num,s.name,s.sex);
	return 0;

scanf传递时，为什么后面要给一个地址？
scanf相当于一个函数，对值进行修改需要知道地址，间接修改，而printf不需要给地址。
C++的引用

#include <stdio.h>
#include <stdlib.h>
void modify_pointer(char*&p)
{
	p=(char*)malloc(100);	//申请空间
	fgets(p,100,)//如果使用fgets时传入的是一个指针变量，中间参数是指针指向空间的大小
	
	
}
int main()
{
	char *p;
	modify_pointer(p);
	puts(p);
	return 0;
}
浪漫的诗人
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构C语言 线性表
kkh01421的博客
08-29 4934
一、线性表的概念及运算 （一）线性表的逻辑结构 线性表是n个数据元素的有限序列。表中元素存在线性关系。根据它们之间的关系可以构成一个线性序列，记作 （a1,a2,...an) 线性表中的元素具有相同的数据类型。线性表中数据元素的个数n定义为线性表的长度，称为表长。n=0时成为空表。ai是第i个数据元素，称i为位序。 （二）线性表的运算 线性表有以下基本运算 1、Inilist():线性表初始化，构造一个空的线性表L。 2、ListLength(L):求线性表的长度，返回线性表L中元素个数。 3
c语言实现简易线性表
qq_63605696的博客
11-08 2821
c语言实现简易线性表。
数据结构（C语言版）-线性表（顺序表）
czh2637750821的博客
01-04 1525
线性表一、线性表的基本概率1、线性表的定义2、线性表举例3、线性表的特点4、线性表的基本操作二、线性表的顺序存储1、顺序表的定义2、顺序表的存储特点3、顺序表的类型定义4、顺序表的基本运算的实现。三、配套实验 一、线性表的基本概率 1、线性表的定义 线性表是具有相同数据类型的n(n>= 0)个数据元素的有限序列。 2、线性表举例 （1）简单的线性表。例如，26个英文字母表；一周七天。 （2）复杂的线性表。例如，学生信息登记表。 在复杂的线性表，常把数据元素称为记录（Record），它由若干个数据项（I
数据结构-线性表详解（类C语言版）
秃了也弱了
03-31 2049
线性表的定义和特点 线性表是具有相同特性的数据元素的一个有限序列。
数据结构（C语言）——线性表（定义，基本操作）
weixin_62677583的博客
12-14 5343
数据结构（C语言）——线性表（定义，基本操作）一、 线性表的定义二、线性表的基本操作什么时候要传入引用“==&==”————对参数的修改结果需要“==带回来==”为什么要实现数据结构的基本操作？ 一、 线性表的定义 线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为 L=（a1,a2,a3,…,ai,ai+1，…,an) 注：每个数据元素所占空间相等，有次序。 几个概念： （1）ai是线性表中的“第i个”元素
C语言线性表顺序存储结构实例详解
08-30
C语言线性表顺序存储结构实例详解 本资源主要介绍了C语言线性表顺序存储结构实例的相关知识点，涵盖了顺序存储结构的定义、线性表的顺序存储结构的实现、顺序表的初始化操作、获取元素操作、插入操作和删除元素操作...
C语言线性表的顺序表示与实现实例详解
09-04
在C语言中，线性表的顺序表示通常采用数组来实现，这是因为数组提供了一种直接访问任意位置元素的高效方式。顺序表的优点在于其随机访问的特性，但插入和删除操作可能需要移动大量元素，效率相对较低。 1. **顺序表...
C语言线性表结构实验
11-06
（2）掌握线性表的顺序存储结构的定义及C语言实现。 （3）掌握线性表在顺序存储结构即顺序表中的各种基本操作。 2．问题描述： 假设两线性表LA和LB分别表示两集合A和B，要求新集合A=AB。 3． 数据输入: 由文件...
数据结构 c语言 线性表 增删查改保存.txt
07-24
数据结构 c语言 线性表 增删查改保存 InitList(Linklist &L,int &k); PrintList(Linklist &L,int &k); ListInsert(Linklist &L,int &k); ListDelete(Linklist &L,int &k); void ListSave(Linklist &L); void cd();
线性表-c语言
weixin_43655690的博客
03-09 2082
定义 线性表：零个或多个数据元素的有限序列。 首先，他是一个序列，元素之间是有顺序的，若存在多个元素，**则第一个无前驱，最后一个无后继，其他元素每个元素都有且只有一个前驱和后继。 **然后，线性表强调是有限的，元素的个数是有限的。 线性表元素的个数n(n>-0)定义为线性表的长度，当n=0时，称为空表。 在复杂的线性表中，一个数据元素可以由若干个数据项组成。相同类型的数据。 线性表的抽象数据类型 ADT 线性表(List) Data 线性表的数据对象集合为{a1,a2,......,an},每个元素
C语言实现的顺序线性表
01-16
用C语言实现了顺序线性表的基本操作（创建、插入数据、获取数据、删除数据、获取存放的数据量、清空线性表、销毁线性表）
c语言实现线性表
06-22
c语言实现线性表
数据结构（C语言版）之线性表
qq_41743824的博客
03-08 5143
前言 这学期学校开设了数据结构与算法，为帮助更多小伙伴和巩固学习，我开始整理这门课的学习内容，希望能给同样在学习这门课的小伙伴们提供一些浅薄的思路。 正文部分 什么是线性表 线性表结构体定义 实现线性表的“增删查改”功能 ...
C语言实现线性表
weixin_42586927的博客
10-23 5342
#include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 //定义线性表最大长度 /*定义顺序表*/ typedef struct { int data[MAXSIZE]; //线性表占用的数组空间 int length; //存储线性表的长度 }SeqList; /*初始化顺序表*/ void InitList(SeqList *L) { L->length=0; //表长为零 } /*建立顺序表
C语言实现线性表的基本操作详解
qq_62138543的博客
03-30 2806
··· #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100//线性表的最大长度 typedef struct { int *elem; int length;//线性表的当前长度 //int maxlength;//线性表的最大长度 }SqList; SqList q; int i,k; //初始化函数 void initSqList(SqList& l) { ...
C语言丨线性表（二）：线性链表（单链表）
weixin_60921752的博客
12-26 3749
本文在介绍线性表的基本概念的基础上，重点介绍线性链表（单链表）及相应的算法。
c语言实现线性表的算法,数据结构算法代码实现——线性表的定义(一)
weixin_36374105的博客
05-24 311
线性表的定义线性表：是最常用且最简单的一种数据结构，它是一种线性数据结构，是由类型相同的n个(n≥0)数据元素组成的有序序列。线性表的特点：有且只有一个被称作“第一个”的数据元素，有且只有一个被称为“最后一个”的数据元素。除第一个数据元素之外，其他元素都只有一个前驱，除最后一个数据元素之外，其他元素都只有一个后继。简单的说，其特点是数据元素之间存在”一一对应 (序偶关系)“的关系。好，现在举个例子...
C语言-线性表
Silence_Fall的博客
10-26 1191
1线性表基本操作InitList(*L): 初始化操作，建立一个空的线性表L。 ListEmpty(L): 判断线性表是否为空表，若线性表为空，返回true，否则返回false。 ClearList(*L): 将线性表清空。 GetElem(L,i,*e): 将线性表L中的第i个位置元素值返回给e。 LocateElem(L,e): 在线性表L中查找与给定值e相等的元素，如果查找成功，返回该元素在表
c—线性表
qq_44921148的博客
07-04 148
数据结构
c语言 线性表冒泡排序
最新发布
06-27
C语言中的线性表，通常指的是数组或链表这两种数据结构，它们用于存储和组织一系列数据。而冒泡排序是一种简单的排序算法，它重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。 下面是使用C语言实现冒泡排序的基本步骤： 1. **定义数组**：首先，你需要声明一个数组并初始化你要排序的数据。 ```c int arr[] = {9, 7, 5, 11, 12, 2}; ``` 2. **设置长度**：计算数组的大小（即元素数量）。 ```c int n = sizeof(arr) / sizeof(arr); ``` 3. **冒泡过程**：使用嵌套循环进行冒泡操作。 ```c for (int i = 0; i < n-1; i++) { for (int j = 0; j < n-i-1; j++) { if (arr[j] > arr[j+1]) { // 交换arr[j]和arr[j+1] int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } ``` 4. **检查排序结果**：最后，数组应该按升序排列。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值