线性表的应用——线性表的合并

最新推荐文章于 2025-03-22 23:03:47 发布
最新推荐文章于 2025-03-22 23:03:47 发布
阅读量3.7k 收藏 45
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ning_meng_nn/article/details/124189014
版权
本文介绍了两种线性表合并的算法，一种是顺序线性表的合并，另一种是单链表表示的顺序表合并。这两种算法的时间复杂度都是O(length(la)*length(lb))。此外，还提供了完整的C++代码实现，包括线性表的基本操作如初始化、插入、删除等。最后，给出了有序表的合并方法，通过比较元素大小进行有序合并。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线性表的合并

初始条件：线性表la和lb
算法：
依次从lb中取出元素，查看是否存在la中，不存在则插入
顺序线性表的实现：

//线性表的合并
void unionList(SqList* &la,SqList* &lb){
    //从一个表中获取元素，再和另一个表中的数据进行比较
    int lena,lenb;
    lena=GetLength(la);
    lenb=GetLength(lb);
    for(int i=1;i<=lena;i++){
        ElemType e;
        GetElem(la,i,e);
        if(!LocateElem(lb,e)){
            ListInsert(lb,++lenb,e);
        }
    }
}

单链表表示的顺序表合并：

//线性表的合并，排除相同元素
void unionLink(LinkList &la,LinkList &lb){
    Lnode *pa,*pb;
    pa=la;
    pb=lb;
    int lena;
    getLinkLength(la,lena);
    int lenb;
    getLinkLength(lb,lenb);
    ElemType r;
    //从一个里面拿出数据，看一下另一个里面是否含有该数据
    for(int i=1;i<=lenb;i++){
        getElemI(lb,i,r);//得到数据r
        if(!LocteElemE(la,r)){
            insertLink(la,++lena,r);
        }
    }
}

算法的时间复杂度都是一样的：O（length(la)*length(lb)）
完整代码：

#include <iostream>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define MAXSIZE 100
using namespace std;
typedef int Status;//返回值类型
typedef char ElemType;//状态
typedef struct
{
    ElemType elem[MAXSIZE];//对应方式二初始化
    //ElemType* elem;对应方式一初始化
    int length;
}SqList;
Status InitList2(SqList* &L){//改变形参中的内容并且使用它则需要用引用，解析：https://blog.youkuaiyun.com/eye123456789/article/details/79794461
    //L.elem = (ElemType *)malloc(MAXSIZE * sizeof(ElemType));
    L=(SqList*)malloc(sizeof(SqList));//(SqList *)表示把这个指针转型为SqlList结构的指针
    //L=new SqList;也可以实现
    if(!L->elem){exit(OVERFLOW);}
    L->length=0;
    return OK;
}
Status InitList(SqList &L){
    //L.elem = (ElemType *)malloc(MAXSIZE * sizeof(ElemType));
    //L.elem=new ElemType[MAXSIZE];
    //开辟一个存储空间，并把这块存储空间的基地址赋值给elem
    if(!L.elem){exit(OVERFLOW);}
    L.length=0;
    return OK;
}
void DestoryList(SqList* &L){
    //注意malloc用free，new用delete
    if(L) free(L);
        //delete L;

}
void ClearList(SqList* &L){
    L->length=0;
}
int GetLength(SqList* L){
    return L->length;
}
int IsEmpty(SqList* L){
    if(L->length==0) return 1;
    else return 0;
}
//取线性表中i号元素
int GetElem(SqList* L,int i,ElemType &e){
    if(i<1||i>L->length) return ERROR;
    e=L->elem[i-1];
    return OK;
}
//查找算法
int LocateElem(SqList* L,ElemType &e){
    for(int i=0;i<L->length;i++){
        if(L->elem[i]==e){
            return ++i;
        }
    }
    return 0;

}
Status AddElem(SqList* &L,ElemType e){
    if(L->length==MAXSIZE) return ERROR;
    L->elem[L->length++]=e;
    return OK;
}

