线性表链式存储结构及实现

最新推荐文章于 2022-03-23 11:32:00 发布
最新推荐文章于 2022-03-23 11:32:00 发布
阅读量2.3k 收藏 16
点赞数 5
分类专栏： 循环双链表 单链表合并 文章标签： 循环双链表 单链表合并 C语言 C++ 数据结构

一、目的

  1. 掌握线性表的脸是存储结构及运算
  2. 熟悉循环链表及双链表线性表的基本运算

二、内容

  1. 编写一个程序cdlinklist.cpp,实现循环双链表的各种基本运算和整体建表算法（假设循环双链表的元素类型ElemType为char），并在此基础上设计一个主程序，完成如下功能：
    （1）初始化循环双链表h
    （2）依次采用尾插法插入a,b,c,d,e元素
    （3）输出循环双链表h
    （4）输出循环双链表h长度
    （5）判断顺序表h是否为空
    （6）输出循环双链表h的第3个元素
    （7）输出元素a的位置
    （8）在第4个元素位置上插入f元素
    （9）输出循环双链表h
    （10）删除循环双链表h的第3个元素
    （11）输出循环双链表h
    （12）释放循环双链表h
  2. 编写一个程序exe2-7.cpp,实现这样的功能：令L1=(x1,x2,…，xn)，L2=（y1，y2，…，ym）是两个线性表，采用带头结点的单链表存储，设计一个算法合并L1、L2，结果放在线性表L3中，要求如下：

L3=（x1，y1，x2，y2，…，xm，ym，xm+1，…，xn）当m<=n时
L3=（x1，y1，x2，y2，…，xn，yn，yn+1，…，yn）当m>n时
L3仍采用单链表存储，算法的空间复杂度为O(1)。

三、源代码

  1. 循环双链表
