线性表——顺序表

最新推荐文章于 2023-03-10 21:37:38 发布
最新推荐文章于 2023-03-10 21:37:38 发布
阅读量2.5k 收藏 33
点赞数 12
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52490101/article/details/115421907
版权

线性表——顺序表

概念

采用顺序存储结构的线性表。
用一组地址连续的存储单元依次存储线性表的数据元素，以元素在计算机中物理位置来表示数据元素之间的逻辑关系。与数组类似，在于对数据元素的定义可以不局限与数字或字符，可以利用结构体完成各种不同的运算，例如复数 (a + bi) 的加减乘除。

准备工作

创建线性表 (以复数线性表为例)

typedef struct
{
    double rp, ip;
} COMPLEX;

定义COMPLEX结构体，包含rp实部， ip虚部。

typedef COMPLEX LELEMENT;

将COMPLEX定义为线性表元素LELEMENT，方便以后可以将复数线性表改为其他线性表，例如分数线性表。

#ifndef _Real_h_
#define _Real_h_

#define epsilon 1e-8

double Revise(double x);
void RealInput(double *x);
void RealOutput(double x);

int RealGt(double x, double y);
int RealGe(double x, double y);
int RealLt(double x, double y);
int RealLe(double x, double y);
int RealEq(double x, double y);
int RealNe(double x, double y);

void RealSwap(double*x, double *y);

#endif

进行实数准备工作，如实数误差修正，实数输入输出，比较大小，判断相等，交换。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "Real.h"

double Revise(double x)
{
	if (fabs(x) < epsilon)
	{
		return 0;
	}
	else
	{
		return x;
	}
}

void RealInput(double *x)
{
	scanf("%lf", &*x);
	*x = Revise(*x); 
}

void RealOutput(double x)
{
	printf("%g", Revise(x));
}

int RealGt(double x, double y)
{
	int t=0;
	if((x-y)>=epsilon)
	{
		t=1;
	}
	return t;
}

int RealGe(double x, double y)
{
	int t=0;
	if((x-y)>=epsilon||fabs(x-y)<epsilon)
	{
		t=1;
	}
	return t;
}

int RealLt(double x, double y)
{
	int t=0;
	if((y-x)>=epsilon)
	{
		t=1;
	}
	return t;
}

int RealLe(double x, double y)
{
	int t=0;
	if((y-x)>=epsilon||fabs(x-y)<epsilon)
	{
		t=1;
	}
	return t;
}

int RealEq(double x, double y)
{
	int t=0;
	if(fabs(x-y)<epsilon)
	{
		t=1;
	}
	return t;
}

int RealNe(double x, double y)
{
	int t=0;
	if(fabs(x-y)>=epsilon)
	{
		t=1;
	}
	return t;
}

void RealSwap(double *x, double *y)
{
	double a;
	a = *x;
	*x = *y;
	*y = a;
}

进行线性表元素准备工作。

#ifndef _LElement_h_
#define _LElement_h_

#include "Complex.h"

typedef COMPLEX LELEMENT;

void LElementInput(LELEMENT *x);
void LElementOutput(const LELEMENT *x);

int LElementEq(const LELEMENT *x, const LELEMENT *y);
int LElementNe(const LELEMENT *x, const LELEMENT *y);

void LElementSwap(LELEMENT *x, LELEMENT *y);

#endif

由于复数无法比较大小，所以只有输入输出，判断相等，交换函数。

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

void LElementInput(LELEMENT *x)
{
	ComplexInput(x); 
}

void LElementOutput(const LELEMENT *x)
{
	ComplexOutput(x);
}

int LElementEq(const LELEMENT *x, const LELEMENT *y)
{
	return ComplexEq(x, y);
}

int LElementNe(const LELEMENT *x, const LELEMENT *y)
{
	return ComplexNe(x, y);
}

void LElementSwap(LELEMENT *x, LELEMENT *y)
{
	ComplexSwap(x,  y);
}

顺序表

