数据结构PTA练习题3

m0_73685288

已于 2023-10-04 09:56:44 修改

阅读量115

点赞数

文章标签：数据结构算法

于 2023-09-23 13:53:41 首次发布

本文链接：https://blog.csdn.net/m0_73685288/article/details/133201524

版权

1. 线性表1

小唐正在学习线性表，他不会写线性表的基本操作。请身为大牛的你帮帮他吧。要对线性表做如下m个操作。

(1) 在第k个位置插入数据x : I k x

(2) 删除第k个位置的数据： E k

(3) 修改第k个位置的数据为x：U k x

(4) 查询第k个位置的数据： Q k

输入格式:

第1行，一个整数m，表示操作的个数，1≤m≤10000.

第2至m+1行，每行1个操作。操作的规定如题目描述。1≤k≤m，|x|≤100000000.若查询操作不合法，则返回-1；若其它操作不合法，则放弃该操作。

输入确保数据符合规定。

输出格式:

若干行,每行一个整数，依次表示查询操作的结果。

代码长度限制-16 KB

时间限制-1000 ms

内存限制-1 MB

完整代码：

没什么好说的，顺序表增删改查操作练习

#include<iostream>
using namespace std;

int main()
{
	int m;
	cin >> m;
	int list[10000];//数组存储线性表
	int length = 0;//线性表长度
	for (int i = 1; i <= m; i++)
	{
		char operation;
		int k,x;
		cin >> operation;
		if (operation == 'I')
		{
			cin >> k >> x;
			if (k >= 1 && k <= length + 1)
			{
				for (int j = length; j >= k; j--)
					list[j] = list[j - 1];
				list[k - 1] = x;
				length++;
			}
		}
		else if (operation == 'E')
		{
			cin >> k;
			if (k >= 1 && k <= length)
			{
				for (int j = k; j < length; j++)
					list[j - 1] = list[j];
				length--;
			}
		}
		else if (operation == 'U')
		{
			cin >> k >> x;
			if (k >= 1 && k <= length)
			{
				list[k - 1] = x;
			}
		}
		else if (operation == 'Q')
		{
			cin >> k;
			if (k >= 1 && k <= length)
				cout << list[k - 1] << endl;
			else 
				cout << -1 << endl;
		}

	}
	return 0;
}

2. 报数游戏

n个人围成一圈，从1开始依次编号，做报数游戏。现指定从第1个人开始报数，报数到第m个人时，该人出圈，然后从其下一个人重新开始报数，仍是报数到第m个人出圈，如此重复下去，直到所有人都出圈。总人数不足m时将循环报数。请输出所有人出圈的顺序。

输入格式:

一行，两个整数n和m。n表示游戏的人数，m表示报数出圈的数字，1≤n≤50000，1≤m≤100.

输出格式:

一行，n个用空格分隔的整数，表示所有人出圈的顺序

代码长度限制-16 KB

时间限制-400 ms

内存限制-64 MB

完整代码：

循环链表，约瑟夫问题，一边遍历一边将删除的结点flag置1

#include <iostream>
using namespace std;

struct node {
 int n;
 int flag = 0;
 node* next;
};

int main(void)
{
 int N, M;
 cin >> N >> M;
 int i;
 node* p, * q, * head;
 p = new node;
 p->flag = 0;
 p->n = 1;
 p->next = NULL;
 head = p;
 for (i = 2; i <= N; i++) {
  q = new node;
  q->n = i;
  q->flag = 0;
  p->next = q;
  p = q;
 }
 p->next = head;
 q = p;
 p = head;
 N--;
 while (N--) {
  for (i = 1; i < M; i++) {
    p = p->next;
    q = q->next;
   }
  p->flag = 1;
  cout << p->n << " ";
  q->next = p->next;
  p = q->next;
 }
 
 while (p->flag != 1) {
  cout << p->n ;
  p = p->next;
  break;
 }
 
}

3. 文字编辑

