顺序表的操作集合

数据结构和算法 顺序表表示集合的几种操作 记录顺序表表示集合的几种操作 1.求两个集合的交集 算法要求:交集运算,求L3=L1∩L2 算法思想:用两次循环,依次抽取L1中的元素,检查L2是否有与之相等的元素,若有则//插入L3中 void intersectList(list *L1,list *L2,list *L3){ int i,j; for(i=0;i<L1->length;i++){ for(j=0;j&lt... 阅读详情

包括对线性表的插入,删除,销毁,排序,交换等等操作

#define MULTIPLE 2
#define ERROR -1
typedef int elem_type;

#define INIT_SIZE 10

typedef struct _DSEQ_LIST
{
elem_type *data;
int length;
int total_length;
}Dlist;


#include<stdio.h>

#include<stdlib.h>
#include<assert.h>
#include"list_des.h"


Dlist *init_dse_list()
{
Dlist *phead = (Dlist *)malloc(sizeof(Dlist));
elem_type *p = (elem_type *)malloc(sizeof(elem_type)*INIT_SIZE);
assert(phead != NULL && p != NULL);


phead->data = p;
phead->length = 0;
phead->total_length = INIT_SIZE;
return phead;
}


bool destory_dse_list(Dlist *p)
{
if (p == NULL)    //研究将其写成宏函数形式
{
return false;
}


free(p->data);
free(p);
return true;
}


//其存在的意义,1,调用函数增加开销,2,直接通过结构体指针就能直接找到
//对不属于自己的进行操作使得程序崩溃
//保护数据,防止对其意外修改


bool clear_seq_list(Dlist *p)
{
if (p == NULL)
{
return false;
}


for(int i=0; i<get_length(p); i++)
{
*(p->data+i) = 0;
}
p->length = 0;


return true;
}


bool insert(Dlist *p, int pos, elem_type e)
{
if (p == NULL || pos>get_length(p) || !is_full(p))
{
return false;
}
for (int i=get_length(p)+1; i>=pos; i--) //向后挪动
{
*(p->data + i+1) = *(p->data + i);
}

*(p->data+pos) = e;
p->length++;


return true;
}


bool insert_head_majia(Dlist *p, elem_type e)
{
return insert(p,0,e);
}


bool insert_tail_majia(Dlist *p, elem_type e)
{
return insert(p,get_length(p),e);
}


bool insert_tail(Dlist *p, elem_type e)
{
    if(p == NULL)
{
return false;
}
if (false == is_full(p))
{
return false;
}


*(p->data + p->length) = e;
p->length++;
return true;
}


bool insert_head(Dlist *p, elem_type e)
{
if(p == NULL)
{
return false;
}
if (false == is_full(p))
{
return false;
}




if (p->length != 0)
{
for(int i=p->length; i>0; i--)
      {
*(p->data+i) = *(p->data+i-1);
   }
}
*(p->data) = e;
p->length++;


return true;
}


bool is_full(Dlist *p)
{
if (p == NULL)
{
return false;
}


if (get_length(p) == p->total_length) //从零开始,第九个的时候已经满了,p->length = 10;
{
//elem_type *data             void *realloc( void *memblock, size_t size );
//p->data = (elem_type *)realloc(p->data, (p->total_length) * MULTIPLE);
p->data = (elem_type *) realloc(p->data, (p->total_length) * MULTIPLE*sizeof(elem_type));
assert(p->data != NULL);
p->total_length = MULTIPLE * (p->total_length);
}


return true;
}


bool is_empty(Dlist *p)
{
if (!(p != NULL && p->length == 0)) //
{
return false;
}
return true;
}


bool show(Dlist *p, void (*pfunc)(elem_type *))
{
if (p == NULL)
{
return false;
}
          //此处的p已经经过检查,可以直接采用p->length形式,这样写避免函数的使用的代价
for(int i=0; i<get_length(p); i++)
{
pfunc(p->data+i);
}
return true;
}


