DS顺序表基础题 c++

A.顺序表的类实现

用C++语言和类实现顺序表

属性包括：数组、实际长度、最大长度（设定为1000）

操作包括：创建、插入、删除、查找

输入

第1行先输入n表示有n个数据，即n是实际长度；接着输入n个数据
第2行输入要插入的位置和新数据
第3行输入要插入的位置和新数据
第4行输入要删除的位置
第5行输入要删除的位置
第6行输入要查找的位置
第7行输入要查找的位置

输出

数据之间用空格隔开
第1行输出创建后的顺序表内容，包括顺序表实际长度和数据
每成功执行一次操作（插入或删除），输出执行后的顺序表内容
每成功执行一次查找，输出查找到的数据
如果执行操作失败（包括插入、删除、查找等失败），输出字符串error，不必输出顺序表内容

样例输入

6 11 22 33 44 55 66
3 777
1 888
1
9
0
5

样例输出

6 11 22 33 44 55 66
7 11 22 777 33 44 55 66
8 888 11 22 777 33 44 55 66
7 11 22 777 33 44 55 66
error
error
44

题解

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

// 顺序表类定义
class SeqList
{
private:
    int *list;      // 元素数组
    int maxsize;    // 顺序表最大长度
    int size;       // 顺序表实际长度
public:
    SeqList();                          // 构造函数
    ~SeqList();                         // 析构函数
    int list_size()
    {
        return size;
    }                   // 获取顺序表实际长度

    int list_insert(int i, int item)
    {
        if(i<1 || i>size+1)
        {
            cout<<"error"<<endl;
            return error;
        }
        for(int j=size;j>i-1;j--)
        {
            list[j]=list[j-1];
        }
        list[i-1]=item;
        size++;
        list_display();
        return ok;
    }  // 插入一个元素，参数是插入的数值和位置

    int list_del(int i)
    {
        if(i<1 || i>size)
        {
            cout<<"error"<<endl;
            return error;
        }
        for(int j=i-1;j<size;j++)
        {
                list[j]=list[j+1];
        }
        size--;
        list_display();
        return ok;
    }           // 删除一个元素，参数是删除的位置

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

    void list_display()
    {
            cout<<size<<" ";
            for(int i=0;i<size;i++)
            {
                cout<<list[i]<<" ";
            }
            cout<<endl;
    }                // 输出整个顺序表

    void list_initlist()
    {
        int n;
        cin>>n;
        if(n>=0 && n<=maxsize)
        {
            for(int i=0;i<n;i++)
            {
                cin>>*(list+i);
                size++;
            }
        }
        list_display();
    }			//输入顺序表初始数据
};

SeqList::SeqList()
{
    maxsize = 1000;
    size = 0;
    list = new int[maxsize];
}
SeqList::~SeqList()
{
    delete []list;
}

int main()
{
	SeqList res;
	res.list_initlist();
	int it,num;
	cin >> it >> num;
	res.list_insert(it,num);
	cin >> it >> num;
	res.list_insert(it,num);
	cin >> it;
	res.list_del(it);
	cin >> it;
	res.list_del(it);
	cin >> it;
	res.list_get(it);
	cin >> it;
	res.list_get(it);
	return 0;
}

---

B. DS顺序表–连续操作

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

该类具有以下成员函数：

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

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

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

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

输入

第1行先输入n表示有n个数据，即n是实际长度；接着输入n个数据
第2行先输入i表示插入开始的位置，再输入k表示有k个插入数据，接着输入k个数据
第3行先输入i表示删除开始的位置，再输入k表示要删除k个数据

输出

顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开
第1行输出创建后的顺序表内容
第2行输出执行连续插入后的顺序表内容
第3行输出执行连续删除后的顺序表内容

样例输入

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

样例输出

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

题解

将模板里的 insert 和 del 放入循环里，构成连续删除、插入 n 个数据的新函数，并在函数末尾调用 list_display 输出即可。

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

const int maxn = 1100;
int item[maxn] = {0};
// 顺序表类定义
class SeqList
{
private:
    int *list;      // 元素数组
    int maxsize;    // 顺序表最大长度
    int size;       // 顺序表实际长度
public:
    SeqList();                          // 构造函数
    ~SeqList();                         // 析构函数
    int list_size()
    {
        return size;
    }                   // 获取顺序表实际长度

    int list_insert(int i, int item)
    {
        if(i<1 || i>size+1)
        {
            cout<<"error"<<endl;
            return error;
        }
        for(int j=size;j>i-1;j--)
        {
            list[j]=list[j-1];
        }
        list[i-1]=item;
        size++;
        //list_display();
        return ok;
    }  // 插入一个元素，参数是插入的数值和位置

