实验2、基于顺序表的非递减有序表的合并

最新推荐文章于 2023-09-04 12:54:32 发布
最新推荐文章于 2023-09-04 12:54:32 发布
阅读量1k 收藏 9
点赞数 3
分类专栏： 数据结构学习笔记 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40772639/article/details/108934491
版权

头文件

#pragma once
#ifndef EXPR1_H_

#define EXPR1_H_
#include <cstddef>
#include <iostream>
#include <memory>
#include <new>
#include <stdexcept>
template <typename T>
class expr1List
{
public:
    struct Node
    {
        T data;
        Node* prior;
        Node* next;
        Node()
        {
            prior = nullptr;
            next = nullptr;
        }
    };

private:
    Node* _head;
    Node* _rear;
    int _length;

public:
    expr1List();
    expr1List(std::initializer_list<T>);
    expr1List(const expr1List<T>&);
    ~expr1List();            //DestroyList(&L)
    void Clear();            //ClearList(&L)
    bool isEmpty() const;    //ListEmpty(L)
    int length() const;      //ListLength()
    T operator[](int) const; //为了List<T>类型的常量
    T& operator[](int);      //GetElem(L,i,&e)
    template <typename F>
    int locateElem(T, F) const; //LoacteElem(L,e,&e)
    int priorElem(T) const;     //改为返回直接前驱的索引，若失败，返回-1
    int nextElem(T) const;      //改为返回直接后驱的索引，若失败，返回-1
    bool listInsert(int, T);    //ListInsert()
    bool listDelete(int, T&);  //删除第i个元素，并将值返回给调用者
    bool isSorted();
    bool push_back(T);
    template <typename F>
    void traverse(F); //ListTraverse(L,visit())

    // iterator begin() { return iterator(_head); }
    // iterator end() { return iterator(_rear->next); }
};

template <typename T>
inline expr1List<T>::expr1List() : _head(nullptr), _rear(nullptr), _length(0) {}

template <typename T>
inline expr1List<T>::expr1List(std::initializer_list<T> il) : expr1List()
{
    int i = 0;
    for (auto p = il.begin(); p != il.end(); p++)
        listInsert(i++, *p);
}
template <typename T>
inline expr1List<T>::expr1List(const expr1List<T>& li):expr1List()
{
    int i = 0;
    while (i < li.length())
    {
        listInsert(i, li[i]);
        i++;
    }
}

template <typename T>
inline expr1List<T>::~expr1List() { Clear(); }

template <typename T>
inline void expr1List<T>::Clear()
{
    if (!_head)
        return;
    if (_length == 1)
    {
        _length = 0;
        delete _head;
        _head = nullptr;
        _rear = nullptr;
        return;
    }
    for (auto p = _head; p != _rear;)
    {
        Node* tmp = p;
        p = p->next;
        delete tmp;
    }
    delete _rear;
    _head = nullptr;
    _rear = nullptr;
    _length = 0;
}

template <typename T>
inline bool expr1List<T>::isEmpty() const
{
    return !_length;
}

template <typename T>
inline int expr1List<T>::length() const
{
    return _length;
}

template <typename T>
inline T expr1List<T>::operator[](int index) const
{
    if (index < 0 || index > _length - 1)
        throw std::out_of_range("下标越界了！");
    int i = 0;
    Node* p = _head;
    while (i != index)
    {
        p = p->next;
        i++;
    }
    return p->data;
}

template <typename T>
inline T& expr1List<T>::operator[](int index)
{
    if (index < 0 || index > _length - 1)
        throw std::out_of_range("下标越界了！");
    int i = 0;
    Node* p = _head;
    while (i != index)
    {
        p = p->next;
        i++;
    }
    return p->data;
}

template <typename T>
template <typename F>
inline int expr1List<T>::locateElem(T t, F f) const
{
    if (_length == 0)
        return -1;
    for (int i = 0; i < _length; i++)
        if (f(t, this->operator[](i)))
            return i;
    return -1;
}

template <typename T>
inline int expr1List<T>::priorElem(T t) const
{
    if (_length < 2)
        return -1;
    for (int i = 1; i < _length; i++)
        if (t == this->operator[](i))
            return i - 1;
    return -1;
}

template <typename T>
inline int expr1List<T>::nextElem(T t) const
{
    if (_length < 2)
        return -1;
    for (int i = 0; i < _length - 1; i++)
        if (t == this->operator[](i))
            return i + 1;
    return -1;
}