bool get_pos_by_value(Dlist *p, elem_type e,int *n)
{
while (p == NULL)
{
return false;
}


int i = 0;
while (i < p->length)
{
if (*(p->data+i)==e)
{
*n = i;
return true;
}
i++;
}
return false;
}


bool search_yes_or_no(Dlist *p, elem_type e)
{
int n=0;
bool x =get_pos_by_value(p,e,&n);


if (!x)
    {
return false;
}


return true;
}


bool sort(Dlist *p)
{
if (p == NULL)
{
return false;
}
for(int i=0; i<p->length; i++)
{
for(int j=0; j<p->length-i-1; j++)
{
if (*(p->data+j) > *(p->data+j+1))
{
elem_type temp = 0;
temp = *(p->data+j);
*(p->data+j) = *(p->data+j+1);
*(p->data+j+1) =temp;
}
}
}
return true;
}


bool get_max(Dlist *p, elem_type *e)
{
if (p == NULL)
{
return false;
}


int max = *p->data;
for(int i=1; i<get_length(p); i++)
{
if (*(p->data+i)>max)
{
max = *(p->data+i);
}
}
*e = max;
return true;
}


bool get_min(Dlist *p, elem_type *e)
{
if (p == NULL)
{
return false;
}


int min = *p->data;
for(int i=1; i<get_length(p); i++)
{
if (*(p->data+i)<min)
{
min = *(p->data+i);
}
}
*e = min;
return true;
}


int get_length(Dlist *p)
{
if (p == NULL)
{
return ERROR;
}
return p->length;
}


bool del_head_majia(Dlist *p, elem_type *e)
{
return del(p, 0, e);
}


bool del_tail_majia(Dlist *p, elem_type *e)
{
return del(p, get_length(p), e);
}


bool del_head(Dlist *p, elem_type *e)
{
if (p == NULL)
{
return false;
}


*e = *p->data;
for (int i=0; i<get_length(p); i++)
{
*(p->data+i) = *(p->data+i+1);
}
p->length--;


return true;
}


bool del_tail(Dlist *p, elem_type *e)
{
if (p == NULL)
{
return false;
}


*e = *(p->data+get_length(p)-1);
    p->length--;
return true;
}


bool del(Dlist *p,int pos, elem_type *e)
{
if (p == NULL) //get_length中包含对p为空的判断
{
return false;
}
if (pos > get_length(p))
{
return false;
}


*e = *(p->data+pos);
for(int i=pos; i<get_length(p); i++)
{
*(p->data+i) = *(p->data+i+1);
}
p->length--;


return true;
}


bool put(Dlist *p, int pos, elem_type e)
{
if (!(p != NULL && pos < get_length(p)))
{
return false;
}


*(p->data + pos)=e;  //让其下标皆从零开始
return true;
}


bool get(Dlist *p, int pos, elem_type *e)
{
if (!(p != NULL && pos < get_length(p)))
{
return false;
}
*e = *(p->data+pos);
return true;
}


bool meger(Dlist *p, Dlist *s)//p=p+s;
{
if (p == NULL || s == NULL)
{
return false;
}


elem_type temp;//如果当其为整型进行初始化,那如果是结构体就用不了
for (int i=0; i<get_length(s); i++)
{
bool bo = get(s, i, &temp);
if (bo == false)
{
return false;

}
insert_tail(p, temp);
}


return false;
}








bool swap(Dlist *p, Dlist *s)
{
if (p == NULL || s == NULL)
{
return false;
}


int i = 0;
int x = get_length(p);
int y = get_length(s);


int plength = x;
int slength = y;


while(x>0 && y>0)
{
is_full(s);
is_full(p);


elem_type temp1;
elem_type temp2;
bool s1 = get(p, i, &temp1);
bool s2 = get(s, i, &temp2);


if (s1 == false || s2 ==false)
{
return false;
}
//如果将两个判断合并起来,则在拿出放进之后,如果得到的就是错误的数据,已经放进去再退出这个函数,对数据有污染
bool s3 = put(s, i, temp1);
bool s4 = put(p, i, temp2);


if (s3 == false || s4 == false)
{
return false;
}


x--;
y--;
i++;
}


elem_type temp;
if (x == 0)
{  
    while (y-- != 0)
{
get(s, i, &temp);
insert(p,i,temp);
i++;
}
}
else
{
while (x-- != 0)
{
get(p, i, &temp);
insert(s, i, temp);
i++;
}
}


p->length = slength;
s->length = plength;
return true;
}