在开始之前，我们已经创建了Real.h、Real.c、LElement.h、LElement.c文件，现在开始构建顺序表

typedef struct
{
    int size, length;
    LELEMENT *element;
} ALIST;

包含有线性表的尺寸，线性表的长度，还有线性表元素的起始地址*element。

#ifndef _AList_h_
#define _AList_h_

#include "LElement.h"

#define AListInitSize 1024//初始尺寸
#define AListIncrement 128//新增尺寸

typedef struct
{
    int size, length;
    LELEMENT *element;
} ALIST;

void AListCreate(ALIST *list);//创建
void AListDestroy(ALIST *list);//销毁
void AListResize(ALIST *list, int size);//扩容
void AListInsert(ALIST *list, int index, const LELEMENT *element);插入
void AListOutput(const ALIST *list);//输出
void AListRemove(ALIST *list, int index, LELEMENT *element);输入
void AListClear(ALIST *list);//清空
void AListInput(ALIST *list);//输入
int AListEmpty(const ALIST *list);//判空
int AListLength(const ALIST *list);//长度
void AListSet(ALIST *list, int index, const LELEMENT *element);设置
void AListGet(const ALIST *list, int index, LELEMENT *element);获取

#endif

在程序开始前，我们需创建线性表才能开始使用，在程序结束前，应将创建的线性表销毁。在线性表初始尺寸不够容纳我们的数据元素时，我们对线性表进行扩容。而根据使用需求，有插入、输出、删除元素、输入、输出线性表、清空线性表、判断空表，获取长度，设置、获取数据元素。

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

void AListCreate(ALIST *list)
{
	list->size = AListInitSize;
	list->length = 0;
	list->element = (LELEMENT*)malloc(list->size * sizeof(LELEMENT));	
} 

void AListDestroy(ALIST *list)
{
    free(list->element);
	list->element = NULL;
	list->size = list->length = 0;
}

void AListResize(ALIST *list, int size)
{
	int i;
	LELEMENT *element;
	if (size > list->length && size != list->size)
	{
		list->size = size;
		element = (LELEMENT*)malloc(list->size * sizeof(LELEMENT));
		for (i = 0; i < list->length; i++)
		{
			element[i] = list->element[i];
		}
		free(list->element);
		list->element = element;
	}
}

void AListInsert(ALIST *list, int index, const LELEMENT *element)
{
	int i;
	if (index < 1 || index > list->length + 1)
	{
		printf("Incorrect index!\n");
	}
	else
	{
		if (list->length == list->size)
			AListResize(list, list->size + 1);
		for (i = list->length; i > index - 1; i--)
		{
			list->element[i] = list->element[i - 1];
		}
		list->element[index - 1] = *element;
		list->length++;
	}
}

void AListOutput(const ALIST *list)
{
	int i;
	putchar('(');
	for (i = 0; i < list->length; i++)
	{
		if (i)
		{
			putchar(',');
		}
		putchar(' ');
		LElementOutput(&list->element[i]);
	}
	putchar(' ');
	putchar(')');
}

void AListRemove(ALIST *list, int index, LELEMENT *element)
{
	int i;
	LELEMENT x = list->element[index - 1];
	if (index <= list->length && index > 0)
	{
		for (i = index - 1; i < list->length - 1; i++)
		{
			list->element[i] = list->element[i + 1];
		}
		list->length--;
		*element = x;
	}
	else
	{
		printf("Incorrect index!\n");
	}
}

void AListClear(ALIST *list)
{
	if (list->element != NULL)
	list->length = 0;
}

void AListInput(ALIST *list)
{
	char c;
	LELEMENT element;
	AListClear(list);
	scanf(" (");
	while (scanf(" %c", &c),c != ')')
	{
		ungetc(c, stdin);
		if (list->length)
			scanf(",");
		LElementInput(&element);
		if (list->length == list->size)
			AListResize(list ,list->size + 10);
		list->element[list->length] = element;
		++list->length;
	}
}

int AListEmpty(const ALIST *list)
{
	return !list->length; 
}