template <typename T>
inline bool expr1List<T>::listInsert(int l, T t)
{
    if (l < 0 || l > _length)
        return false;

    Node* newNode = new Node;
    if (!newNode)
        return false;
    newNode->data = t;
    _length++;

    if (l == 0) //如果插入第一个元素
    {
        if (_length == 1)
        {
            newNode->prior = newNode;
            newNode->next = newNode;
            _rear = newNode;
            _head = newNode;
            return true;
        }
        newNode->prior = _rear;
        newNode->next = _head;
        _head->prior = newNode;
        _rear->next = newNode;
        _head = newNode;

        return true;
    }

    int i = 0;
    Node* p = _head;
    while (i != l)
    {
        p = p->next;
        i++;
    }
    newNode->next = p;
    newNode->prior = p->prior;
    newNode->prior->next = newNode;
    newNode->next->prior = newNode;
    if (l == _length - 1)
        _rear = newNode;
    return true;
}

template <typename T>
inline bool expr1List<T>::listDelete(int l, T& t)
{
    if (l < 0 || l > _length - 1)
        return false;
    _length--;

    int i = 0;
    Node* p = _head;
    while (i != l)
    {
        p = p->next;
        i++;
    }
    if (l == 0)
        _head = p->next;
    if (l == _length - 1)
        _rear = p->prior;

    p->prior->next = p->next;
    p->next->prior = p->prior;
    delete p;
    return true;
}
template <typename T>
inline bool expr1List<T>::isSorted()
{
    if (_length < 2)
        return true;
    for (int i = 1; i < _length; i++)
        if (this->operator[](i) < this->operator[](i - 1))
            return false;
    return true;
}

template <typename T>
bool expr1List<T>::push_back(T t)
{
    Node* newNode = new Node;
    newNode->data = t;
    if (_length == 0)
    {
        newNode->prior = newNode;
        newNode->next = newNode;
        _head = _rear = newNode;
        _length++;
        return true;
    }
    newNode->prior = _rear;
    newNode->next = _head;
    _head->prior = newNode;
    _rear->next = newNode;
    _rear = newNode;
    _length++;
    return true;
}
template <typename T>
template <typename F>
inline void expr1List<T>::traverse(F f)
{
    if (_length == 0)
        return;
    for (int i = 0; i < _length; i++)
        f(this->operator[](i));
}

#endif // !EXPR1_H_

