利用顺序表的操作，实现以下的函数。

Posted 2021-11-10 Roam-G

(1) 从顺序表中删除具有最小值的元素并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。

(2) 从顺序表中删除第i个元素并由函数返回被删元素的值。如果i不合理或顺序表为空则显示出错信息并退出运行。

(3) 向顺序表中第i个位置插入一个新的元素x。如果i不合理则显示出错信息并退出运行。

(4) 从顺序表中删除具有给定值x的所有元素。

(5) 从顺序表中删除其值在给定值s与t之间（要求s小于t）的所有元素，如果s或t不合理或顺序表为空则显示出错信息并退出运行。

(6) 从有序顺序表中删除其值在给定值s与t之间（要求s小于t）的所有元素，如果s或t不合理或顺序表为空则显示出错信息并退出运行。

(7) 将两个有序顺序表合并成一个新的有序顺序表并由函数返回结果顺序表。

(8) 从顺序表中删除所有其值重复的元素，使表中所有元素的值均不相同。

//順序表的定義
#ifndef SEQLIST_H //定义在头文件“seqlist.h”中
#define SEQLIST_H
#include < iostream>
#include <stdlib.h>
template <class Type>
class SeqList
{
private:
    Type *data;  //顺序表的存放数组
    int MaxSize; //顺序表的最大可容纳项数
    int last;    //顺序表当前已存表项的最后位置
    int current; //顺序表的当前指针（最近处理的表项）
public:
    SeqList(int MaxSize);                     //构造函数
    ~SeqList() { delete[] data; }             //析构函数
    int MaxLength() const { return MaxSize; } //求表的最大长度
    int Length() const { return last + 1; }   //计算表长度
    int Find(Type x) const;                   //定位函数: 找x位置，置为当前表项
    void Locate(int i) { i >= 0 &&i <= last ? current = i : exit(1); }
    //定位函数: 第i项置为当前表项
    int IsIn(Type x);                                               //判断x是否在表中，不置为当前表项
    Type *GetData() { return current == -1？NULL : data[current]; } //取当前表项的值
    int Insert(Type x);                                             //插入x在表当前表项之后，置为当前表项
    int Append(Type x);                                             //追加x到表尾，置为当前表项
    Type *Remove();                                                 //删除当前表项，置下一表项为当前表项
    Type *First();                                                  //取表中第一个表项的值，置为当前表项
    Type *Next() { return current < last ? &data[++current] : NULL; }
    //取当前表项后继表项的值，置为当前表项
    Type *Prior() { return current > 0 ? &data[--current] : NULL; }
    //取当前表项前驱表项的值，置为当前表项
    int IsEmpty() { return last == -1; }         //判断顺序表空否, 空则返回1; 否则返回0
    int IsFull() { return last == MaxSize - 1; } //判断顺序表满否, 满则返回1; 否则返回0
}
#endif
// (1)实现删除具有最小值元素的函数如下：
template<Type>
Type *DelMin(SeqList<Type> *L)
{
    if (L->Length() == 0) //表空, 中止操作返回
    {
        cerr << " List is Empty !  " << endl;
        exit(1);
    }
    Type min = *L->First(), *temp; //假定0号元素的值最小
    for (int i = 1; i < L->Length(); i++)
    {                     //循环, 寻找具有最小值的元素
        temp = L->Next(); //下一个表项定位为当前表项
        if (*temp < min)
            min = *temp; //让min记忆当前具最小值的元素
    }
    L->Find(min);
    temp = L->Remove(); //定位于min所在表项，删除之
    return temp;
}
// (2) 实现删除第i个元素的函数如下（设第i个元素在data[i], i = 0, 1, , last）： template <Type>
Type *DelNo #i(SeqList<Type> *L, int i)
{
    if (L->Length() == 0 || i < 0 || i >= L->Length()) //表空或i不合理, 中止操作
    {
        cerr <<"  List is Empty or Parameter is out range ! " << endl;
        exit(1);
    }
    L->Locate(i);             //定位于第i个元素
    Type *temp = L->Remove(); //删除
    return temp;
}
// (3) 实现向第i个位置插入一个新的元素x的函数如下（设第i个元素在data[i], i = 0, 1, , last）： template <Type>
void InsNo #i(SeqList<Type> *L, int i, Type x)
{
    if (L->IsFull() || i < 0 || i >= L->Length()) //表满或参数i不合理, 中止操作返回
    {
        cerr << " List is Full or Parameter is out range ! " << endl;
        exit(1);
    }
    L->Locate(i); //定位于第i个元素
    L->Insert(x); //在第i个位置插入
}
// (4) 从顺序表中删除具有给定值x的所有元素。
template <Type>
void DelValue(SeqList<Type> *L, Type x)
{
    int i = 0;
    Type *temp = L->First();
    while (i < L->Length()) //循环, 寻找具有值x的元素并删除它
        if (*temp == x)
            L->Remove(); //删除具有值x的元素
        else
        {
            temp = L->Next();
            i++;
        }
}
// (5) 实现删除其值在给定值s与t之间（要求s小于t）的所有元素的函数如下：
template <Type>
void DelNo #sto #t(SeqList<Type> *L, Type s, Type t)
{
    if (L->Length() == 0 || s >= t)
    {
        cerr << "List is empty or parameters are illegal !" << endl;
        exit(1);
    }
    int i = 0;
    Type *temp = L->First();
    while (i < L->Length())           //循环, 寻找界于s与t之间的元素并删除它
        if (*temp >= s && *temp <= t) //删除满足条件的元素
            L->Remove();
        else
        {
            temp = L->Next();
            i++;
        }
}
// (6) 实现从有序顺序表中删除其值在给定值s与t之间的所有元素的函数如下：
template <Type>
void DelNo #sto #t1(SeqList<Type> *L, Type s, Type t)
{
    if (L->Length() == 0 || s >= t)
    {
        cerr << "List is empty or parameters are illegal ! "<< endl;
        exit(1);
    }
    int i = 0;
    Type *temp = L->First();
    while (i < L->Length()) //循环, 寻找值 ≥s 的第一个元素
        if (*temp >= s)
            break; //退出循环时, 该元素成为当前表项
        else
        {
            temp = L->Next();
            i++;
        } //否则, 继续寻找
    while (i < L->Length() && *temp <= t)
    {
        L->Remove();
        temp = L->GetData();
    }
}
// (7) 实现将两个有序顺序表合并成一个新的有序顺序表的函数如下：
template <Type>
SeqList<Type> Merge(SeqList<Type> A, SeqList<Type> B)
{
    //合并有序顺序表A与B成为一个新的有序顺序表并由函数返回
    SeqList<Type> temp;
    if (A.Length() + B.Length() > temp.MaxLength())
    {
        cerr << "The summary of The length of Lists is out MaxSize !"<< endl;
        exit(1);
    }
    Type *value1 = A.First(), *value2 = B.First();
    int i = 0, j = 0;
    while (i < A.length() && j < B.length())
    { //循环, 两两比较, 小者存入结果表
        if (*value1 <= *value2)
        {
            temp.Append(*value1);
            *value1 = A.Next();
            i++;
        }
        else
        {
            temp.Append(*value2);
            *value2 = B.Next();
            j++;
        }
    }
    while (i < A.Length()) //当A表未检测完, 继续向结果表传送
    {
        temp.Append(*value1);
        *value1 = A.Next();
        i++;
    }
    while (j < B.Length()) //当B表未检测完, 继续向结果表传送
    {
        temp.Append(*value2);
        *value2 = B.Next();
        j++;
    }
    return temp;
}
// (8) 实现从表中删除所有其值重复的元素的函数如下：
template <Type>
void SeqList<Type>::DelDouble()
{
    if (L->IsEmpty())
    {
        cerr << " List is empty !" << endl;
        exit(1);
    }
    int i = 0, j;
    Type *temp1 = L->First(), *temp2;
    while (i < L->Length() - 1)
    { //循环检测
        j = i + 1;
        temp2 = L->Next();
        while (j < L->Length())   //对于每一个i, 重复检测一遍后续元素
            if (*temp1 == *temp2) //如果相等, 删除
            {
                L->Remove();
                *temp2 = L->GetData();
            }
            else
            {
                *temp2 = L->Next();
                j++;
            }
        L->Locate(++i);
        *temp1 = L->GetData();
    }
}