int AListLength(const ALIST *list)
{
	return list->length;
}

void AListSet(ALIST *list, int index, const LELEMENT *element)
{
	if (index <= list->length && index > 0)	list->element[index - 1] = *element;
	else	printf("Incorrect index!\n");
}

void AListGet(const ALIST *list, int index, LELEMENT *element)
{
	if (index <= list->length && index > 0)	*element = list->element[index - 1];
	else	printf("Incorrect index!\n"); 
}

完成线性表的创建和一系列对线性表的操作后，我们需要创建一操作面版提示用户如何操作

#include <stdio.h>
#include "AList.h"

int main()
{
	int index;
	LELEMENT element;
	ALIST list;
	char c;
	AListCreate(&list);
	printf("E-判空 L-长度 N-插入 R-删除 C-清空 S-设置 G-读取 I-输入 O-输出 Q-退出 > ");
	scanf(" %c", &c);
	while (c != 'q' && c != 'Q')//退出 
	{
		if (c == 'e' || c == 'E')//空 
		{
			if (AListEmpty(&list))
				printf("空表\n");
			else
				printf("非空表\n");
		}
		else if (c == 'l' || c == 'L')//长 
		{
			printf("长度: %d\n", AListLength(&list));
		}
		else if (c == 'i' || c == 'I')//输入 
		{
			printf("线性表: "); 
			AListInput(&list);
		}
		else if (c == 'n' || c == 'N')//插入 
		{
			printf("位序: ");
			scanf("%d", &index);
			printf("数据元素: ");
			LElementInput(&element);
			AListInsert(&list, index, &element);
		}
		else if (c == 'r' || c == 'R')//删除 
		{
			printf("位序: ");
			scanf("%d", &index);
			AListRemove(&list, index, &element);
			printf("数据元素: ");
			LElementOutput(&element);
			putchar('\n');
		}
		else if (c == 'c' || c == 'C')//清空 
		{
			AListClear(&list);
		}
		else if (c == 's' || c == 'S')//设置 
		{
			printf("位序: ");
			scanf("%d", &index);
			printf("数据元素: ");
			LElementInput(&element);
			AListSet(&list, index, &element);
		}
		else if (c == 'g' || c == 'G')//读取 
		{
			printf("位序: ");
			scanf("%d", &index);
			AListGet(&list, index, &element);
			printf("数据元素: ");
			LElementOutput(&element);
			putchar('\n');
		}
		else if (c == 'o' || c == 'O')//输出 
		{
			printf("线性表: ");
			AListOutput(&list);
			putchar('\n');
		}
		else
		{
			printf("不正确的选项!\n");
		}
		printf("E-判空 L-长度 N-插入 R-删除 C-清空 S-设置 G-读取 I-输入 O-输出 Q-退出 > ");
        scanf(" %c", &c);
	}
	AListDestroy(&list);
	return 0;
}


这样一个复数线性表就基本完成了。后期我们需要做其他线性表的时候，不必大刀阔斧对程序进行修改，只需要改变一些关键内容，例如将复数线性表改成分数线性表时，我们将

typedef COMPLEX LELEMENT;

改为

typedef FRACTION LELEMENT;

并将实数函数改为整数函数，并添加关于分数运算的函数，如求最大公约数

int Gcd(int x, int y)
{
	if (x || y)
	{
		int a = IntMax(x, y), b = IntMin(x, y), c;
		if (a < 0) a = -a;
		if (b < 0) b = -b;
		while (b > 0)
		{
			c = a % b;
			a = b;
			b = c;
		}
		return a;
	}
	else
	{
		return 1;
	}
}

最大公倍数

int Lcm(int x, int y)
{
	if (x < 0) x = -x;
	if (y < 0) y = -y;
	return x * y / Gcd(x, y);
}

比较大小

int LElementGt(const LELEMENT *x, const LELEMENT *y)
{
	LELEMENT a = *x, b = *y;
	return FractionGt(&a, &b);
}