Status ListInsert(SqList* &L,int i,ElemType e){
    if(i<1||i>(L->length+1)){
        return ERROR;
    }
    if(L->length==MAXSIZE) return ERROR;
    for(int j=L->length-1;j>=i-1;j--){
        L->elem[j+1]=L->elem[j];
    }
    L->elem[i-1]=e;
    L->length++;
    return OK;
}

void selectList(SqList* L){
    for(int i=0;i<L->length;i++){
        printf("%c ",L->elem[i]);
    }
}

Status ListDelete(SqList* &L,int i,ElemType &e){
    if(i<1||i>L->length) return ERROR;
    e=L->elem[i-1];
    for(int j=i-1;j<L->length;j++){
        L->elem[j]=L->elem[j+1];
    }
    L->length--;
    return OK;
}
//线性表的合并
void unionList(SqList* &la,SqList* &lb){
    //从一个表中获取元素，再和另一个表中的数据进行比较
    int lena,lenb;
    lena=GetLength(la);
    lenb=GetLength(lb);
    for(int i=1;i<=lena;i++){
        ElemType e;
        GetElem(la,i,e);
        if(!LocateElem(lb,e)){
            ListInsert(lb,++lenb,e);
        }
    }
}

//有序表的合并——顺序实现
SqList* mergeList(SqList* &la,SqList* &lb){
    SqList* lc;
    InitList2(lc);
    int lena,lenb,pa_last=0,pb_last=0;
    lena=la->length;
    lenb=lb->length;
    while(pa_last<lena&&pb_last<lenb){
        if(la->elem[pa_last]<lb->elem[pb_last]){
            lc->elem[lc->length++]=la->elem[pa_last++];
        }else{
            lc->elem[lc->length++]=lb->elem[pb_last++];
        }
    }
    while(pa_last<lena){
        lc->elem[lc->length++]=la->elem[pa_last++];
    }
    while(pb_last<lenb){
        lc->elem[lc->length++]=lb->elem[pb_last++];
    }
    return lc;
}


int main()
{
    SqList* L;
    InitList2(L);
    //printf("长度为：%d",L->length);
    ElemType e='a';
    AddElem(L,e);
    AddElem(L,'c');
    AddElem(L,'d');
    AddElem(L,'f');
    selectList(L);
    printf("\n===============\n");

    SqList* Lb;
    InitList2(Lb);
    //printf("长度为：%d",L->length);
    AddElem(Lb,e);
    AddElem(Lb,'e');
    AddElem(Lb,'f');
    AddElem(Lb,'g');
    selectList(Lb);
    printf("\n===============\n");
    //unionList(L,Lb);
    SqList* lc=mergeList(L,Lb);
    selectList(lc);
    printf("\n===============\n");
    //selectList(L);
    //printf("\n");
    //ListInsert(L,2,'b');
    //ElemType r;
   // ListDelete(L,4,r);
   // selectList(L);
   // printf("\n被删除元素为：%c",r);
    //ElemType r;
    //GetElem(L,1,r);
    //printf("a:%c\n",r);
    //printf("%d",LocateElem(L,e));
    //printf("%d",IsEmpty(L));

    return 0;
}

链表实现的完整代码：