#include<stdio.h>
#include<malloc.h>
typedef char ElemType;
typedef struct DNode
{
    ElemType data;
    struct DNode *prior;
    struct DNode *next;
}DLinkNode;
void CreateListF(DLinkNode *&L,ElemType a[],int n)
{
    DLinkNode *s;
    L=(DLinkNode *)malloc(sizeof(DLinkNode));
    L->next=NULL;
    for(int i=0;i<n;i++)
    {
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        s->data=a[i];
        s->next=L->next;
        if(L->next!=NULL) L->next->prior=s;
        L->next=s;s->prior=L;
    }
    s=L->next;
    while(s->next!=NULL)
        s=s->next;
    s->next=L;
    L->prior=s;
}
void CreateListR(DLinkNode *&L,ElemType a[],int n)
{
    DLinkNode *s,*r;
    L=(DLinkNode *)malloc(sizeof(DLinkNode));
    r=L;
    for(int i=0;i<n;i++)
    {
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        s->data=a[i];
        r->next=s;s->prior=r;
        r=s;
    }
    r->next=L;
    L->prior=r;
}
void InitList(DLinkNode *&L)
{
    L=(DLinkNode *)malloc(sizeof(DLinkNode));
    L->prior=L->next=L;
}
void DestroyList(DLinkNode *&L)
{
    DLinkNode *pre=L,*p=L->next;
    while(p!=L)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
}
bool ListEmpty(DLinkNode *L)
{
    return(L->next==L);
}
int ListLength(DLinkNode *L)
{
    int i=0;
    DLinkNode *p=L;
    while(p->next!=L)
    {
        i++;
        p=p->next;
    }
    return(i);
}
void DispList(DLinkNode *L)
{
    DLinkNode *p=L->next;
    while(p!=L)
    {
        printf("%c ",p->data);
        p=p->next;
    }
    printf("\n");
}
bool GetElem(DLinkNode *L,int i,ElemType &e)
{
    int j=1;
    DLinkNode *p=L->next;
    if(i<=0||L->next==L)
        return false;
    if(i==1)
    {
        e=L->next->data;
        return true;
    }
    else
    {
        while(j<i&&p!=L)
        {
            j++;
            p=p->next;
        }
        if(p==NULL)
            return false;
        else
        {
            e=p->data;
            return true;
        }
    }
}
int LocateElem(DLinkNode *L,ElemType e)
{
    int i=1;
    DLinkNode *p=L->next;
    while(p!=L&&p->data!=e)
    {
        i++;
        p=p->next;
    }
    if(p==L)
        return 0;
    else
        return i;
}
bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
    DLinkNode *p=L,*s;
    int j=1;
    if(i<=0)return false;
    if(p->next==NULL||i==1)
    {
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        s->data=e;
        p->next=s;s->next=p;
        p->prior=s;s->prior=p;
        return true;
    }
    else if (i==1)
    {
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        s->data=e;
        s->next=p->next;p->next=s;
        s->next->prior=s;s->prior=p;
        return true;
    }
    else
    {
        p=L->next;
        while(j<i-2&&p!=L)
        {
            j++;
            p=p->next;
        }
        if(p==L)
            return false;
        else
        {
            s=(DLinkNode *)malloc(sizeof(DLinkNode));
            s->data=e;
            s->next=p->next;
            if(p->next!=NULL)p->next->prior=s;
            s->prior=s;
            p->next=s;
            return true;
        }
    }

}
bool ListDelete(DLinkNode *&L,int i,ElemType &e)
{
    DLinkNode *p=L,*q;
    int j=1;
    if(i<=0||L->next==L)
        return false;
    if(i==1)
    {
        q=L->next;
        e=q->data;
        L->next=q->next;
        q->next->prior=L;
        free(q);
        return true;
    }
    else
    {
        p=L->next;
        while(j<=i-2&&p!=L)
        {
            j++;
            p=p->next;
        }
        if(p==L)
            return false;
        else
        {
            q=p->next;
            if(q==NULL)return 0;
            e=q->data;
            p->next=q->next;
            if(p->next!=NULL)p->next->prior=p;
            free(q);
            return true;
        }
    }
}
int main()
{
    DLinkNode *h;
    ElemType e;
    printf("循环双链表的基本运算如下：\n");
    printf("    (1)初始化循环双链表h\n");
    InitList(h);
    printf("    (2)依次插入a、b、c、d、e元素\n");
    ListInsert(h,1,'a');
    ListInsert(h,2,'b');
    ListInsert(h,3,'c');
    ListInsert(h,4,'d');
    ListInsert(h,5,'e');
    printf("    (3)输出循环双链表h:");
    DispList(h);
    printf("    (4)循环双链表h长度：%d\n",ListLength(h));
    printf("    (5)循环双链表h为%s\n",(ListEmpty(h)?"空":"非空"));
    GetElem(h,3,e);
    printf("    (6)循环双链表h的第3个元素:%c\n",e);
    printf("    (7)元素a的位置:%d\n",LocateElem(h,'a'));
    printf("    (8)在第4个元素位置上插入f元素\n");
    ListInsert(h,4,'f');
    printf("    (9)输出循环双链表h：");DispList(h);
    printf("    (10)删除h的第3个元素\n");
    ListDelete(h,3,e);
    printf("    (11)输出循环双链表h：");DispList(h);
    printf("    (12)释放循环双链表h\n");
    DestroyList(h);
    return 0;
}
  1. 单链表合并
