0109作业

思维导图

使用C++手动封装一个顺序表，包含成员指针变量，成员变量N个

main.cpp

#include <iostream>
#include "z1.h"
using namespace std;

int main()
{
    SeqLite s1;

    s1.add(1);
    s1.add(2);
    s1.add(3);
    s1.add(4);
    s1.add(5);
/*
    int n;
    cout<<"请输入查询的位置:"<<endl;
    cin>>n;
    cout<<"顺序表第"<<n<<"个位置的数为："<<s1.at(n)<<endl;

    cout<<"请输入删除的位置:"<<endl;
    cin>>n;
    s1.delete_pos(n);

    cout<<"请输入插入的位置:"<<endl;
    cin>>n;
    s1.insert_pos(n,100);

    cout<<"请输入查询的位置:"<<endl;
    cin>>n;
    cout<<"顺序表第"<<n<<"个位置的数为："<<s1.at(n)<<endl;

    cout<<"该顺序表的长度为："<<s1.length()<<endl;
    s1.delete_pos(2);
  */
    s1.expend();
    s1.add(999);
    s1.add(888);
    s1.add(777);
    s1.add(666);
    s1.add(555);
while(1)
{
    int n;
    cout<<"请输入查询的位置:"<<endl;
    cin>>n;
    cout<<"顺序表第"<<n<<"个位置的数为："<<s1.at(n)<<endl;
}
    return 0;
}

z1.cpp

#include "z1.h"

//无参构造
SeqLite::SeqLite():data(new datatype[5]),size(5),len(0)
{
    std::cout<<"无参构造"<<std::endl;
}

//判空函数
bool SeqLite::empty()
{
    return len==0;
}
//判满函数
bool SeqLite::full()
{
    return len==size;
}
//添加数据函数
bool SeqLite::add(datatype e)
{
    if(full())
    {
        std::cout<<"顺序表已满"<<std::endl;
    }
    data[len] = e;
    len++;
    return true;
}
//求当前顺序表的实际长度
int SeqLite::length()
{
    return len;
}


//任意位置插入函数
bool SeqLite::insert_pos(int pos,datatype e)
{
    int i=0;
    if(full())
    {
        std::cout<<"顺序表满了"<<std::endl;
        return false;
    }
    if(pos<0 || pos>len)
    {
        std::cout<<"输入位置不合法"<<std::endl;
        return false;
    }
    for(i=len;i>pos-1;i--)
    {
        data[i] = data[i-1];
    }
    data[i] = e;
    len++;
    return true;
}

//任意位置删除的函数
bool SeqLite::delete_pos(int pos)
{
    int i=0;
    if(empty())
    {
        std::cout<<"顺序表为空"<<std::endl;
        return false;
    }
    if(pos<0 || pos>len)
    {
        std::cout<<"输入位置不合法"<<std::endl;
        return false;
    }
    for(i=pos-1;i<len;i++)
    {
        data[i] = data[i+1];
    }
    len--;
    return true;
}
//访问容器中任意一个元素
datatype &SeqLite::at(int index)
{
    if(index<0 || index>len)
    {
        std::cout<<"输入位置不合法"<<std::endl;
    }
    return data[index-1];
}

//君子函数：二倍扩容
void SeqLite::expend()
{
    size *=2;
    datatype *newdata = new datatype[size];
    for(int i=0;i<len;i++)
    {
        newdata[i] = data[i];
    }
    delete[] data;
    data = newdata;
}

//释放顺序表
void SeqLite::seqfree()
{
    delete[] data;
    data = NULL;
    size = 0;
    len = 0;
}

z1.h

#ifndef Z1_H
#define Z1_H
#include <iostream>

//类型重命名
using datatype = int;

class SeqLite
{
private:
    datatype *data;   //指向堆区空间的指针
    int size;         //数组的大小
    int len;          //顺序表实际长度

public:
    //无参构造
    SeqLite();
    /*
    SeqLite(int s):data(new datatype[s]),size(s),len(0)
    {
        cout<<"有参构造"<<endl;
    }
    */
    //判空函数
    bool empty();
    //判满函数
    bool full();
    //添加数据函数
    bool add(datatype e);
    //求当前顺序表的实际长度
    int length();
    //任意位置插入函数
    bool insert_pos(int pos,datatype e);
    //任意位置删除的函数
    bool delete_pos(int pos);
    //访问容器中任意一个元素
    datatype &at(int index);
    //君子函数：二倍扩容
    void expend();
    //释放顺序表
    void seqfree();

};

#endif // Z1_H