#include <iostream>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define MAXSIZE 100
using namespace std;
typedef int Status;//返回值类型
typedef char ElemType;//数据类型
using namespace std;
typedef struct Lnode{
    ElemType data;
    Lnode* next;
}Lnode,*LinkList;
//带头结点链表初始化
//1.将链表指向头结点，并且头结点的下一个指向为空
Status initList(LinkList &L){
    //Lnode L=new Lnode;//c++语法用delete销毁，c的语法为；用free销毁
    L=(LinkList)malloc(sizeof(Lnode));
    L->next=nullptr;
    return OK;
}
//判断链表是否为空
int isEmpty(LinkList L){
    if(L->next!=nullptr) return 0;
    else return 1;
}
//销毁单链表
void destoryLink(LinkList &L){
    LinkList p;
    //注意点：L->next=null时是最后一个节点，不是循环结束的条件
    //循环结束的条件为L=null；
    //while(L!=nullptr){
     //   p=L;
     //   L=L->next;
     //   free(p);
    //}
    //或者
    p=L;
    //这里的循环结束的条件为L=null或者p=null
    while(p){
        L=L->next;
        free(p);
        p=L;
    }
}
//清空链表（头结点保存，从首元结点开始删除）
Status clearLink(LinkList &L){

    LinkList pre,cur;
   // if(L->next!=nullptr){
    //    pre=L->next;
    //    cur=pre->next;
    //    while(cur){
     //       free(pre);
     //       pre=cur;
     //       cur=cur->next;
      //  }
      //}
    pre=L->next;
    while(pre){
        cur=pre->next;
        free(pre);
        pre=cur;
    }
    L->next=nullptr;//头结点的指针域设置为空
    return OK;
}
//求单链表的表长
void getLinkLength(LinkList L,int &len){
    LinkList p;
    p=L->next;
    len=0;//设置初值
    while(p!=nullptr){
        len++;
        p=p->next;
    }
}
//取第i个元素值
Status getElemI(LinkList &L,int i,ElemType &e){
    int index=1;
    Lnode* p;
    p=L->next;//首元结点，所以index从1开始
    //如果一开始j>i说明要找的位置i比1小，是非法的
    while(p&&index<i){
        p=p->next;
        index++;
    }
    if(!p||index>i) return ERROR;
    e=p->data;
    return ERROR;
}
//按值查找，返回地址
Lnode*  LocteElemE(LinkList L,ElemType e){
    Lnode* p;
    p=L->next;
    while(p&&p->data!=e){
        p=p->next;
    }
    return p;
}
//按值查找，返回在第几个
int LocateElemE2(LinkList L,ElemType e){
    int i=1;
    Lnode* p;
    p=L->next;
    while(p&&p->data!=e){
        p=p->next;
        i++;
    }
    if(p==nullptr) return 0;
    else return i;
}
Status insertLink(LinkList &L,int i,ElemType e){
   Lnode* p=L;
   int index=0;
   while(p&&index<(i-1)){
        p=p->next;
        index++;
   }
   if(!p||index>i-1){//!p说明大于表长+1；index>i-1说明小于1
        return ERROR;
   }else{
       Lnode* s=(LinkList)malloc(sizeof(Lnode));
       s->data=e;
       s->next=p->next;
       p->next=s;
       return OK;
   }
}

Status deleteLink(LinkList &L,int i,ElemType &e){
    int index=0;
    Lnode* p;
    p=L;
    //或者需要用中间变量存储p->next
    //Lnode* q;
    while(p&&index<(i-1)){//index=i-1或者p为空的时候跳出循环
        p=p->next;
        index++;
    }
    if(p||index>(i-1)){
        return ERROR;
    }else{
        //q=p->next;
        //p->next=q->next;
        //e=q->data;
        e=p->next->data;
        p->next=p->next->next;
        return OK;
    }

}
//头插法
void headInsert(LinkList &L,ElemType e){
    Lnode* p=(LinkList)malloc(sizeof(Lnode));
    //或者用户输入这个元素的值
    //cin>>e;
    //scanf(e);
    p->data=e;
    p->next=L->next;//原来的接在新节点的后面
    L->next=p;//新节点接在头结点的后面
}
//尾插法
void tailInsert(LinkList &L,int n){

    Lnode* tail;
    tail=L;//指向头结点
    while(n!=0){
        Lnode* p=new Lnode;//记得每次都要开辟一块空间，否则输入会产生错误
        cin>>p->data;
        p->next=nullptr;//新指针的下一个指针域设置为空
        tail->next=p;//把尾指针的下一个指向当前的新指针
        tail=p;//移动尾指针的位置
        n--;//减少
    }
}