一篇文章由n个汉字构成，汉字从前到后依次编号为1，2，……，n。
有四种操作：

A i j表示把编号为i的汉字移动编号为j的汉字之前；

B i j表示把编号为i的汉字移动编号为j的汉字之后；

Q 0 i为询问编号为i的汉字之前的汉字的编号；

Q 1 i为询问编号为i的汉字之后的汉字的编号。

规定：1号汉字之前是n号汉字，n号汉字之后是1号汉字。

输入格式:

第1行，1个整数T，表示有T组测试数据， 1≤T≤9999.

随后的每一组测试数据中，第1行两个整数n和m，用空格分隔，分别代表汉字数和操作数，2≤n≤9999，1≤m≤9999；第2至m+1行，每行包含3个常量s、i和j，用空格分隔，s代表操作的类型，若s为A或B，则i和j表示汉字的编号，若s为Q，i代表0或1，j代表汉字的编号。

输出格式:

若干行，每行1个整数，对应每个询问的结果汉字编号。

代码长度限制-16 KB

时间限制-1000 ms

内存限制-2 MB

完整代码：

运用静态链表版跳舞链进行高效插入和删除，特征为元素固定，只调整链接

#include<iostream>
#include<string>
#include<stdio.h>
using namespace std;
int l[10001];//左索引
int r[10001];//右索引
void creat(int n)
{
	for (int i = 1; i <= n; i++)
	{
		l[i] = i - 1;
		r[i] = i + 1;
	}
	r[n] = 1;
	l[1] = n;
}
void del_A(int i, int j)//删除i元素，并改变i的左右指针以便插入j前 
{
	r[l[i]] = r[i];
	l[r[i]] = l[i];
	r[i] = j;
	l[i] = l[j];
}
void del_B(int i, int j)//删除i元素，并改变i的左右指针以便插入j后 
{
	r[l[i]] = r[i];
	l[r[i]] = l[i];
	l[i] = j;
	r[i] = r[j];
}

void ins(int x)
{
	r[l[x]] = x;
	l[r[x]] = x;
}
void func(char s[], int i, int j, int n)
{
	if (s[0] == 'A')
	{
		del_A(i, j);
		ins(i);
	}
	else if (s[0] == 'B')
	{
		del_B(i, j);
		ins(i);
	}
	else if (s[0] == 'Q')
	{
		if (i == 0)
		{
			printf("%d\n", l[j]);
		}
		else if (i == 1)
		{
			printf("%d\n", r[j]);
		}
	}
}

int main()
{
	int T; 
	cin >> T;
	int n, m;
	char s[3];
	int x, y;
	for (int i = 1; i <= T; i++)
	{
		scanf("%d%d", &n, &m);
		creat(n);
		for (int j = 1; j <= m; j++)
		{
			scanf("%s%d%d", s, &x, &y);
			func(s, x, y, n);
		}
	}
}

4. 线性表2

小唐正在学习线性表，他又遇到了线性表的操作问题。请身为大牛的你再帮帮他吧。具体来说，要对线性表做如下操作。

（1）在表头插入数据x :    I 1 x

（2）在表尾插入数据x :    I 2 x

（3）在当前位置后插入x ： I 3 x

（4）查询数据x是否存在：   Q x

（5）删除表头结点:         E 1

（6）删除表尾结点：        E 2

（7）删除当前位置的结点： E 3

当前位置：初始化为0或特殊值；插入操作后为插入的结点；查询操作，存在则为找到的第一个结点，不存在则不改变；如果当前结点被删除，当前位置回归初始值。

输入格式:

第1行，一个整数m，表示操作的个数，1≤m≤100000.

第2至m+1行，每行1个操作。操作的规定如题目描述。|x|≤100000000.若操作不合法，则放弃该操作。

输入确保数据符合规定。

输出格式:

若干行,每行一个整数，依次表示查询操作的结果。如果存在，输出1，否则输出0。