    int list_del(int i)
    {
        if(i<1 || i>size)
        {
            cout<<"error"<<endl;
            return error;
        }
        for(int j=i-1;j<size;j++)
        {
                list[j]=list[j+1];
        }
        size--;
        //list_display();
        return ok;
    }           // 删除一个元素，参数是删除的位置

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

    void list_display()
    {
            cout<<size<<" ";
            for(int i=0;i<size;i++)
            {
                cout<<list[i]<<" ";
            }
            cout<<endl;
    }                // 输出整个顺序表

    void list_initlist()
    {
        int n;
        cin>>n;
        if(n>=0 && n<=maxsize)
        {
            for(int i=0;i<n;i++)
            {
                cin>>*(list+i);
                size++;
            }
        }
        list_display();
    }			//输入顺序表初始数据
    
    void multiinsert(int i,int n,int item[])
    {
    	for(int j = 0; j < n; j++)
    		list_insert(i+j,item[j]);
    	list_display();
	}
	
	void multidel(int i,int n)
	{
		for(int j = 0; j < n; j++)
			list_del(i);
		list_display();
	}
};

SeqList::SeqList()
{
    maxsize = 1000;
    size = 0;
    list = new int[maxsize];
}
SeqList::~SeqList()
{
    delete []list;
}

int main()
{
	SeqList res;
	res.list_initlist();
	
	int i,k;	
	cin >> i >> k;
	for(int j = 0; j < k; j++)
		cin >> item[j];
	res.multiinsert(i,k,item);
	
	cin >> i >> k;
	res.multidel(i,k);
	
	return 0;
}

C. DS顺序表–合并操作

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

已知两个递增序列，把两个序列的数据合并到顺序表中，并使得顺序表的数据递增有序

输入

第1行先输入n表示有n个数据，接着输入n个数据，表示第1个序列，要求数据递增互不等

第2行先输入m表示有m个数据，接着输入m个数据，表示第2个序列，要求数据递增互不等

输出

顺序表内容包括顺序表的实际长度和数据，数据之间用空格隔开
第1行输出创建后的顺序表内容

样例输入

3 11 33 55
5 22 44 66 88 99

样例输出

8 11 22 33 44 55 66 88 99

题解

题目给出两个递增序列，那么传入数据为 (int item1[],int n, int item2[],int m)，更新 size += n+m 。然后循环并判断哪个数值小就塞入数组中。不过要判断数组是否遍历完。

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

const int maxn = 1100;
int item1[maxn] = {0}, item2[maxn] = {0};
// 顺序表类定义
class SeqList
{
private:
    int *list;      // 元素数组
    int maxsize;    // 顺序表最大长度
    int size;       // 顺序表实际长度
public:
    SeqList();                          // 构造函数
    ~SeqList();                         // 析构函数
    int list_size()
    {
        return size;
    }                   // 获取顺序表实际长度

    int list_insert(int i, int item)
    {
        if(i<1 || i>size+1)
        {
            cout<<"error"<<endl;
            return error;
        }
        for(int j=size;j>i-1;j--)
        {
            list[j]=list[j-1];
        }
        list[i-1]=item;
        size++;
        //list_display();
        return ok;
    }  // 插入一个元素，参数是插入的数值和位置

    int list_del(int i)
    {
        if(i<1 || i>size)
        {
            cout<<"error"<<endl;
            return error;
        }
        for(int j=i-1;j<size;j++)
        {
                list[j]=list[j+1];
        }
        size--;
        //list_display();
        return ok;
    }           // 删除一个元素，参数是删除的位置

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

    void list_display()
    {
            cout<<size<<" ";
            for(int i=0;i<size;i++)
            {
                cout<<list[i]<<" ";
            }
            cout<<endl;
    }                // 输出整个顺序表

    void list_initlist()
    {
        int n;
        cin>>n;
        if(n>=0 && n<=maxsize)
        {
            for(int i=0;i<n;i++)
            {
                cin>>*(list+i);
                size++;
            }
        }
        list_display();
    }			//输入顺序表初始数据
	
	//合并操作
	void list_merge(int item1[],int n,int item2[], int m)
	{
		size = n + m;		
		//双指针
		int tp1 = 0,tp2 = 0;
		for(int i = 0; i < size; i++)
		{
			// tp2 遍历完，tp1 未遍历完，且 item1更小，塞入item1
			if(tp2 == m || (tp1 < n && item1[tp1] < item2[tp2]))
			{
				*(list+i) = item1[tp1++];
			}
			// 塞入 item2 的情况
			else if(tp1  == n || (tp2 < m && item1[tp1] > item2[tp2]))
			{
				*(list+i) = item2[tp2++];
			}	
		}
		list_display();
	}
};

SeqList::SeqList()
{
    maxsize = 1000;
    size = 0;
    list = new int[maxsize];
}
SeqList::~SeqList()
{
    delete []list;
}