//遍历链表
void selectLink(LinkList L){
    Lnode* p;
    p=L->next;
    if(p==nullptr){
        printf("这个链表是空的！");
    }
    while(p!=nullptr){
        printf("p->data: %c\n",p->data);
        p=p->next;
    }
}
//线性表的合并，排除相同元素
void unionLink(LinkList &la,LinkList &lb){
    Lnode *pa,*pb;
    pa=la;
    pb=lb;
    int lena;
    getLinkLength(la,lena);
    int lenb;
    getLinkLength(lb,lenb);
    ElemType r;
    //从一个里面拿出数据，看一下另一个里面是否含有该数据
    for(int i=1;i<=lenb;i++){
        getElemI(lb,i,r);//得到数据r
        if(!LocteElemE(la,r)){
            insertLink(la,++lena,r);
        }
    }
}
//有序表的合并
void mergeLink(LinkList &la,LinkList &lb){
    Lnode* lc,*pa,*pb,*pc;
    lc=la;
    pc=lc;
    pa=la->next;
    pb=lb->next;
    while(pa!=nullptr&&pb!=nullptr){
        if(pa->data>=pb->data){
            pc->next=pb;
            pb=pb->next;
            pc=pc->next;
        }else{
            pc->next=pa;
            pa=pa->next;
            pc=pc->next;
        }
    }
    pc->next=pa?pa:pb;//三目运算符
    delete lb;
}