查询操作不超过20个

代码长度限制-16 KB

时间限制-30 ms

内存限制-64 MB

完整代码：

运用双向链表正常操作即可，难点是注意指针的改变以及当前位置的变化

#include <stdio.h>
#include <stdlib.h>
#include<iostream>
using namespace std;

typedef struct Node {
    int value;
    struct Node* next;
    struct Node* prev;
} Node;//双向链表

//对指针进行管理
Node* head = NULL;
Node* tail = NULL;
Node* curr = NULL;

//从头插入
void insertHead(int x) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    //插入
    newNode->value = x;
    //头节点非空
    if (head) {
        head->prev = newNode;
        newNode->next = head;
        newNode->prev = NULL;
        head = newNode;
        curr = newNode;
    }
    //头结点为空
    else {
        newNode->next = NULL;
        newNode->prev = NULL;
        tail = newNode;
        head = newNode;
        curr = newNode;
    }
}
//从表尾插入
void insertTail(int x) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->value = x;
    newNode->next = NULL;
    newNode->prev = tail;
    if (tail) {
        //链表非空，直接插入
        tail->next = newNode;
    }
    else {
        head = newNode;
    }
    //指针维护
    tail = newNode;
    curr = newNode;
}
//从当前位置后插入
void insertAfterCurr(int x) {
    //当前指针为空，插入到头
    if (!curr) {
        insertHead(x);
        return;
    }
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->value = x;
    newNode->next = curr->next;
    newNode->prev = curr;
    if (curr->next) {
        curr->next->prev = newNode;
    }
    else {
        tail = newNode;
    }
    curr->next = newNode;
    curr = newNode;
}
//查询数据x是否存在
int query(int x) {
    Node* temp = head;
    while (temp) {
        if (temp->value == x) {
            curr = temp;
            return 1;
        }
        temp = temp->next;
    }
    return 0;
}
//从表头删除
void eraseHead() {
    //头节点为空
    if (!head) return;
    //判断当前节点是否为头节点
    if (curr == head) curr = NULL;//注意当前位置的变化
    Node* temp = head;//暂时保存，方便后续释放
    head = head->next;
    //判断节点数是否为1
    if (head) {
        head->prev = NULL;
    }
    else {
        tail = NULL;
    }
    free(temp);
}
//从表尾删除
void eraseTail() {
    //判断尾节点是否为空
    if (!tail) return;
    //判断尾节点是否为当前节点
    if (curr == tail) curr = NULL;
    Node* temp = tail;
    tail = tail->prev;
    if (tail) {
        //判断节点数是否为1
        tail->next = NULL;
    }
    else {
        head = NULL;
    }
    free(temp);
}
//从当前位置删除
void eraseCurr() {
    if (!curr) return;
    if (curr->prev) {
        curr->prev->next = curr->next;
    }
    else {
        head = curr->next;
    }
    if (curr->next) {
        curr->next->prev = curr->prev;
    }
    else {
        tail = curr->prev;
    }
    free(curr);
    curr = NULL;
}

int main() {
    int m;
    scanf("%d", &m);//要操作的次数

    int results[20];
    int idx = 0;//保存结果

    for (int i = 0; i < m; i++) {
        char op[2];
        int type, x;
        scanf("%s", op);//输入操作
        switch (op[0]) {
        case 'I':
            scanf("%d %d", &type, &x);
            if (type == 1) insertHead(x);
            else if (type == 2) insertTail(x);
            else if (type == 3) insertAfterCurr(x);
            break;

        case 'Q':
            scanf("%d", &x);
            results[idx++] = query(x);
            break;

        case 'E':
            scanf("%d", &type);
            if (type == 1) eraseHead();
            else if (type == 2) eraseTail();
            else if (type == 3) eraseCurr();
            break;
        }
    }
    for (int i = 0; i < idx; i++) {
        printf("%d\n", results[i]);
    }//输出
    return 0;
}