#include "expr1.h"
#include <cctype>
#include <memory>
using namespace std;
template <typename T>
void MergeList(T, T, T&);
void showMenu();
void showError() { cout << "请先初始化一个线性表！" << endl; }
template <typename T>
void input(expr1List<T>& li, bool sortedCheck = false);
template <typename T>
void showList(const expr1List<T>&);
expr1List<int>* l1 = nullptr;
bool status = false;
int main()
{
    showMenu();
    int selection;
    while (true)
    {
        cout << "请输入操作代码：";
        cin >> selection;
        if (selection < 0)
            break;
        switch (selection)
        {
        case 1:
        {
            if (!status)
            {
                l1 = new expr1List<int>;
                if (cin.peek() == '\n')
                    cin.get();

                input(*l1);
                status = true;
                cout << "初始化完成!" << endl;
            }
            else
                cout << "已经初始化过了。" << endl;
        }
        break;
        case 2:
        {
            if (status)
            {
                delete l1;
                status = false;
                cout << "链表已销毁！" << endl;
            }
            else
                showError();
            break;
        }
        case 3:
        {
            if (status)
            {
                l1->Clear();
                cout << "线性表已清空！" << endl;
            }
            else
                showError();
            break;
        }
        case 4:
        {
            if (status)
            {
                if (l1->isEmpty())
                    cout << "线性表是空的！" << endl;
                else
                    cout << "线性表不是空的！" << endl;
            }
            else
                showError();
            break;
        }
        case 5:
        {
            if (status)
                cout << "线性表长度为" << l1->length() << endl;
            else
                showError();
            break;
        }
        case 6:
        {
            if (status)
            {
                if (l1->length() == 0)
                {
                    cout << "线性表里什么都没有呢！" << endl;
                    break;
                }
                int n;
                do
                {
                    printf("请输入指定的位置，区间要在[0,%d)：", l1->length());
                    cin >> n;
                } while (n < 0 || n > l1->length() - 1);
                cout << "第" << n << "位的值是" << l1->operator[](n) << endl;
            }
            else
                showError();
            break;
        }
        case 7:
        {
            if (status)
            {
                int n;
                cout << "请输入元素：";
                cin >> n;
                int e = l1->locateElem(n, [](int n, int m) { return n == m; });
                if (e == -1)
                    cout << "呀！找不到该元素。" << endl;
                else
                    cout << "这个元素在线性表最靠前的位置是" << e << endl;
            }
            else
                showError();
            break;
        }
        case 8:
        {
            if (status)
            {
                int n;
                cout << "请输入要求前驱的元素：";
                cin >> n;
                int e = l1->locateElem(n, [](int n, int m) { return n == m; });
                if (e == -1)
                {
                    cout << "呀！找不到该元素。" << endl; break;
                }
                int index = l1->priorElem(n);
                if (index == -1)
                    cout << "这个元素没有前驱。" << endl;
                else
                    cout << "这个元素的前驱是" << l1->operator[](index) << endl;
            }
            else
                showError();
            break;
        }
        case 9:
        {
            if (status)
            {
                int n;
                cout << "请输入要求后继的元素：";
                cin >> n;
                int e = l1->locateElem(n, [](int n, int m) { return n == m; });
                if (e == -1)
                {
                    cout << "呀！找不到该元素。" << endl; break;
                }
                int index = l1->nextElem(n);
                if (index == -1)
                    cout << "这个元素没有后继。" << endl;
                else
                    cout << "这个元素的后继是" << l1->operator[](index) << endl;
            }
            else
                showError();
            break;
        }
        case 10:
        {
            if (status)
            {
                int index;
                int n;
                do
                {
                    cout << "请输入一个正确的位置：";
                    cin >> index;
                } while (index < 0 || index > l1->length());
                cout << "请输入元素：";
                cin >> n;
                l1->listInsert(index, n);
                cout << "插入成功！" << endl;
            }
            else
                showError();
            break;
        }
        case 11:
        {
            if (status)
            {
                int index;
                int n;
                do
                {
                    cout << "请输入一个正确的位置：";
                    cin >> index;
                } while (index < 0 || index > l1->length() - 1);
                l1->listDelete(index, n);
                cout << "删除成功！" << endl;
            }
            else
                showError();
            break;
        }
        case 12:
        {
            if (status)
                showList(*l1);
            else
                showError();
            break;
        }
        case 13:
        {
            expr1List<int> la, lb, lc;
            cout << "请输入两个非递减有序的线性表。" << endl;
            cout << "第一个：" << endl;
            if (cin.peek() == '\n')
                cin.get();
            input(la, true);
            cout << "第二个" << endl;
            if (cin.peek() == '\n')
                cin.get();
            input(lb, true);
            MergeList(la, lb, lc);
            cout << "合并结果：";
            showList(lc);
        }
        default:
            cout << "请输入1-13以内的数，或者一个负数" << endl;
        }
    }
    cout << "拜拜！" << endl;
    if (status)
        delete l1;
    system("pause");
}

template <typename T>
void MergeList(T La, T Lb, T& Lc)
{
    int i = 0;
    int j = 0;
    int k = 0;
    while (i != La.length() && j != Lb.length())
    {
        if (La[i] <= Lb[j])
        {
            Lc.listInsert(k++, La[i]);
            if (La[i++] == Lb[j])
                j++;
        }
        else if (La[i] > Lb[j])
            Lc.listInsert(k++, Lb[j++]);
    }
    while (i != La.length())
        Lc.listInsert(k++, La[i++]);
    while (j != Lb.length())
        Lc.listInsert(k++, Lb[j++]);
}
void showMenu()
{
    cout << "=============实验二（李金宝）================" << endl
        << "1----初始化一个线性表" << endl
        << "2----销毁线性表" << endl
        << "3----清空线性表" << endl
        << "4----判断线性表是否为空" << endl
        << "5----求线性表长度" << endl
        << "6----获取线性表中指定的位置" << endl
        << "7----获取线性表元素的位置" << endl
        << "8----求前驱" << endl
        << "9----求后继" << endl
        << "10----在线性表指定位置插入元素" << endl
        << "11----删除线性表指定位置的元素" << endl
        << "12----显示线性表" << endl
        << "13----合并两个非递减有序的线性表" << endl
        << "      退出，输入一个负数！" << endl
        << endl;
}

