数据结构与算法基础（王卓）（8）：线性表的应用

news2024/9/21 15:42:43

PPT：第二章P173；

并集集合：线性表的合并（无需有序，不能重复）

线性表：

Status Union(Sqlist& A, Sqlist& B)//并集
{
    int len_A = A.length;
    int len_B = B.length;
    for (int i = 1; i <= len_B; i++)
    {
        Poly e=*A.elem;
        //这里只是给我们设定的元素e赋一个任意初值
        //只要保证e在初始化时由初值不为空即可
        //至于该e元素的内容是什么其实并没有什么所谓
        //因为后面我们总归是会改的
        GetElem(B, i, e);
        if (LocateElem(A, e))
            return ERROR;
        else
            ListInsert(A, ++len_A, e);
        //注意插入函数中输入的是位序，不是数组下标
    }
    return true;
}

该算法的时间复杂度：O(ListLenth(La) * ListLengrh(Lb))

最后A表为合并以后的新表

链表：

Status Union(Lnode& A, Lnode& B)
{
    for (int i = 1; i <= 求表长(&B); i++)
    {
        int len_A = 求表长(&A);
        Elemtype e;
        取第i个元素(&A, i, e);
        if (!LocateELem(&B, e))
            Listlnsert(&A, ++len_A, e);
    }
    return true;
}

结果：（默认在（7）：小结：关于链表和线性表的定义及操作当中预设的前置语句之下运行） 

而产生该结果的原因，和前置语句中，定义插入函数的语句有关：

Status Listlnsert(LinkList& L, int i, Elemtype e)

更准确的来说：问题源于我们给出的 “&A”和定义中的“LinkList& L”类型匹配不上

想要程序能够正常运行，改动的方法有两种：

1：

修改<插入>函数的函数体：（此时<合并>函数无需修改）

把合并函数的“声明”（函数体之外）部分改为：

Status Listlnsert(LinkList L, int i, Elemtype e)

此时，该合并函数所需要的前置条件（最简单版本）为：

//链表的定义及其基础操作
#include<iostream>
using namespace std;
#include<stdlib.h>//存放exit

#define TRUE        1
#define FALSE       0
#define OK          1
#define ERROR       0
#define INFEASIBLE  -1
#define OVERFLOW   -2   

#define MAXlength 100  //初始大小为100，可按需修改

typedef int Status;         //函数调用状态

struct K
{
    float a;
    int b;
    string c;
    bool operator==(K& t)
    {
        return t.a == a && t.b == b;
        //&& t.c = c;
    }
    bool operator!=(K& t)
    {
        return t.a != a || t.b != b;
        //|| t.c = c;
    }
};
typedef K Elemtype;         //函数调用状态

struct Lnode
    //node:结; 结点;
{
    Elemtype data;
    Lnode* next;
};
typedef Lnode* LinkList;

Status 链表是否为空(LinkList L)
{
    if (L->next)
        return true;
    else
        return false;
}
Status 求表长(LinkList L)
{
    if (链表是否为空(L))
        cerr << "链表为空" << endl;
    LinkList p = L->next;
    //特别注意：因为这里从首元结点开始算起（计算）
    //所以：L->next;
    int i = 0;
    while (p)//不要写成if
    {
        p = p->next;
        i++;
    }
    //cout << "表长为：  " << i << endl;
    return i;
}

Status 取第i个元素(LinkList L, int i, Elemtype e)
{// GetElem“i”
    LinkList p;
    p = L->next;
    int j = 1;
    while (p && i > j)
    {
        p = p->next;
        j++;
    }
    if (i < 0 || i < j || !p)
        return false;
    e = p->data;
    return true;
}

Status LocateELem(LinkList L, Elemtype e)
{
    //在线性表L中查找值为e的数据元素
    //找到，则返回L中值为e的数据元素的地址，查找失败返回NULL
    auto p = L->next; int i = 1;
    while (p && p->data != e)
    {
        i++;
        if (e == p->data)
        {
            cout << "地址为：  " << p << ";" << endl;
            cout << "位置序号为：  " << i << ";" << endl;
        }
        p = p->next;
    }
    if (p == NULL)
        return NULL;
    return true;
}

