c++实验2 顺序存储线性表

线性表顺序存储

实现了动态数组的增删改查  前驱后继  A=AUB 动态数组右移

（1）顺序表存储结构的定义(类的声明)：

class SeqList
{
protected:
    DataType *list;                           //数组
    int maxSize;                              //最大元素个数
    int size;                                 //当前元素个数
public:
    SeqList();                                   //无参构造
    SeqList(int max=0);
    SeqList(DataType a[],int max=0);            //构造函数
    ~SeqList(void);                           //析构函数
    int Size(void) const;                      //取当前数据元素个数
    void Insert(const DataType& item,int i);  //插入
    DataType Delete(const int i);             //删除
    DataType GetData(int i) const;            //取数据元素
       DataType getall();                          //得到所有元素
    DataType finde(DataType e);                 //查询e
    bool isnull();                               //判表空算法
    DataType before(DataType e);                 //找到前驱
    DataType after(DataType e);                 //找到后继
};

（2）初始化顺序表算法实现（不带参数的构造函数）

SeqList::SeqList()
{
    maxSize=0;
    size=0;
    list=new DataType[maxSize];
}

（3）顺序表的建立算法（带参数的构造函数）

SeqList::SeqList(DataType a[],int n)                   //构造函数
{
    maxSize=n;
    size=0;
    list=new DataType[maxSize];
    int b=sizeof(a)/sizeof(DataType);
    for(int i=0;i<b;i++)
        list[i]=a[i];
    size=b;
}

（4）在顺序表的第i个位置前插入元素e算法

void SeqList::Insert(const DataType& e,int i)    //插入
//在指定位置i前插入一个数据元素item
{
    //从size-1至i逐个元素后移
    for(int j=size;j>i;j--)
        list[j]=list[j-1];
    list[i]=e;                              //在i位置插入item
    size++ ;                                          //当前元素个数加1
}

（5）删除线性表中第i个元素算法

DataType SeqList::Delete(const int i)      //删除
//删除指定位置i的数据元素，删除的元素由函数返回
{
     //判断删除位置 i 的合法性
    DataType x=list[i];             //取到要删除的元素
    //从i+1至size-1逐个元素前移
    for(int j=i;j<size-1;j++) 
list[j]=list[j+1];
    size--;                                //当前元素个数减1
    return x;                              //返回删除的元素
}

（6）遍历线性表元素算法

DataType SeqList::getall()
{
    
    for(int i=0;i<Size();i++)
        cout<<list[i];
}

（7）获得线性表长度算法

int SeqList::Size(void) const        //取当前数据元素个数
{
    return size;
}

（8）在顺序线性表中查找e值，返回该元素的位序算法

DataType SeqList::finde(DataType e)
{
    for(int i=0;i<Size();i++)
        {
        if(list[i]==e)
            return i;
        }
    return -1;
}

（9）获得顺序线性表第i个元素的值

DataType SeqList::GetData(int i) const    //取数据元素
//取位置i的数据元素，取到的数据元素由函数返回
{
    
    return list[i];                       //返回取到的元素
}

（10）判表空算法

bool SeqList::isnull()
{
    if(size>0)
        return 1;
    else 
        return 0;
    
}

(11)求直接前驱结点算法

DataType SeqList::before(DataType e)
{
   if(finde(DataType e)>1)
        return GetData(finde(DataType e)-1);
   else
   {
       cout<<"没有找到"<<endl;
        return -1;
   }  
}

(12)求直接后继结点算法

DataType SeqList::before(DataType e)
{
   if(finde(DataType e)<size)
        return GetData(finde(DataType e)+1);
   else
   {
       cout<<"没有找到"<<endl;
        return -1;
   }  
}

（13）实现A=AUB算法。

DataType SeqList::AUB(SeqList s1)
{
    SeqList s2(200);
    int mina=0,minb=0;
    for(int i=0;i<this->size+s1.size-1;i++)
    {

        if(this->GetData(mina)>s1.GetData(minb))
        {
            s2.Insert(s1.GetData(minb),i);
            minb++;
        }
        else if(this->GetData(mina)<s1.GetData(minb))
        {
            s2.Insert(GetData(mina),i);
            mina++;
        }
        else
        {
           s2.Insert(s1.GetData(minb),i);
           mina++;
           minb++;
        }
    }
    if(this->GetData(mina)!=0)
        s2.Insert(GetData(mina),size+s1.size-1);
    else
        s2.Insert(s1.GetData(minb),size+s1.size-1);
    cout<<"
AUB=";
    s2.getall();
return 0;
}

（14）对以上顺序表类中的基本操作算法适当加以补充，实现向一个有序的（非递减）的顺序表中插入数据元素e算法。

void SeqList::Insert1(const DataType& e)
{
    int count=0;
    for(int i=0;i<size;i++)
    {
        if(e>list[i-1]&&e<list[i])
            count=i;
    }
    Insert(e,count);
}

（15）用算法实现将线性表循环右移k位。（m=k%L.length,每次取最后一个元素，插入到第１个位置，做m次）

void SeqList::turnright(int k)
{
    int count=0;
    int c=size;
    for(int j=size;j>0;j--)
    {
        list[j+k]=list[j];

        count++;
    }
    size=size+k;
    for(int j=0;j<count;j++)
        list[j]=0;
    for(int m=0,f=size;m<k%c+1;m++,f--)
    {
        Insert(list[f],m);
    }
}