数据结构与算法——顺序表

小柒_02

于 2024-09-05 21:25:06 发布

阅读量541

点赞数 13

分类专栏：头歌——数据结构与算法文章标签： c++ 算法数据结构

本文链接：https://blog.csdn.net/weixin_60732009/article/details/141941145

版权

头歌——数据结构与算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

第1关顺序表基本操作

任务描述

本关任务要求针对线性结构的顺序存储方式完成其七个操作函数，分别实现线性表中数据的插入、删除、扩容、查找、访问、遍历和转置等功能。

编程要求

本关任务是实现step1：顺序表/SeqList.h中的insert、remove、resize、search、visit、traverse和inverse七个基本操作。请注意，为了能够更好的比对输出结构，在参考教材代码的同时，请删除所有提示信息的输出！基本操作具体要求如下：

* insert: 在顺序表的位置i插入结点x, 插入d[i]之前,i的有效范围[0,curLength]
* remove:删除顺序表第i号结点, i的有效范围应在[0,curLength-1]，否则会产生异常或错误。
* search:查找第一个值为value的结点,存在则返回结点坐标, 未找到返回－1
* resize:对现有顺序表扩容，扩容后大小为原来的2倍。
* visit:访问顺序表第i号结点, i的有效范围应在[0,curLength-1]，否则会产生异常或错误。找到则返回元素值，
* traverse:遍历输出顺序表中元素。
* inverse:逆置顺序表中元素。

输入输出格式请参见后续测试样例
注意：在实现本关任务的七个操作函数时，可调用以完成的其他操作。

测试说明

本关的测试文件是step1：顺序表/main.cpp，负责对实现的代码进行测试。具体代码，可以切换平台代码文件查看。
注意：step1：顺序表/main.cpp的代码不能被修改。

以下是平台对step1：顺序表/main.cpp的测试样例：
样例输入:
4 //输入线性表的长度
0 0 //0号位置出入元素0
1 1 //1号位置出入元素1
2 2 //2号位置出入元素2
3 3 //3号位置出入元素3
2 //设置j值
0 //设置val值
样例输出
0 1 2 3 //输出当前线性表的数据元素
0 //输出值为0的元素所在位置
2 //输出j位置元素值
0 1 3 //删除j位置元素后，输出线性表
3 1 0 //逆置当前线性表后输出

开始你的任务吧，祝你成功！

代码

seqList.h

#ifndef _SEQLIST_H_
#define _SEQLIST_H_
#include "List.h"

template <class elemType>          // elemType为顺序表存储的元素类型
class seqList: public List<elemType>
{ 
private:
  elemType *data;              // 利用数组存储数据元素 
    int curLength;              // 当前顺序表中存储的元素个数
    int maxSize;              // 顺序表的最大长度
    void resize();              // 表满时扩大表空间
public:
    seqList(int initSize = 10);        // 构造函数 
  seqList(seqList & sl) ;          // 拷贝构造函数
    ~seqList()  {delete [] data;}      // 析构函数 
    void clear()  {curLength = 0;}      // 清空表，只需修改curLength
  bool empty() const {return curLength==0;}  // 判空
    int size() const {return curLength;}  // 返回顺序表的当前存储元素的个数 
    void insert(int i,const elemType &value);  // 在位置i上插入一个元素value，表的长度增1
    void remove(int i);            // 删除位置i上的元素value，若删除位置合法，表的长度减1 
    int search(const elemType &value) const ;  // 查找值为value的元素第一次出现的位序
    elemType visit(int i) const;      // 访问位序为i的元素值，“位序”0表示第一个元素，类似于数组下标
    void traverse() const ;          // 遍历顺序表
  void inverse();              // 逆置顺序表
};
template <class elemType>
seqList<elemType>::seqList(int initSize) 
{ 
  if (initSize <= 0) throw badSize();
  maxSize = initSize;            
  data = new elemType[maxSize];      // 创建一个大小为maxSize的顺序表
  curLength = 0;              
} 
template <class elemType>
seqList<elemType>::seqList(seqList & sl) { 
    maxSize = sl.maxSize;            
    curLength = sl. curLength;              
    data = new elemType[maxSize];  
    for (int i = 0; i < curLength; ++i)
        data[i] = sl.data[i];    
}
template <class elemType>
void seqList<elemType>::insert(int i, const elemType &value)
{ 
    if (i < 0 || i > curLength) throw outOfRange();  // 合法的插入位置为[0..n]
    if (curLength == maxSize) resize();      // 表满，扩大数组容量
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/

    for (int j = curLength;j > i;j--) {
        data[j] = data[j - 1];
    }

    data[i] = value;
    ++curLength;

    /********** End **********/
}

template <class elemType>
void seqList<elemType>::remove(int i) 
{ 
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
  
    if (i < 0 || i > curLength - 1) {
        throw outOfRange();
    }

    for (int j = i;j < curLength - 1;j++){
        data[j] = data[j+1];
    }

    --curLength;

    /********** End **********/
}