Status Listlnsert(LinkList L, int i, Elemtype e)
{//插入（把元素e插到第i个位置结点上）
    auto p = L; int j = 0;
    while (p && j < i - 1)
    {
        p = p->next; ++j;
    }
    if (!p || j > i - 1)
        return false;
    auto s = new Lnode;
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}//Listlnsert_L

2：
修改<合并>函数的函数体：（在前置语句保持不变，不必改动的情况下）

Status Union(Lnode& A, Lnode& B)
{
    for (int i = 1; i <= 求表长(&B); i++)
    {
        int len_A = 求表长(&A);
        Elemtype e;
        LinkList p = &A;
        取第i个元素(&A, i, e);
        if (!LocateELem(&B, e))
            Listlnsert(p, ++len_A, e);
    }
    return true;
}

那么此时，一个让我觉得很有意思（很奇怪）的现象（情况）就发生了

问题：

为什么在前面“&A”和定义中的“LinkList& L”类型匹配不上

但是只要我们把“&A”放到一个新的该类型的变量当中，让该信息以变量的形式在程序中执行

放进去的明明都是同一个东西（&A），凭什么（怎么）原来的时候程序就可以运行了呢？？？

 

合并为一个新的整体：有序表的合并（有序，可重复）

线性表：

对于该操作的具体实现的流程设计：（各模块）

  1. 创建一个空表C

  2. 依次从A或B(中）“摘取”元素值较小的结点插入到C表的最后，直至其

    中一表变空

  3. 继续将A或B其中一表的剩余结点插入C表的最后

模块一：

对于这里的模块一，我们需要进行的：

建一个新表来返回两表合并后的结果（最终合并后的表）的操作的整个学习过程与问题，详见：

数据结构与算法基础（王卓）（8）附：关于new的使用方法详解part 2；

而在本程序中，我们使用的语句，即：

    C.elem = new Elemtype[100];

模块二：

其中，模块二的流程实现，又具体细分为：

  1.  摘取两表中元素值较小的结点
  2. 将结点插入到C表的结尾
  3. 重复循环“1”、“2”步操作，直至其中一表变为空为止

project1：

    //不用指针，直接硬钢判断语句
    int i = 0,//对应A表
        j = 0,//对应B表
        k = 0;//对应C表
    while (i < A.length || j < B.length)
    {
        if (A.elem[i] > B.elem[j])
        {
            C.elem[k] = B.elem[i];
            i++;
            k++;
        }

        if (A.elem[i] == B.elem[j])
        {
            C.elem[k] = A.elem[i];
            C.elem[++k] = B.elem[j];
            i++;
            j++;
            k++;
        }

        else//        if (A.elem[i] < B.elem[j])

        {
            C.elem[k] = A.elem[i];
            i++;
            k++;
        }
//当然，也可以先大于小于再等于

说明：

（1）：

在模块二中，两表相比较的两结点元素值都相等的语句，也可以写为：

        if (A.elem[i] == B.elem[j])
        {
            C.elem[k] = A.elem[i];
            C.elem[++k] = B.elem[j];
            i++;
            j++;
            k++;
        }

（2）：

需要注意（记住），本来（一开始），对于循环执行（的）判断语句，我们本来想写为

    while(A.elem[i] != 0 || B.elem[j] != 0)

然而，结果显示：

首先，第一点确定无疑的事情（结论）就是：

在这里，我们的程序不能完成该语句中的“！=”判断

在这里，想要程序能够成功实现执行该判断，我们可以有如下两种解决办法：

  • 手撸一个关于<Poly类型> != <int类型>的判断定义表达式
  • 定义结点为空时，该空节点的内容；即：定义一个这样的空结点

当然，要真这么写，可以是也可以，但是太过麻烦，我们这里就不选择这种方法了

project 2：（利用线性表地址线性排列存储的性质）

    //利用指针
    Poly* pa, * pb, * pc;
    pa = A.elem;
    pb = B.elem;
    pc = C.elem;

    //*pa = A.elem[0];
    //*pb = B.elem[0];

    while (pa <= &A.elem[A.length - 1] || pb < &B.elem[B.length - 1])
    {
        if (*pa > *pb)
        {
            *pc = *pb;
            pa++;
            pc++;
        }

        if (*pa == *pb)
        {
            *pc = *pa;
            *(++pc) = *pb;
            pa++;
            pb++;
            pc++;
        }

        else
        {
            *pc = *pa;
            pa++;
            pc++;
        }

模块三：

    if (A.length > B.length)
    {
        //while (i < A.length)  同理,后面不再赘述
        while (pa <= &A.elem[A.length - 1])    
        {
            *pc = *pa;
            pc++;
            pa++;
        }
    }
    else
    {
        while (pb <= &B.elem[B.length - 1])
        {
            *pc = *pb;
            pc++;
            pb++;
        }
    }

最终修改打磨：

根据（参考）PPT（178）中的标准答案，我们发现以下地方仍有修改的空间：

模块一:

一方面：

我们没有给新建的C表的length元素赋值

另一方面：

C表的长度是A表和B表两表长度的总和

如果还是只是固定的，像开辟和A表B表一样的固定为100的大小的空间，未免有些不妥：

  C.length = A.length + B.length; 
  C.elem = new Elemtype[C.length];

另外，模块二这里我们写的限定条件：

    while (pa <= &A.elem[A.length - 1] || pb < &B.elem[B.length - 1])

写成：

    while (pa <= A.elem + A.length - 1 || pb < B.elem + B.length - 1)

也同理（一样）；（标准答案就是按后者这么写的，但我感觉这么写倒也没有什么特别过人之处）

但是另一个问题就严重了：

在C++中：

与：&&

或：||

非：！

所以应该改为：

    while (pa <= A.elem + A.length - 1 && pb < B.elem + B.length - 1)

 或者：

    while (pa <= &A.elem[A.length - 1] && pb < &B.elem[B.length - 1])

另外：

在模块二中关于这个循环的循环体，我写的倒是也没有什么大的错误

但是太过累赘，还是标准答案上写的更加简洁和方便

当然他其实没有我写的那么严谨：具体写出两节点元素值相等时的操作流程，可以让循环次数减少

但是从大的时间复杂度的角度来说，其实n次循环和（n-5）次循环本质上没有太大区别

所以这里我们还是选择标准答案上的写法：

    while (pa <= &A.elem[A.length - 1] && pb < &B.elem[B.length - 1])
    {
        if (*pa < *pb)
            *pc++ = *pa++;
        else
            *pc++ = *pb++;
    }

该写法，即：

先（给C表中最后的结点（*pc））赋值，再自增；一个语句实现

最后，关于模块三：

其实我们不用在去设置看A和B哪个表更长的判断语句

因为其实我们即使直接写两个循环语句，依然不影响程序的运行

因为一个表的指针已经到达该表的尾结点以后，自然就不符合该循环的循环判断条件：

        while (pa <= &A.elem[A.length - 1])    
和
        while (pb <= &B.elem[B.length - 1])

了，另外，这里的函数体，我们也可以写为像上面一样的“先（给C表中最后的结点（*pc））赋值，再自增；”的形式：

        while (pa <= &A.elem[A.length - 1])    
        {
            *pc++ = *pa++;
        }
        while (pb <= &B.elem[B.length - 1])
        {
            *pc++ = *pb++;
        }

综上：

关于线性表的：有序表的合并（有序，可重复）操作如下：

int Merge(Sqlist A, Sqlist B, Sqlist& C)
{//合并; 融入; (使)结合; 并入; 相融;

    typedef Poly Elemtype;

    C.length = A.length + B.length;
    C.elem = new Elemtype[C.length];

    //利用指针
    Poly* pa, * pb, * pc;
    pa = A.elem;
    pb = B.elem;
    pc = C.elem;
    //*pa = A.elem[0];
    //*pb = B.elem[0];

    while (pa <= &A.elem[A.length - 1] && pb < &B.elem[B.length - 1])
    {
        if (*pa < *pb)
            *pc++ = *pa++;
        else
            *pc++ = *pb++;
    }
    //
    while (pa <= &A.elem[A.length - 1])
    {
        *pc++ = *pa++;
    }
    while (pb <= &B.elem[B.length - 1])
    {
        *pc++ = *pb++;
    }
    //
    return true;
}

链表：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/165206.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

SpringCloud学习（1）

SpringCloud学习（1）

SpringCloud学习 软件架构演进之路 对于单体架构&#xff0c;我们根据设计期和开发实现期的不同模式和划分结构&#xff0c;可以分为&#xff1a; 简单单体模式&#xff1a; 代码层面没有拆分&#xff0c;所有的业务逻辑都在一个项目&#xff08;Project&#xff09;里打包…
阅读更多...
​力扣解法汇总2293. 极大极小游戏

​力扣解法汇总2293. 极大极小游戏

目录链接&#xff1a; 力扣编程题-解法汇总_分享记录-CSDN博客 GitHub同步刷题项目&#xff1a; https://github.com/September26/java-algorithms 原题链接&#xff1a; 力扣 描述&#xff1a; 给你一个下标从 0 开始的整数数组 nums &#xff0c;其长度是 2 的幂。 对 n…
阅读更多...
伪随机码序列

伪随机码序列

伪随机码又称伪随机序列&#xff0c;是用确定性方法产生的在一段周期内具有类似白噪声的随机特性的二&#xff08;或多&#xff09;进制数据序列。 伪随机序列在码分复用、码分多址和扩频通信中都有重要应用。常用的伪随机序列有m序列、M序列和Gold序列。 作为地址码和扩频码…
阅读更多...
pycharm中commit/push撤销+分支合并

pycharm中commit/push撤销+分支合并

一、现在想撤销到打印3怎么操作&#xff1f; 1复制修订号 2鼠标右键 3去项目下执行git bash here&#xff0c;再输入git push -f 4此时&#xff0c;github中的push就已经回退成功&#xff1b;再进行一次新代码的commit和push&#xff0c;master分支的颜色就变成黄色了&#x…
阅读更多...
Windows中安装 MySQL8.0.30 数据库

Windows中安装 MySQL8.0.30 数据库

下载安装文件 访问MySQL官网下载安装文件https://downloads.mysql.com/archives/community/。 如下图所示&#xff0c;点击页面中的“DOWNLOAD”按钮。 然后&#xff0c;会出现如下所示页面&#xff0c;点击页面底部的“No thanks, just start my download”&#xff0c;就可…
阅读更多...
Vue3商店后台管理系统设计文稿篇（四）

Vue3商店后台管理系统设计文稿篇（四）

记录使用vscode构建Vue3商店后台管理系统&#xff0c;这是第四篇&#xff0c;主要记录使用git与vscode将代码同步提交到GitHub上面 文章目录一、Git与Github建立连接二、配置开发工具三、实用Git命令仓库相关命令分支相关命令正文内容&#xff1a; 一、Git与Github建立连接 使…
阅读更多...
从0到1【建站:AWS+Ubuntu+Python+Django+uwsgi+nginx+ssl】

从0到1【建站:AWS+Ubuntu+Python+Django+uwsgi+nginx+ssl】

目录一、创建服务器1、进入AWS官网2、启动实例3、创建新密钥对4、选择密钥对5、网络设置6、配置存储7、启动实例8、查看实例9、配置安全组二、连接服务器1、在AWS官网进行连接2、使用Xshell7进行连接3、设置允许root登录三、域名解析1、进行腾讯云官网2、管理域名解析3、绑定公…
阅读更多...
xilinx ZYNQ 7000 XADC 片上模拟转数字模块

xilinx ZYNQ 7000 XADC 片上模拟转数字模块

上图所示&#xff0c;XADC 属于 PL部分的资源 XADC是一种硬逻辑实现&#xff0c;位于PL功率域。PS- xadc接口是PS的一部分&#xff0c;可以被PS APU访问&#xff0c;而不需要对PL进行编程。PL必须上电才能配置PS-XADC接口、使用PL- jtag或DRP接口以及操作XADC。 上面的机构图能…
阅读更多...
通关算法题之 ⌈回溯算法⌋

通关算法题之 ⌈回溯算法⌋

回溯算法 子集组合排列 78. 子集 给你一个整数数组 nums&#xff0c;数组中的元素互不相同 &#xff0c;返回该数组所有可能的子集&#xff08;幂集&#xff09;。解集不能包含重复的子集&#xff0c;你可以按任意顺序 返回解集。 输入&#xff1a;nums [1,2,3] 输出&…
阅读更多...
LeetCode 5. 最长回文子串

LeetCode 5. 最长回文子串

&#x1f308;&#x1f308;&#x1f604;&#x1f604; 欢迎来到茶色岛独家岛屿&#xff0c;本期将为大家揭晓LeetCode 5. 最长回文子串&#xff0c;做好准备了么&#xff0c;那么开始吧。 &#x1f332;&#x1f332;&#x1f434;&#x1f434; 一、题目名称 LeetCode 5…
阅读更多...
1590_AURIX_TC275_PMU_Flash的操作

1590_AURIX_TC275_PMU_Flash的操作

全部学习汇总&#xff1a; GreyZhang/g_TC275: happy hacking for TC275! (github.com) 这里提到的这个复位读取操作&#xff0c;复位的对象其实是当前的操作&#xff0c;也就是命令序列。主要是命令序列的最后一个命令还没有被接收到&#xff0c;都可以被这个命令中断。在复位…
阅读更多...
目标检测：特征金字塔网络（Feature Pyramid Network）

目标检测：特征金字塔网络（Feature Pyramid Network）

目标检测&#xff1a;特征金字塔网络&#xff08;Feature Pyramid Network&#xff09;概述核心思想概述 由于在目标检测任务中&#xff0c;对与大目标的检测&#xff0c;需要feature map每个点的感受野大一点&#xff08;高层语义特征&#xff09;&#xff0c;对于小目标&…
阅读更多...
GPIO 八种工作模式及其硬件框图

GPIO 八种工作模式及其硬件框图

参考资料： STM32F1xx 官方资料：《STM32中文参考手册V10》- 第 8 章通用和复用功能 IO(GPIO 和 AFIO) GPIO 是通用输入/输出端口的简称，是 STM32 可控制的引脚。GPIO 的引脚与外部硬件设备连接，可实现与外部通讯、控制外部硬件或者采集外部硬件数据的功能。 STM32 的八种 …
阅读更多...
图像融合笔记（一）：RFN-Nest

图像融合笔记（一）：RFN-Nest

RFN-NestAbstractIntroductionRelated worksThe proposed fusion frameworkThe architecture of the fusion networkTwo-stage training strategy论文&#xff1a; RFN-Nest: An end-to-end residual fusion network for infrared and visible images代码&#xff1a; https://…
阅读更多...
[Android Input系统]MotionEvent的序列化传送

[Android Input系统]MotionEvent的序列化传送

这里从云游戏的触控操作看起&#xff0c;PC端的客户端支持按键和鼠标滑动操作&#xff0c;手机上的云游戏客户端则是和手机游戏一样的touch触控&#xff0c;客户端的touch操作是怎样处理给服务端的呢&#xff0c;猜测是把touch操作“实时”的传送给了服务器&#xff0c;Android…
阅读更多...
COM，Component Object Model 简介

COM，Component Object Model 简介

COM&#xff0c;Component Object Model 简介 1. COM 是什么 COM 的英文全称是&#xff0c;Component Object Model&#xff0c;中文译为&#xff0c;组件对象模型。它官方的概念是&#xff1a; The Microsoft Component Object Model (COM) is a platform-independent, dis…
阅读更多...
一个简单、功能完整的开源WMS​仓库管理系统

一个简单、功能完整的开源WMS​仓库管理系统

今天给大家推荐一个简单、功能完整的仓库管理系统。 项目简介 这是基于.NetCore 7、Vue 3开发的开源项目&#xff0c;支持中英文&#xff0c;界面简单清爽&#xff0c;采用前后端分离架构。 该项目主要是针对小型物流仓储供应链流程&#xff0c;采用的技术也都比较新&#x…
阅读更多...
Redis基础配置之RDB持久化

Redis基础配置之RDB持久化

测试环境&#xff1a; windows RDB的触发机制 save bgsave flushall 自动触发(配置文件配置) save命令触发&#xff1a; 触发方式 &#xff1a;首先手动删除dump.rdb文件。 当执行save命令时&#xff0c;自动生成dump.rdb文建测试成功 bgsave命令触发&#xff1a; 触…
阅读更多...
jsp网络课程管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

jsp网络课程管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

一、源码特点 JSP 网络课程管理系统 是一套完善的web设计系统&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统采用web模式开发&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主要采用B/S模式开发。开发环境为TOMCAT7.0,Myeclipse8.5开发&#xff…
阅读更多...
JVM内存组成简介

JVM内存组成简介

按照官方的说法&#xff1a;“Java 虚拟机具有一个堆&#xff0c;堆是运行时数据区域&#xff0c;所有类实例和数组的内存均从此处分配。堆是在 Java 虚拟机启动时创建的。”“在JVM中堆之外的内存称为非堆内存(Non-heap memory)”。可以看出JVM主要管理两种类型的内存&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023