int main()
{
	SeqList res;
	//
	int n,m;
	cin >> n;
	for(int i = 0; i < n; i++)
		cin >> item1[i];
	//	
	cin >> m;
	for(int i = 0; i < m; i++)
		cin >> item2[i];
	//
	res.list_merge(item1,n,item2,m);
		
	return 0;
}

D. DS顺序表之循环移位

顺序表的移位是循环移位，例如顺序表：1，2，3，4，5，6。如果左移1位，即原来的头元素移动到末尾，其它元素向左移1位，变成2，3，4，5，6，1。同理，如果右移1位，即原来的尾元素移动到头，其它元素向右移1位，变成6，1，2，3，4，5。以下是移位的多个例子：

原数据：1，2，3，4，5，6

左移3位：4，5，6，1，2，3，与原数据对比

右移4位：3，4，5，6，1，2，与原数据对比

请编写程序实现顺序表的循环移位操作

输入

第1行输入n表示顺序表包含的·n个数据
第2行输入n个数据，数据是小于100的正整数
第3行输入移动方向和移动的位数，左移方向为0，右移方向为1
第4行输入移动方向和移动的位数，左移方向为0，右移方向为1
注意：移动操作是针对上一次移动后的结果进行的

输出

第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开
第二行输出第一次移位操作后，顺序表内的所有数据，数据之间用空格隔开
第三行输出第二次移位操作后，顺序表内的所有数据，数据之间用空格隔开

样例输入

5
11 22 33 44 55
0 2
1 4

样例输出

11 22 33 44 55
33 44 55 11 22
44 55 11 22 33

题解

核心代码
单独右移 new_list[(i+n)%size] = list[i]
单独左移new_list[(i-n+size)%size] = list[i] 我们需要 +size 来防止出现负数导致数组越界

这里我们合并二式，得到new_list[(i+n+size)%size] = list[i] ，再通过 Judge 判断左右移动，左移则令 n 未负数来代替减号即可。

void list_cshift(int judge,int n)
	{
		int *new_list = new int[size];
		//判断是否左移
		if(!judge) n = -n;
		
		for(int i = 0; i < size; i++)
		{
			//存入新数组
			new_list[(i+n+size)%size] = list[i];
		}
		for(int i = 0; i < size; i++)
		{
			list[i] = new_list[i];
		}
		delete []new_list;
		list_display();
	}

完整代码

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

const int maxn = 1100;
int item1[maxn] = {0}, item2[maxn] = {0};
// 顺序表类定义
class SeqList
{
private:
    int *list;      // 元素数组
    int maxsize;    // 顺序表最大长度
    int size;       // 顺序表实际长度
public:
    SeqList();                          // 构造函数
    ~SeqList();                         // 析构函数
    int list_size()
    {
        return size;
    }                   // 获取顺序表实际长度

    int list_insert(int i, int item)
    {
        if(i<1 || i>size+1)
        {
            cout<<"error"<<endl;
            return error;
        }
        for(int j=size;j>i-1;j--)
        {
            list[j]=list[j-1];
        }
        list[i-1]=item;
        size++;
        //list_display();
        return ok;
    }  // 插入一个元素，参数是插入的数值和位置

    int list_del(int i)
    {
        if(i<1 || i>size)
        {
            cout<<"error"<<endl;
            return error;
        }
        for(int j=i-1;j<size;j++)
        {
                list[j]=list[j+1];
        }
        size--;
        //list_display();
        return ok;
    }           // 删除一个元素，参数是删除的位置

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

    void list_display()
    {
            //cout<
            for(int i=0;i<size;i++)
            {
                cout<<list[i]<<" ";
            }
            cout<<endl;
    }                // 输出整个顺序表

    void list_initlist()
    {
        int n;
        cin>>n;
        if(n>=0 && n<=maxsize)
        {
            for(int i=0;i<n;i++)
            {
                cin>>*(list+i);
                size++;
            }
        }
        list_display();
    }			//输入顺序表初始数据
	
	void list_cshift(int judge,int n)
	{
		int *new_list = new int[size];
		if(!judge) n = -n;
		
		for(int i = 0; i < size; i++)
		{
			new_list[(i+n+size)%size] = list[i];
		}
		for(int i = 0; i < size; i++)
		{
			list[i] = new_list[i];
		}
		delete []new_list;
		list_display();
	}
};

SeqList::SeqList()
{
    maxsize = 1000;
    size = 0;
    list = new int[maxsize];
}
SeqList::~SeqList()
{
    delete []list;
}

int main()
{
	SeqList res;
	res.list_initlist();
	
	int judge,n;
	cin >> judge >> n;
	res.list_cshift(judge,n);
	cin >> judge >> n;
	res.list_cshift(judge,n);
		
	return 0;
}