template <class elemType>
void seqList<elemType>::resize()
{ 
    elemType *p = data;              // p指向原顺序表空间
    maxSize *= 2;                  // 表空间扩大2倍
    data = new elemType[maxSize];          // data指向新的表空间
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
   
    for (int i = 0;i < curLength; ++i) {
        data[i] = p[i];
    }

    delete [] p;

    /********** End **********/
}

template<class elemType>
int seqList<elemType>::search(const elemType & value) const
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
   
   for (int i = 0;i < curLength;i++) {
       if (value == data[i]) {
           return i;
       }

       return -1;
   }

    /********** End **********/              
}

template<class elemType>
elemType seqList<elemType>::visit(int i) const
{
  if (i < 0 || i > curLength-1 ) throw outOfRange();// 合法的访问位置为[0..n-1] 
  // 请在这里补充代码，完成本关任务
    /********** Begin *********/

    return data[i];
 
    /********** End **********/
}

template<class elemType>
void seqList<elemType>::traverse()const
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/

    if(empty()) {
        cout << endl;
    }
    else {
        for (int i = 0;i < curLength;i++) {
            cout << data[i] << " ";
        }
        cout << endl;
    }

    /********** End **********/          
}

template<class elemType>
void seqList<elemType>::inverse() 
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/

    elemType tmp;
    for(int i = 0;i < curLength/2;i++) {
        tmp = data[i];
        data[i] = data[curLength-i-1];
        data[curLength-i-1] = tmp;
    }

    /********** End **********/
}

#endif

第2关合并两个顺序表

任务描述

1.按要求生成顺序表1和顺序表2。
接收由键盘输出的两组数据，第1组数据按录入顺序生成顺序表1，第2组数据按录入的逆序生成顺序表2。
例如，若第一组数据依次录入0 1 2，则顺序表1的0-2号位置依次为 0 1 2。若第二组数据依次录入为0 1 2，则顺序表2的0-2号位置依次为 2 1 0。
2.合并顺序表2到顺序表1中，即顺序表2的元素依次插入到顺序表1尾元素后，打印合并后的顺序表1。

测试说明

平台会对你编写的代码进行测试：

4 //输入第一个表的长度
0 2 4 6//依次输入顺序表1元素
5 //输入第二个表的长度
1 3 5 7 9 //依次输入顺序表2元素
预期输出：
归并表为：0 2 4 6 9 7 5 3 1

代码

/*
合并两个顺序表：
1.按要求生成顺序表1和顺序表2。
接收由键盘输出的两组数据，第1组数据按录入顺序生成顺序表1，第2组数据按录入的逆序生成顺序表2。
例如，若第一组数据依次录入0 1 2，则顺序表1的0-2号位置依次为 0 1 2。若第二组数据依次录入为0 1 2，则顺序表2的0-2号位置依次为 2 1 0。
2.合并顺序表2到顺序表1中，即顺序表2的元素依次插入到顺序表1尾元素后，打印合并后的顺序表1。

提示：本关可调用第1关中已实现的顺序表基本操作，请注意头文件的调用。
*/

#include <iostream>    
#include <cstdlib>
using namespace std;     
#include "seqList.h"
#include "List.h"

int main()   
{   

    seqList<int>* sl_1;
    seqList<int>* sl_2;
    sl_1 = new seqList<int>();
    sl_2 = new seqList<int>();

    int val;
    int n;

    cin >> n;
    for (int i = 0;i < n;i++){
        cin >> val;
        sl_1 -> insert(i,val);
    }

    cin >> n;
    for (int i = 0;i < n;i++){
        cin >> val;
        sl_2 -> insert(i,val);
    }

    sl_2 -> inverse();

    n = sl_2 -> size();
    int l = sl_1 -> size();
    for (int i = 0;i < n;i++){
        val = sl_2 -> visit(i);
        sl_1 -> insert(l + i,val);
    }

    sl_1 -> traverse();

}

小柒_02

关注

13
点赞
踩
13

收藏

觉得还不错? 一键收藏
打赏
0
评论
数据结构与算法——顺序表

在顺序表位置i插入元素value：将value插入data[i]之前。删除位置序i处的元素：删除线性表的i号数据元素。查找顺序表中第一次出现值为value的元素位置：找到线性表中第一个值为value的数据元素的编号。删除顺序表中第一个值为x的数据元素：删除第一个值为x的数据元素，返回该数据元素的编号。本关任务要求针对线性结构的顺序存储方式完成其七个操作函数，分别实现线性表中数据的插入、删除、扩容、查找、访问、遍历和转置等功能。访问顺序表第i个数据元素：返回位于线性表的第i个数据元素data[i]。
复制链接

扫一扫