template <typename T>
void input(expr1List<T>& li, bool sortedCheck)
{
    cout << "请输入一个线性表(以“Enter”结束输入)：";
    if (cin.peek() == '\n')
    {
        cin.get(); return;
    }
    int n = 0;
    do
    {
        li.Clear();
        if (sortedCheck)
            cout << "要有序！！！" << endl;
        while (cin >> n)
        {
            li.push_back(n);
            if (cin.peek() == '\n')
            {
                cin.get();
                break;
            }
        }
        if (!sortedCheck)
            return;
    } while (cin.clear(), cin.sync(), !li.isSorted());
}
template <typename T>
void showList(const expr1List<T>& li)
{
    int i = 0;
    cout << endl;
    while (i < li.length())
        cout << li[i++] << "  ";
    cout << endl;
}
遇水叠桥
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
陈越、何钦铭-数据结构作业2：顺序链表合并
03-15
本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。L1和L2是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Merge要将L1和L2合并为一个非递减的整数序列。应直接使用原...
数据结构实验①：线性表的操作之顺序表（C语言）
憨憨猿学编程
06-20 4941
一.题目描述： 1.顺序表的操作 （1）输入一组整型元素序列，建立线性表的顺序存储结构。 （2）实现该线性表的遍历。 （3）在该顺序表中查找某一元素,查找成功显示查找元素，否则显示查找失败。 （4）在该顺序表中插入指定元素。 （5）在该顺序表中删除指定元素。 （6）建立两个按值非递减有序排列的顺序表，将他们合并成一个按值非递减有序排列的顺序表。 ...
顺序表的非递减数列合并
weixin_33998125的博客
05-30 335
#include&lt;stdio.h&gt; /*包括输入输出头文件*/ #define ListSize 100 typedef int DataType; typedef struct { DataType list[ListSize]; int length; }SeqList; void InitList(SeqList *L) /*将线性表初始...
顺序表的有序合并
qq_43480179的博客
04-19 1343
题目描述 有两个顺序表LA和LB，其元素均为非递减有序排列，编写算法， 将它们合并成一个顺序表LC，要求LC也是非递减有序排列。 例如，LA=（2,2,3），LB=（1,3,3,4），则LC=（1,2,2,3,3,3,4） 输入描述 分别输入两个顺序表LA和LB，以-1结束输入 输出描述 输出归并后的顺序表LC 输入样例 2 2 3 -1 1 3 3 4 -1 输出样例 1 2 2 3 3 3 4...
有序表
qq_40710190的博客
10-02 1439
有序表算法题 今年开始上数据结构的课了，把写的题记录一下 数组实现 1.求两个集合的并集和交集 这题我之前的博客其实写过了，所以稍微简单地改了改就写上了。 题目描述： 已知A和B均是由整型数据组成的集合，使用顺序表表示集合，设计算法求集合A、B的交集和并集，功能包括输入集合A，输入集合B，求A和B的并集，求A和B的交集。本题中, 线性表的第一个元素位置为1，线性表的最大长度为20。 输入描述： 各个命令以及相关数据的输入格式如下： 输入集合A：A，接下来的一行是要输入的集合元素个数n，下面是n行数据，每行数
C语言顺序表，合并并排序（代码注释讲解）
全栈川川
03-29 3976
/*.已知有两个按元素值递增有序的顺序表A和B，设计一个算法将表A和表B的全部元素归并为一个按元素值非递减有序的顺序表C。 要求： 从键盘输入顺序表A和B的各元素，编程实现上述算法，输出顺序表A、顺序表B和顺序表C 的所有元素值 。*/ #include<stdio.h> #include <stdlib.h> #include<iomanip> #include<iostream> #pragma warning(disable:4996) typede
合并两个有序链表.pptx
03-20
数据结构之合并两个有序链表PPT动画演示
将两个递增的链表合并为一个非递减的链表
04-12
从键盘输入两个链表，通过程序对他们排序，之后按递增顺序合并链表
数据结构实验报告 顺序表
11-01
顺序表是指采用顺序存储结构的线性表，它利用内存中的一片...4. 写一个函数，实现两个有序（非递减）表合并生成新的有序表的功能 5. 编写一个界面友好的测试程序，能够对各种边界条件进行测试，验证上述算法的正确性。
shunxubiao.rar_shunxubiao_输入一组整型元素序列，建立顺序表
09-19
(1)．输入一组整型元素序列，建立顺序表。 (2)．实现该顺序表的遍历。 (3)．在该顺序表中顺序查找某一元素,查找...利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。 (8)．编写一个主函数,调试上述算法。
两个有序顺序表的合并
10-05
两个有序顺序表的合并 C++ 无技术含量 数据结构题目
非递减有序顺序表的合并
SuiGi的博客
03-17 3244
/*问题描述:已知两个有序集合A和B，数据元素按值非递减有序排列，现要求 一个新的集合C=A∪B，使集合C中数据元素仍按值非递减有序排列 //搬点以前写的记录一下 [分析]:无序表LA,LB所以无需遍历LB，设LC为空表 用两个头指针pa，pb遍历两表将小值插入LC并++，最后多余数据表直接补在LC后面 设表长分别为m,n，时间复杂度为○(m+n),最糟的情况不过LA的元素都大于LB,LB表长大...
两个非递减顺序表合并成一个非递减顺序表
最新发布
weixin_75202470的博客
09-04 845
我在这里将这种方式描述为 "穿针引线法"是因为真的很形象，但是其实如果是在链表中这样称呼，似乎更加合适。
非递减顺序表的合并
qq_18062811的专栏
11-01 1165
//顺序表的合并 //输入元素函数 put //输出元素函数 output //合并 Merge #include #include #include using namespace std; #define LIST_INIT_SIZE 80 #define LISTINCREMENT 10 typedef struct { int *elem; int length;
C++ （数据结构）基于顺序表的有关操作
ninini12386的博客
11-03 1320
实验2、基于顺序表的非递减有序表的合并 （1）实验目的 通过该实验，深入理解顺序表的逻辑结构、物理结构等概念，掌握顺序表基本操作的编程实现，注意顺序表插入、删除等操作过程中数据元素的移动现象，培养学生编写程序时，要考虑程序的健壮性，全面考虑问题，熟练掌握通过函数参数返回函数结果的办法。 （2）实验内容 编程实现顺序表下教材第二章定义的线性表的基本操作，并根据已经实现的基本操作，实现两个非递减有序的线性表的合并，注意，合并时，如果有重复的元素，请保留一个。 （3）实验要求 （a）求前驱是指，输入一个元素值（而
合并两个非递减排列类的顺序线性表
weixin_51235620的博客
03-15 1254
伪c语言如下(函数) 根据题目就知道显然使用链表更加简单（就是简单的连线) 思想：以L线性表作为基准，遍历Q线性表，满足条件及插入即可，需要注意，每次插入都要记住插入点的位置（n),下次插入必定在此处之后，每找到一个点就开始从此处开始将L的元素向后移一个位置，经多次调试才发现插入点为最后一个位置是要做特殊判断（此时不需要移动L中的元素） void mergelist(sqlist &L) { sqlist Q; int i; int e; int l, j, k; int j1,n; printf(
非递减有序排列C语言,非递减有序顺序表的排序
weixin_42214654的博客
05-23 2016
由于编者水平有限,如有错误,请多多包涵。/*File name: Example.cppDescription: 非递减有序线性表LA， 非递减有序线性表LB， 要求排序后存放在LC中，且LC元素仍然为非递减有序排列Author: Yang_JiangDate: 2018年10月12日Compiler：Visual Studio 2008*/# include # include # define...
顺序表非递减顺序合并
weixin_30257433的博客
10-09 420
1 #include <bits/stdc++.h> 2 using namespace std; 3 #define MAXSIZE 100 4 /** 5 * 实验一 （1） 6 * @author Unchangedman 7 */ 8 typedef int ElemType; 9 10 typedef str...
数据结构 基于顺序表的非递减有序表的合并
03-16
基于顺序表的非递减有序表的合并，可以采用双指针的方法。具体步骤如下： 1. 定义两个指针i和j，分别指向两个有序表的起始位置。 2. 定义一个新的顺序表result，用于存储合并后的有序表。 3. 循环比较两个有序表中当前位置的元素大小，将较小的元素插入到result中，并将对应指针向后移动一位。 4. 当其中一个有序表的指针到达末尾时，将另一个有序表中剩余的元素依次插入到result中。 5. 返回result作为合并后的有序表。 例如，假设有两个有序表A=[1,3,5,7,9]和B=[2,4,6,8,10]，则合并后的有序表为result=[1,2,3,4,5,6,7,8,9,10]。具体实现可以参考以下伪代码： ``` function merge(A, B): i = j = result = [] while i < len(A) and j < len(B): if A[i] <= B[j]: result.append(A[i]) i += 1 else: result.append(B[j]) j += 1 if i < len(A): result.extend(A[i:]) if j < len(B): result.extend(B[j:]) return result ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值