bool merger_by_order(Dlist *p, Dlist *s)//p=p+s
{
if (p == NULL || s == NULL)
{
return false;
}

bool s1 = sort(p);//不好,改变了原来数据
bool s2 = sort(s);


if (!s || !s2)
{
return false;
}


elem_type temp1; // p  m
elem_type temp2; // s  n
int m = 0;
int n = 0;


int plength = get_length(p);
int slength = get_length(s);


elem_type pp = *(p->data+plength-1);
elem_type ss = *(s->data+slength-1);


int tmp = get_length(p) < get_length(s) ? get_length(p) : get_length(s);           //得出较小值


get(p, m, &temp1);
get(s, n, &temp2);
for (int i=0;  pp != temp1 && ss != temp2 ; i++)
{
bool s1 = get(p, m, &temp1);
bool s2 = get(s, n, &temp2);
if (!s1 || !s2)
{
return false;
}
 //p m 9   s n 23
if(temp1 < temp2)
{
m++;
}
else
{
insert(p, m, temp2);
n++;
}
}


if(plength == tmp)
{
while(tmp < slength)
{
get(s, n, &temp1);
insert_tail(p,temp1);
n++;
m++;
tmp++;
}
}
return false;
}


bool same_data(Dlist *p, Dlist *s, Dlist *m)//p与s中相同的取出放到m线性表中去
{
if (p == NULL || s == NULL || m == NULL)
{
return false;
}
for (int i=0; i<get_length(p); i++)
{
if (search_yes_or_no(s, *(p->data+i)))
{
insert_tail(m,*(p->data+i));
}
}
return true;
}