int LElementGe(const LELEMENT *x, const LELEMENT *y)
{
	LELEMENT a = *x, b = *y;
	return FractionGe(&a, &b);
}

int LElementLt(const LELEMENT *x, const LELEMENT *y)
{
	LELEMENT a = *x, b = *y;
	return FractionLt(&a, &b);
}

int LElementLe(const LELEMENT *x, const LELEMENT *y)
{
	LELEMENT a = *x, b = *y;
	return FractionLe(&a, &b);
}

及其他可用于分数的运算，但不可用于复数运算的函数。

一颗大宝贝
关注
  • 12
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
20、LeetCode 2021/1/31 27. 移除元素
qq_42847094的博客
01-31 562
20、LeetCode 2021/1/31 27. 移除元素 27. 移除元素 难度简单758 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 示例 1： 输入：nums = [3,2,2,3], val = 3 输出：2, nums = [2,2] 解释：函数应该返回新的长度 2, 并且 nu
小白算法积累——顺序表6#有序顺序表 +删除重复元素
01-07
题目：从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。 关键字：有序顺序表 删除重复元素 思路 关注：因为是有序表，所以值相同的元素一定在连续的位置上， 用类似于直接插入排序的思想 1.初始时...
数据结构（c语言版）之顺序表
u012882633的专栏
11-18 854
#include #include #define LIST_INIT_SIZE  100 //线性顺序表空间的初始大小 #define INCREMENT_SIZE 10       //线性顺序表空间不够时增加的大小 typedef struct{ int *elem; //顺序表基址 int length; //顺序表长度 int listsize;  
PTA 6-4 查找元素(*)
wcd278212784的博客
03-31 1993
6-4 查找元素(*)添加链接描述 已知顺序表的结构定义如下： typedef struct { int size, length; int *element; } ALIST; 说明：element 为存储数据元素的动态数组的起始地址，size 为动态数组的尺寸，length 为顺序表的长度。 请编写函数，在顺序表中查找数据元素。 函数原型 int AListFind(const ALIST *list, int element); 说明：参数 list 为指示线性表(顺序表)的指针，element 为待
c语言结构体，结构体变量，结构体变量数组
m0_72575952的博客
03-10 172
/计算两个复数相乘的结果，就想问一下，使用结构变量的指针进行传参数的，传过去和原来的用法一样吧，这个还好不是结构体作为数组元素，数组元素的话几个都是共用一个首地址的吧，只用定义一个就行了.如果先定义了。只能用(*p).age p->age 什么的，也就这两个了，只有数组是比较特殊，p是地址没错。但是下面的好像不能这样，因为是一个的地址，肯定不能用p[2] p[i]什么的了。应该可以用的，因为就把它当作数组来看，p[2]相当于 stu[2]说p[2]代表 a[2]的地址都好点。
数据结构（二）链表的相关操作
时光若止-Dale
03-21 151
以下是我在学习 链表 及其相关接口操作时写的代码: 1.函数定义的 .c 文件 #include "LinkedList.h" #include <stdio.h> #include <stdlib.h> #include <assert.h> //1.初始化 / 销毁 void LListInit(LList *llist) { llist->fir...
线性表——顺序表PPT学习教案.pptx
10-04
线性表——顺序表PPT学习教案 线性表是一种典型的线性结构，其基本特点是线性表中的数据元素是有序且是有限的。线性表可以分为顺序表和链表两种存储结构，今天我们主要讨论顺序表。 1. 线性表的定义 线性表是具有...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-C++5.4.0，为了防止误修改，文档已限制编辑，密码...
小白算法积累——顺序表5#无序顺序表+删除范围
01-07
题目：从顺序表中删除其值在给定值s与t之间（包含s和t，要求s<t）的所有元素，如果s或t不合理或顺序表为空，则显示出错信息并退出运行。 关键词：无序顺序表 删除范围 思路： 1.遍历扫描顺序表L，用k记录下当前...
实验2第二个程序.zip_线性表的顺序存储实现——归并
09-21
归并两个“其数据元素按值非递减有序排列”的有序表 LA 和 LB，求得有序表 LC 也具有同样特性。
线性表之顺序表
weixin_61932507的博客
03-13 1086
1.线性表 定义：n个具有相同特性的数据元素的有限序列。 常见的线性表：顺序表，链表，栈，队列，字符串。 线性表在逻辑上是线性结构，但在物理上不一定是连续的，线性表在屋里上存储时, 通常以数组和链式结构的形式储存。 2.顺序表 定义：顺序表时一段物理地址连续的储存单元一次存储数据元素的线性结构， 一般情况下采用数组存储。在数组上完成增删查改。 类似于数组。 3.分类 静态顺序表 动态顺序表 静态顺序表缺点：开小了不够用，开大了浪费空间。 使用动态顺序表是较优解。 4.接口实现
数据结构——线性表之顺序表
weixin_68153081的博客
09-04 1361
数据结构——线性表之顺序表
数据结构——线性表
qq_52434831的博客
04-24 2842
数据结构线性表的基础知识及常用算法的总结
【数据结构】线性表之顺序表
大米饭的记录册
12-05 421
文章讲解了顺序表及其各个接口的具体实现，包括顺序表的增删查改等。
C语言复数运算（结构体）
热门推荐
qq_45899288的博客
04-09 1万+
复数的加减乘除 *// 复数加法 COMPLEX ComplexAdd(const COMPLEX *x, const COMPLEX *y); // 复数减法 COMPLEX ComplexSub(const COMPLEX *x, const COMPLEX *y); // 复数乘法 COMPLEX ComplexMul(const COMPLEX *x, const COMPLEX *y);...
c语言 复数的运算
gustmirage的博客
04-24 6777
复数的运算 请用程序实现 用函数编写复数的加法、减法、乘法和除法的运算。 函数定义 // 复数加法 COMPLEX ComplexAdd(const COMPLEX *x, const COMPLEX *y); // 复数减法 COMPLEX ComplexSub(const COMPLEX *x, const COMPLEX *y); // 复数乘法 COMPLEX ComplexMul(con...
顺序表（线性表的顺序存储）---C语言版
weixin_47138646的博客
11-27 1977
目录顺序表一、顺序表的定义二、顺序表上基本操作的具体实现1.`InitList_Sq(*L)`:初始化表。构造一个空的顺序表。分类一：主函数里声明的是一个指向顺序表的指针分类二：主函数里声明的是一个顺序表2. `Length(L)`:求表长。3.`ListInsert_Sq(*L,i,e)`:插入操作。在顺序表L中的第i个位置上插入指定元素e。4.`ListDelete_Sq(*L,i,*e)`:删除操作。删除表中L中第i个位置的元素，并用e返回删除的元素。5.`LocateElem(L,e)`:按值查找操
swap函数_swap不应该失败
weixin_39840153的博客
12-10 173
钒铅矿C.84: A swap function may not failC.84:swap函数不应该失败Reason(原因)swap is widely used in ways that are assumed never to fail and programs cannot easily be written to work correctly in the presence of a f...
顺序线性表——课上练
最新发布
09-12
顺序线性表是一种常见的数据结构，它是一系列元素按照一定的顺序排列的数据集合。顺序线性表中的元素在内存中是连续存储的，可以通过索引直接访问。 在课上练习顺序线性表时，你可以尝试以下几个问题： 1. 创建一个空的顺序线性表，并插入若干个元素。 2. 实现顺序线性表的遍历操作，打印出所有元素。 3. 实现顺序线性表的查找操作，根据给定的元素值查找其在表中的位置。 4. 实现顺序线性表的插入操作，将一个新元素插入到指定位置。 5. 实现顺序线性表的删除操作，删除指定位置上的元素。 通过完成这些练习，你可以更好地理解顺序线性表的基本操作和使用方式。在实际开发中，顺序线性表常用于需要频繁访问和操作元素的场景。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一颗大宝贝

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值