int main()
{
    //LinkList L;
    //initList(L);
    //ElemType elem[5]={'a','b','c','d','e'};
    //for(int i=4;i>=0;i--){
    //    headInsert(L,elem[i]);
    //}
    //tailInsert(L,5);
    //selectLink(L);
    //insertLink(L,6,'f');
    //printf("插入后：\n");
    //ElemType result;
   // getElemI(L,5,result);
    //printf("取出第5个元素的值为%c\n",result);
    //Lnode* p=LocteElemE(L,'a');
    //printf("按值查找返回地址：%c\n",p->data);
    //int i=LocateElemE2(L,'a');
   // printf("按值查找返回第几个: %d\n",i);
   // selectLink(L);
    //int len;
    //getLinkLength(L,len);
    //printf("链表长度:%d\n",len);
    //==========================下面测试线性表的合并
    LinkList la,lb;
    initList(la);
    initList(lb);
    tailInsert(la,5);
    selectLink(la);
    tailInsert(lb,5);
    selectLink(lb);
    //unionLink(la,lb);
    //printf("======合并后数据=======\n");
    //selectLink(la);
    mergeLink(la,lb);
    printf("========有序表的合并======\n");
    selectLink(la);
    return 0;
}
数据结构 线性表的应用——经典题目分析
ZY-JIMMY
12-27 1490
目录 1、逆置单链表 2、反转单链表 3、合并两个有序的单链表 4、判断单链表是否有环？环的入口点？环的长度？ 5、判断两个单链表是否相交？交点？ 6、O(1)时间删除单链表的一个节点 7、最快时间内找到单链表倒数第K个节点？ 8、最快时间内删除单链表倒数第K个节点？ 9、 求两个顺序表的交集、并集和差集 10、求两个有序单链表的交集、并集和差集 11、求两个单链表(可以无...
合并两个已排序的线性表——顺序表
Lydia_r的博客
05-30 7697
写一个算法合并两个已排序的线性表。（用两种方法：数组表示的线性表（顺序表）和指针表示的线性表（链表））       要求：1、定义线性表节点的结构，并定义节点的型和位置的型。             2、定义线性表的基本操作          3、在1，2的基础上，完成本题。         4、在main函数中进行测试：先构建两个有序的线性表，然后合并这两个线性表。#include &lt;st...
[数据结构]线性表合并
weixin_34218890的博客
02-09 4121
一、问题描述 线性表合并是程序设计语言编译中的一个最基本的问题，现在有两个线性表LA和LB，其中的元素都是按照非递减有序排列的，要将两个LA和LB归并为一个新的线性表LC，使得LC中的元素仍然是非递减有序的。 本实验的合并方式有两种。第一种是分别取LA和LB的第一个元素，即各自的最小的元素进行比较，选择较小的元素加入LC尾部，然后重复以上步骤；当LA表空了或者LB表空了的时候，将另一个表剩下的...
线性表的合并
sunjiangangok的博客
04-10 1190
好久都没有用c语言写程序了，对于c语言都有些生疏了～在暑期最后这十几天内，把数据结构好好复习一下吧，今天静下心来，慢慢复习数据结构时候，发现自己长时间没有编写程序了，竟然编写一个简单的线性表的合并花费的2个多小时，唉，看来程序还是要坚持写的，不能放下～题目要求：有两个线性表a和b，这两个线性表都是非递减有序排列，现在要把这两个线性表合并为一个非递减有序排列的c线性表。算法思想：用i，j，k这3个指
线性表的合并---链表实现
最新发布
在csdn分享更多技术知识，相互交流
03-22 95
【代码】线性表的合并---链表实现。
线性表合并
weixin_44594976的博客
03-28 769
#include<stdio.h> #include<malloc.h> #define SIZE 10 typedef struct list{ int*elem; int length; int size; }List; List InitList() { List t; t.elem=(int*)malloc(SIZE*sizeof(int)); i...
数据结构 （8）线性表的应用——一元多项式的表示及应用
m0_73399576的博客
11-24 1084
数据结构——线性表的应用——一元多项式的表示及应用篇
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
文档中还提供了一些运行结果的例子，包括基本操作的验证和两个有序线性表合并成一个有序表的操作演示。这有助于读者更好地理解代码的实际运行效果，并可以用来验证自己的实现是否正确。 #### 五、注意事项 1. **...
数据结构——“线性表的应用举例“ 深度分析学完线性表工作中应用在哪？
weixin_44278698的博客
04-28 5267
线性表的应用举例引言应用举例应用一：多项式的处理应用二：Joseph问题（约瑟夫算法）joseph代码示例： 引言 我们前面学习了线性表的顺序存储，顺序表的链式存储，但是在实际运用过程中我们该如何应用呢？ 应用举例 应用一：多项式的处理 多项式表示 与 相加: 设一元n次多项式: 它的n+1个系数可形成一个线性表:p(p0，p1，… ，pn)，而x的指数i(0 ≤i ≤ n)对应系数 pi 的序号。无疑Pn(x)中有许多系数为0的项，如: 我们看个多项式的案例： 对于这样繁琐的多项式合并计算，如果多
线性表的合并（单链表）
qq_40724550的博客
09-05 1665
语言：c++ 问题： 求解一般集合的合并【问题描述】 已知两个集合A和B，现 要求一个新的集合A=AUB。例如，设 A=（7，5，3，11） B=（2，6，3） 合并后 A=（7，5，3，11，2，6）【分析】 首先了解集合的特点，集合中元素不重复。可以利用两个线性表LA和LB分别表示集合A和B。将LB中的待合并元素与LA中每个元素比较，如果LB中的待合并元素在LA中存在，LB中的待合并元素不要并...
线性表的合并（链表实现）
Bit_Dong的博客
06-06 2043
上节中已对线性表合并的顺序表实现进行了详细的介绍，本节再以链表实现合并进行代码示例。
线性表应用2——一元多项式加法运算，要求采用链式存储结构实现，其中对链表的建立、合并和结果输出用自定义函数完成。
09-24
接下来，我们需要链表操作函数，用于插入节点、合并链表以及输出链表： ```c // 插入节点到链表尾部的函数 void insert_to_list(Term** head, Term* term) { if (*head == NULL) { *head = term; } else { Term...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

菜菜iwi

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

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

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

打赏作者

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

抵扣说明：

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

余额充值