B : DS顺序表--连续操作

Description

建立顺序表的类，属性包括：数组、实际长度、最大长度（设定为1000）

该类具有以下成员函数：

构造函数：实现顺序表的初始化。

插入多个数据的multiinsert(int i, int n, int item[])函数，实现在第i个位置，连续插入来自数组item的n个数据，即从位置i开始插入多个数据。

删除多个数据的multidel(int i, int n)函数，实现从第i个位置开始，连续删除n个数据，即从位置i开始删除多个数据。

编写main函数测试该顺序表类。

Input

第1行先输入n表示有n个数据，即n是实际长度；接着输入n个数据

第2行先输入i表示插入开始的位置，再输入k表示有k个插入数据，接着输入k个数据

第3行先输入i表示删除开始的位置，再输入k表示要删除k个数据

Output

顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开

第1行输出创建后的顺序表内容

第2行输出执行连续插入后的顺序表内容

第3行输出执行连续删除后的顺序表内容

Sample

#0

Input

Copy

6 11 22 33 44 55 66
2 3 99 88 77
4 5

Output

Copy

6 11 22 33 44 55 66 
9 11 99 88 77 22 33 44 55 66 
4 11 99 88 66 

---

 自己做的没有用multiinsert(int i, int n, int item[])

#include<iostream>
using namespace std;
#define ok 0
#define error -1

// 顺序表类定义
class SeqList
{
private:
    int* list;      // 元素数组
    int maxsize;    // 顺序表最大长度
    int size;       // 顺序表实际长度
public:
    SeqList();                          // 构造函数
    ~SeqList();                         // 析构函数
    int list_size();                    // 获取顺序表实际长度
    bool list_insert(int i, int item);   // 插入一个元素，参数是插入的位置  数值
    bool list_del(int i);                // 删除一个元素，参数是删除的位置
    bool list_get(int i);                // 获取一个元素，参数是获取的位置
    void list_display();                // 输出整个顺序表

   
};

SeqList::SeqList()// 构造函数
{
    maxsize = 1000;
    size = 0;
    list = new int[maxsize];
}

SeqList::~SeqList() // 析构函数
{
    delete[]list;
}

// // 获取顺序表实际长度
int SeqList:: list_size() {
    return size;
}


// 插入一个元素，参数是插入的位置 数值
bool SeqList:: list_insert(int i, int item) {
    //判断是不是合法位置i
    if (i<1 || i>size + 1)
    {
        return false;
    }
    int j = size;//list数组从0开始 所以list[size]这个位置是为空的
    for (j = size; j > i - 1; j--)
    {
        list[j] = list[j - 1];//插入就是把数组长度加一位 并且每个单位往后移一位
    }
    list[j] = item;//此时的j对于i-1 也就是在i的位置输入item数据
    size++;//数组总长要+1
    return true;
}

 // 删除一个元素，参数是删除的位置
bool  SeqList:: list_del(int i) {
    //判断是不是合法位置i
    if (i<1 || i>size + 1)
    {
        return false;
    }
    int j;
    for (j = i - 1; j < size - 1; j++)
    {  //j = i - 1 此时j的位置就是i
        list[j] = list[j + 1]; //删除就是后面的数据 把 前面一项的数据覆盖
    }
    size--;//删除 数组长度-1
    return true;
}

// 获取一个元素，参数是获取的位置
bool SeqList::list_get(int i)
{
    if(i<1 || i>size)	
				return false;
			cout<<list[i-1]<<endl;
			return true;
}

//输出列表
void SeqList:: list_display() {
    cout << size << " ";
    for (int i = 0; i < size; i++)
        cout << list[i] << " ";
    cout << endl;
}



int main()
{
    //第1行先输入n表示有n个数据，即n是实际长度；接着输入n个数据
    int n;
    cin >> n;
    //创建顺序表
    SeqList myList;
    //接着输入n个数据
    for (int i = 1; i <= n; i++)
    {
        int num1;
        cin >> num1;
        myList.list_insert(i, num1); 插入一个元素，参数是插入的位置+数值
    }
    // 输出整个顺序表
    myList.list_display();

    //第2行先输入i表示插入开始的位置，再输入k表示有k个插入数据，接着输入k个数据
    int k;
    cin >> n>>k;
    for (int i = n; i < n+k ; i++)//循环k次
    {
        int num;
        cin >> num;
        myList.list_insert(i, num);
    }
    // 输出整个顺序表
    myList.list_display();
    // 第3行先输入i表示删除开始的位置，再输入k表示要删除k个数据
    cin >> n >> k;
    for (int i = n;i<n+k;i++)//循环k次
    {
        myList.list_del(n);//永远都是删除这个下标的数据
    }
    // 输出整个顺序表
    myList.list_display();
}

---

用了multiinsert(int i, int n, int item[])

#include<iostream>
#include<math.h>
#include<string>

using namespace std;

#define ok 0
#define error -1

class SeqList
{
	int* list; //元素数组
	int maxsize;
	int size;
public:
	SeqList()
	{
		maxsize = 1000;
		size = 0;
		list = new int[maxsize];
	}
	~SeqList()
	{
		if (list != NULL)
			delete[]list;
	}
	int list_size();  //获取顺序表的实际长度
	int list_insert(int i, int item); //插入一个元素
	int list_del(int i);
	int list_get(int i);
	void list_display();
	//插入多个数据的multiinsert(int i, int n, int item[])函数，
	//实现在第i个位置，连续插入来自数组item的n个数据，即从位置i开始插入多个数据。
	void multiinsert(int i, int n, int item[])
	{
		for (int p = 0; p < n; p++)
		{
			list_insert(i + p, item[p]);//插入是不断往后插 所以p要变化
		}
	}
	//删除
	void multidel(int i, int n)
	{
		for (int p = 0; p < n; p++)
		{
			list_del(i + 1);//删除每次都是i+1那个位置被删 所以选择定值i
		}
	}
};
int SeqList::list_size()
{
	return size;
}
int SeqList::list_insert(int i, int item)
{
	if (i<1 || i>size + 1)
	{
		return -1;
	}
	for (int q = size; q > i - 1; q--)
	{
		if (q > 0)
			list[q] = list[q - 1];
	}
	list[i - 1] = item;
	size++;
	return ok;
}
int SeqList::list_del(int i)
{
	if (i<1 || i>size + 1)
	{
		return -1;
	}
	//if (i != size)
	//{
	for (int q = i - 1; q < size; q++)
	{
		if (q > 0)
			list[q - 1] = list[q];
	}
	//}
	size--;
	return ok;
}
int SeqList::list_get(int i)
{
	if (i<1 || i>size + 1)
	{
		return -1;
	}
	return list[i - 1];
}
void SeqList::list_display()
{
	cout << size << " ";
	for (int i = 0; i < size; ++i)
	{
		cout << list[i] << " ";
	}
	cout << endl;
}

int main(void)
{
	int n;
	cin >> n;
	SeqList p;
	int number[128];
	for (int i = 0; i < n; ++i)
	{
		cin >> number[i];
	}
	p.multiinsert(1, n, number);
	p.list_display();
	int i;
	cin >> i >> n;
	for (int i = 0; i < n; ++i)
	{
		cin >> number[i];
	}
	p.multiinsert(i, n, number);
	p.list_display();
	cin >> i >> n;
	p.multidel(i, n);
	p.list_display();
	return 0;
}

---

小结：二者的核心思路都是一样的 只是有没有封装成函数

插入时候 下标要不断往后移

删除 下标不变