【数据结构C++实现】顺序表实现集合操作:交集、并集与差集   (递增有序)顺序表表示集合A、B,实现以下操作:    C=A∩B,C=A∪B,C=A∖BC=A \cap B,C=A \cup B,C=A \setminus BC=A∩B,C=A∪B,C=A∖B A=A∩B,A=A∪B,A=A∖BA=A \cap B,A=A \cup B,A=A \setminus BA=A∩B,A=A∪B,A=A∖B C=A∩BC=A \cap BC=A∩B bool SeqList::intersectionSet( SeqList& LA, SeqList 阅读详情

相关推荐

顺序表实现集合的并集、交集、差集

题目内容 基本要求: 实现顺序表的各种基本运算的算法,求集合的并集、交集、差集: 测试案例: 线性表A的元素为:1 2 3 4 线性表B的元素为:2 3 5 6 7 A∪B为:1 2 3 4 5 6 7 A∩B为:2 3 A-B为:1 4 B-A为:5 6 7 算法描述 A:A的特有元素+AB共有元素; B:B的特有元素+AB共有元素; A∪B:将A、B的所有元素合到一起构成的集合C,相同的数...

Nothing_Wzy的博客 1万+

6-2 顺序表操作集

本题要求实现顺序表的操作集。 函数接口定义: List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下: typedef int Position; typedef struct LNode *List; struct LNode { Ele.

idjke的博客 2613

利用顺序表实现集合的并运算

/*利用顺序表实现集合的并运算*/ #include #include #include #include #include using namespace std; const int N=20; template class SeqList { private: DataType* list; int MaxSize; int size; public: SeqL

梧桐下的四叶草 2444

【01】顺序表操作集

这是一个很基础的题目。。。 函数接口定义: // An highlighted block List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下: // An highlighted block typedef int Position; typed

WR的博客 887

6-65 顺序表操作集

本题要求实现顺序表的基本操作集,如初始化、查找、插入、删除等操作。

燕朝铭的博客 1066

gesp c++ 八级知识点

gesp c++ 八级知识点

MMD.然大大 2250

6-1 顺序表操作集 数据结构实训(c/c++编程题)

* 保存线性表中最后一个元素的位置 */各个操作函数的定义为:(1)List MakeEmpty():创建并返回一个空的线性表。(2)void PrintL(List L):顺序打印顺序表L里面的数据元素。打印要求:“顺序表的值为:”(按顺序打印顺序表中的数据元素,每个数据元素之后有一个空格,打印结束之后打印换行符)(3)Position Find( List L, ElementType X ):在线性表L中查找X,若找到,则返回线性表中X的位置;若找不到则返回ERROR。

m0_62351105的博客 812

数据分析—用户行为数据分析

一般价值用户(R高F高M低):用户处于购买活跃期,感兴趣的商品多,购买次数少 → 针对该部分客户,目的就是要让他们购买,所以可以和运营部门沟通,降低利润,给出有力折扣促进购买,进而转为重要价值用户。重要价值用户(R高F高M高)维护:用户处于购买活跃期,感兴趣的商品多,购买次数也多 → 针对兴趣产品,保持一定频率的触达,持续维护。

m0_74091312的博客 1421

顺序表的操作合集

顺序表的操作合集。

sunres的博客 143

二手分析仪器改造实战:如何用PMT搭建荧光检测电路(附完整电路图)

本文详细介绍了如何利用二手分析仪器中的光电倍增管(PMT)核心部件,进行荧光检测电路的实战改造。内容涵盖从PMT工作原理理解、高压供电电路设计、低噪声前置放大(跨阻放大器)到信号调理的完整流程,并提供了关键电路图与调试排错指南,旨在帮助电子爱好者与工程师低成本构建稳定、高灵敏度的专业检测系统。

weixin_29234239的博客 441

基于Java+Maven+Testng+RestAssured+Allure+Jenkins搭建一个接口自动化框架

2、有一个提取表达式列,通过编写每个接口的JSON提取表达式,后边在解析Excel时,对接口执行后的响应数据用该表达式提取出来,保存到环境变量,如果某些接口需要前置接口的响应数据,我们就可以从环境变量中获取该数据出来,从而解决了接口关联的问题。1、在之前介绍过全局配置类Contants中添加一个控制台日志开关控制权限,如果选择为false,则控制台不输出日志,将日志输出到allure报表,选择为true,则在控制台输出日志,不输出到allure报表。

专注于技术分享的博主 1186

顺序表表示集合的操作

/*【问题描述】 本题要求定义并实现一个用于存放整型数据的集合,编程实现集合的各种操作并在main函数中测试。 【基本要求】 实现集合的以下操作: (1)增加一个数到集合中; //完成 (2)从集合中去掉一个元素; //完成 (3)判断一个元素是否在集合中; //完成 (4)实现两个集合的并运算; (5)实现两个...

yucan1234的博客 1529

DeepSeek安装教程

两分钟讲述deepseek正确安装教程

weixin_45906703的博客 1666

顺序表集合的交并差操作

用顺序表表示集合,设计一个算法实现集合的求交集运算 void Intersection(SqList A,SqList B,SqList &C) { int i,j,k; //k记录C中的元素个数 for(i=0; i<A.length; i++) //用i遍历顺序表A { j=0; while(j<B.length&&B.data[j]!=A.da

小宋的博客 7016

NVIDIA Isaac GR00T N1 人形机器人强化学习入门教程(二)详细步骤

LeRobot 格式 1.1 加载数据集 要加载数据集,我们需要定义以下 3 项内容: 在数据中显示图像帧 我们还可以对 LeRobotSingleDataset 类中的数据进行一系列转换。下面展示了如何对数据进行转换。 现在看看应用转换后的数据有何不同。 例如,对状态和操作进行规范化和串联,对视频图像进行裁剪、调整大小和颜色抖动。 二、GR00T 推断 本教程介绍如何使用 GR00

2506_90492529的博客 3014

计算机组成原理(第三版)唐朔飞-第六章计算机的运算方法-课后习题(17-32)

计算机组成原理(第三版)唐朔飞-第六章计算机的运算方法-课后习题(17-32)

weixin_45735391的博客 12万+

实验1用顺序表完成集合的交差并补操作

(1)集合的元素限定为小写字母字符(a'.z),集合输入的形式为一个以“回车符”为结束标志的字符串,串中字符顺序不限,且允许出现重复字符或非法字符,程序应能自动滤去。(2)演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”后,由用户在键盘上输入演示程序中规定的运算命令,相应的输入数据(滤去输入中的非法字符)和运算结果显示在其后。数据关系:R1={|ai−1,ai∈D,ai−1≤ai,i=1,2,…操作结果:生成一个由S1 和S2 的并集构成的集合T。

m0_74216612的博客 1097

docker命令_获取镜像,创建容器,启动容器,进入容器,退出容器,停止容器,删除容器,列出镜像,删除镜像

1.数据准备

C/C++、嵌入式开发、深度学习算法、模型部署与推理优化 1084

C++实现顺序表两个集合的并交差集

给定两个顺序表(代表两个不同的集合),利用顺序表的基本操作实现这两个集合的并集,交集,差集。

henry594xiaoli的博客 9379

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

c语言顺序表错误,求改正C语言错误,假设两个顺序表La和Lb分别表示两个集合A和B,利用 union_Sq操作实现A=A∪B。用C语言写...

求改正C语言错误,假设两个顺序表La和Lb分别表示两个集合A和B,利用union_Sq操作实现A=A∪B。用C语言写0#include#include#include"malloc.h"#defineTRUE1#defineFALSE0#defineOVERFLOW-2#defineLIST_SIZE100/*runthisprogramusingtheconsolepauseroraddyou...

weixin_32205867的博客 735

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

顺序表的基本操作(c++实现)

(1)编程实现顺序表的基本操作:建立顺序表,修改顺序表,插入顺序表,删除顺序表; (2)采用顺序表结构编程实现:两个集合的运算:交集/并集/差集。 /* (1) */ #include <iostream> #define MAXSIZE 100 typedef struct{ int *elem; int length; }Sqlist; void InitList(...

路漫漫小菜狗的博客 2323

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

实验一 顺序表的操作(数据结构实验)

以下为实验内容: 1.实验性质:设计性实验 2.要求: 编程实现顺序表的以下基本操作:建立顺序表,修改顺序表,插入顺序表,删除顺序表。 采用顺序表结构编程实现:两个集合的运算:交集/并集/差集。 3.实验目的 通过该实验,深入理解顺序表的逻辑结构、物理结构等概念,掌握顺序表基本操作的编程实现,注意顺序表插入、删除等操作过程中数据元素的移动现象,学生编写程序时,要考虑程序的健壮性,熟练掌握...

qq_41998273的博客 1万+

数据结构-顺序表的操作

数据结构-顺序表的操作

梅川酷酷的博客 353

2024/3/15顺序表的应用:求两个集合的并交差集

按照惯例,再次欢迎大家边听歌边看本博客。

打铁还需自身硬 636

顺序表操作集合(初始化 创建 插入 删除 清空 销毁等)

代码如下: 其中case 7 8 9的scanf函数中%号前均有空白,详细原因参考两次调用scanf函数的问题 若有错误和可以改进的地方,敬请评论区指正。 #include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<string.h> #define LIST_INIT_SIZE 100 #define LIST_INCREMENT 10 #define OVERFLOW -2 #def

xueoyet的博客 404

顺序表实现交集,并集,差集

#include <stdio.h> #define MAXSIZE 30 typedef int datatype; typedef struct { datatype data[MAXSIZE]; int last; }SeqList; //实现集合的并 void Union(SeqList A,SeqList B,SeqList *C){ int i=0,j=0,k=0; while(i<=A.last&&j<=B.last) { if(A

edceee的博客 4200
上一篇: switch语句
下一篇: C编程的细节(3)
Learning_zhang
博客等级 码龄10年 16粉丝 71原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值