#include<stdio.h>
#include<malloc.h>
typedef char ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LinkNode;
void CreateListF(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s;
    L=(LinkNode *)malloc(sizeof(LinkNode));
    L->next=NULL;
    for(int i=0;i<n;i++)
    {
        s=(LinkNode *)malloc(sizeof(LinkNode));
        s->data=a[i];
        s->next=L->next;
        L->next=s;
    }
}
void CreateListR(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    L=(LinkNode *)malloc(sizeof(LinkNode));
    r=L;
    for(int i=0;i<n;i++)
    {
        s=(LinkNode *)malloc(sizeof(LinkNode));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}
void InitList(LinkNode *&L)
{
    L=(LinkNode *)malloc(sizeof(LinkNode));
    L->next=NULL;
}
void DestroyList(LinkNode *&L)
{
    LinkNode *pre=L,*p=L->next;
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=p->next;
    }
    free(p);
}
bool ListEmpty(LinkNode *L)
{
    return(L->next==NULL);
}
int ListLength(LinkNode *L)
{
    int i=0;
    LinkNode *p=L;
    while(p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return(i);
}
void DispList(LinkNode *L)
{
    LinkNode *p=L->next;
    while(p!=NULL)
    {
        printf("%c ",p->data);
        p=p->next;
    }
    printf("\n");
}
bool GetElem(LinkNode *L,int i,ElemType &e)
{
    int j=0;
    LinkNode *p=L;
    if(i<=0)return false;
    while(j<i&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        e=p->data;
        return true;
    }
}
int LocateElem(LinkNode *L,ElemType e)
{
    int i=1;
    LinkNode *p=L;
    while(p!=NULL&&p->data!=e)
    {
        i++;
        p=p->next;
    }
    if(p==NULL)
        return 0;
    else
        return i;
}
bool ListInsert(LinkNode *&L,int i,ElemType e)
{
    LinkNode *p=L,*s;
    int j=0;
    if(i<=0)return false;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        s=(LinkNode *)malloc(sizeof(LinkNode));
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }
}
bool ListDelete(LinkNode *&L,int i,ElemType &e)
{
    LinkNode *p=L,*q;
    int j=0;
    if(i<=0)return false;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        q=p->next;
        if(q==NULL)
            return false;
        e=p->next->data;
        p->next=q->next;
        free(q);
        return true;
    }
}
void Merge(LinkNode *L1,LinkNode *L2,LinkNode *&L3)
{
    LinkNode *p=L1->next,*q=L2->next,*r;
    L3=L1;
    r=L3;
    free(L2);
    while(p!=NULL&&q!=NULL)
    {
        r->next=p;r=p;p=p->next;
        r->next=q;r=q;q=q->next;
    }
    r->next=NULL;
    if(q!=NULL)p=q;
    r->next=p;
}
int main()
{
    LinkNode *L1,*L2,*L3;
    ElemType a[]="abcdefgh";
    int n=8;
    CreateListR(L1,a,n);
    printf("L1:");DispList(L1);
    ElemType b[]="12345";
    n=5;
    CreateListR(L2,b,n);
    printf("L2:");DispList(L2);
    printf("L1和L2合并产生L3\n");
    Merge(L1,L2,L3);
    printf("L3:");DispList(L3);
    DestroyList(L3);
    return 0;
}

备注：
有问题可以评论，看到后我会尽力及时回复的，谢谢！

ID：1024
关注
  • 5
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
将L1,L2采用带头结点的单链表存储，设计一个算法合并L1,L2，结果放在单链表L3中.要求：L3中L1,L2元素交叉存储(尾插法），且算法的空间复杂度为O（1）
yyy_zxc的博客
11-14 1582
#include "LinkList.cpp" //导入基础算法文件单链表的基本运算算法_yyy_zxc的博客-CSDN博客_单链表的基本运算算法//----------实现单链表的各种基本运算的算法-----------------// #include是编译预处理指令 .h是头文件，头文件是包含函数声明和定义的文件；#include <stdio.h> //包含关于C程序的输入输出的各种信息 stdlib.h#include <stdlib.h>#include <mal
单链表-两个线性表的合并1（破环原链表+尾插法）
muyu_muyu的博客
12-21 1219
题意： 令L1 = (X1,X2,X3,X4…Xn), L2 = (y1,y2,y3,y4…ym);是两个线性表。采用带头节点的链表存储，设计一个算法合并L1,L2，结果放在线性表L3中，要求如下： L3 = (X1,Y1,X2,Y2,X3,Y3,…XmYm,Xm+1,…Xn) 当m<= n L3 = (X1,Y1,X2,Y2,X3,Y3,…XnYn,Yn+1,…Ym) 当n<= m L3采用单链表存储。 单链表的存储结构： typedef struct LinkList{ in
王道数据结构2022-线性表的链式表示-综合题(p41)-11设C={a1,b1,a2,b2,...,an,bn}为线性表,采用带头结点的hc单链表存放, 设计一个就地算法,将其拆分为两个线性表, 使
好奇独角兽
08-29 1578
设C={a1,b1,a2,b2,…,an,bn}为线性表,采用带头结点的hc单链表存放,设计一个就地算法,将其拆分为两个线性表,使得A={a1,a2,…,an},B={bn,…b1} #include<stdio.h> #include<stdlib.h> typedef struct LNode { //定义单链表结点类型 int data;//数据域 struct LNode *next;//指针域 } LNode, *LinkList; /*设C={a1,b1,a2,b
单链表-两个线性表的合并（不破坏原链表+尾插法）
muyu_muyu的博客
12-21 3368
题意： 令L1 = (X1,X2,X3,X4…Xn), L2 = (y1,y2,y3,y4…ym);是两个线性表。采用带头节点的链表存储，设计一个算法合并L1,L2，结果放在线性表L3中，要求如下： L3 = (X1,Y1,X2,Y2,X3,Y3,…XmYm,Xm+1,…Xn) 当m<= n L3 = (X1,Y1,X2,Y2,X3,Y3,…XnYn,Yn+1,…Ym) 当n<= m L3采用单链表存储。 单链表的存储结构： typedef struct LinkList{ in
单链表-单链表拆分为两个线性表（同序的）（尾插法+尾插法）
muyu_muyu的博客
12-19 2107
题意： 设C{a1,b1,a2.b2…an,bn}为一线性表，采用带头结点的单链表hc存放，设计一个就地算法，将其拆分为两个线性表，每个线性表均采用带头结点的单链表存储，使得： A = {a1,a2.a3.a4…an}, B = {b1,b2,b3.b4…bn} 单链表的存储结构： typedef struct LinkList{ int data; LinkList * next; } 分析： 这里的拆分线性表与拆分奇偶链表类似。 但是，但是这两者有啥不同呢？ 1
C++实现线性表链式存储（单链）
08-19
"C++实现线性表链式存储（单链）" 本文主要介绍了C++实现线性表链式存储的方法，包括了链表的定义、构造函数、插入结点、删除结点、查找结点等基本操作。下面是对该实现的详细分析： 一、链表的定义 在C++中，...
线性表链式存储
09-29
3. 结构灵活：可以通过增加额外的指针字段来实现更复杂的数据结构，如二叉链表、B树等。 然而，链式存储也有其缺点： 1. 访问效率：链表的元素访问速度较慢，因为无法像数组那样通过索引直接访问，必须从头节点开始...
线性表链式存储结构C语言实现
10-04
本主题主要关注的是链式存储结构在C语言中的实现。 链式存储结构与顺序存储不同，不依赖于内存中的连续空间来存储元素。每个元素（称为节点）包含两部分：数据域，用于存储数据；指针域，用于存储指向下一个节点的...
dm03_线性表链式存储设计与实现.zip_数据结构（C语言）
最新发布
09-23
在实际的`dm03_线性表链式存储设计与实现`项目中，上述操作会被实现为完整的C语言程序，包括主函数、头文件和源文件，可能还会包含错误处理和用户交互功能。这些代码将演示如何在C语言环境下实现一个功能完备的链式...
《数据结构》上机实验(第二章)——线性表 Ⅲ
Miss Z的博客
08-03 1993
1. L1=(x1,x2,…,xn),L2=(y1,y2,...,yn)L1=(x_1,x_2,…,x_n),L2=(y_1,y_2,...,y_n)L1=(x1​,x2​,…,xn​),L2=(y1​,y2​,...,yn​)，它们是两个线性表，采用带头结点的单链表存储，合并L1、L2，结果放在线性表L3中。 要求如下： L3=(x1,y1,x2,y2,...,xm,ym,xm+1,...,xn)                    m≤nL3=(x_1,y_1,x_2,y_2,...,x_m,y_m,
实现两个链表的合并
07-06
基本功能要求： （1）建立两个链表A和B 链表元素个数分别为m和n个 （2）假设元素分别为 x1 x2 …xm 和 y1 y2 …yn 把它们合并成一个线性表C 使得： 当m> n时 C x1 y1 x2 y2 …xn yn … xm 当n>m时 C y1 x1 y2 x2 …ym xm … yn 输出线性表C： （1） 用直接插入排序法对C进行升序排序 生成链表D 并输出链表D ">基本功能要求： （1）建立两个链表A和B 链表元素个数分别为m和n个 （2）假设元素分别为 x1 x2 …xm 和 y1 y2 …yn 把它们合并成一个线性表C 使得： 当m> n时 C x1 y1 x2 y2 …xn yn … xm 当n>m时 C y1 x1 y2 x2 …ym xm … yn [更多]
LinkList.cpp
06-25
数据结构链表基础内容，构建存储个人信息的表格。
实现循环单链表的各种基本运算的算法
04-17
数据结构与算法 李春葆 第五版实验报告2.22 含代码和结果
实现双链表各种基本运算的方法
xiezhi123456的博客
01-10 2409
#include &lt;stdio.h&gt; #include &lt;malloc.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct DNode {     ElemType data;     struct DNode *prior;//指向前驱结点     struct DNode *next;...
实现双链表各种基本运算的算法
yyy_zxc的博客
11-04 1447
//---------------实现双链表各种基本运算的算法----------- #include <stdio.h> #include<malloc.h> #define ElemType int //声明结点类型 typedef struct DNode{ ElemType data; struct DNode *prior; //指向前驱结点 struct DNode *next; //指向后继结点 }NLinkNode; /...
最近对问题
weixin_45728842的博客
06-20 533
问题 最近对问题要求在包含有n个点的集合S中，找出距离最近的两个点。设 p1(x1,y1)，p2(x2,y2)，……，pn(xn,yn)是平面的n个点。 2解析 1.按x坐标排列的n(n>=2)个点的集合S={(x1,y1),(x2,y2),…,(xn,yn)}， 2.如果n2，则返回（x1,y1）和（x2,y2）之间的距离，算法结束； 3.如果n3，则返回（x1,y1）、（x2,y2）和（x3,y3）之间的最小距离，算法结束； 4.划分：m==S中各点x坐标的中位数； 5.d1 = 计算{(x1,.
编写一个程序实现循环双链表的各种基本运算（假设顺序表的元数基本类型为Char）
张旺华的博客
07-01 4402
/* *Copyright (c) 2016, 烟台大学计算机学院 *All rights reserved. *文件名称：main.cpp *作者：张旺华 *完成日期： 2016 年 7 月 1 日 *版本号：v1.0 *问题描述：编写一个程序实现循环双链表的各种基本运算（假设顺序表的元数基本类型为Char） * */ #include #include #include
数据结构（C语言版)（第3版）实验三（答案）
qq_62804018的博客
03-23 3351
江西师范大学计算机信息工程学院学生实验报告 专业 计算机信息工程学院 姓名 钟宗谨 学号 202126202185日期 2022/3/21 课程名称 数据结构 实验室名称 实验名称 不带头结点的单链表 指导教师 万中英 成绩 实验目的 理解带头结点的单链表的...
单链表的各种操作
用可见的方式来记录和分享每一次收获
12-17 365
#include&lt;iostream&gt; #define _CRT_SECURE_NO_WARNINGS using namespace std; typedef int DATA; struct SNode //定义节点 { DATA data; SNode* pNext; }; class CList //创建一个链表类 { S...
线性表链式存储详解与实现
"数据结构(8).ppt是一个关于线性表的详细讲解，涵盖了线性表的顺序存储和链式存储结构，包括线性链表、循环链表以及字符串的操作。文档适合学习和参考，提供了线性表在链式存储结构上的建立、插入、删除、打印和查找...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值