山东大学数据结构实验四

最新推荐文章于 2024-06-11 17:25:41 发布
最新推荐文章于 2024-06-11 17:25:41 发布
阅读量276 收藏 3
点赞数
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62819443/article/details/130371756
版权

链表实现

链表合并

A 链表实现

要求

  1. 封装链表类，链表迭代器类
  2. 链表类需提供操作：在指定位置插入元素，删除指定元素，搜索链表中是否有指定元素，原地逆置链表，输出链表
  3. 不得使用与链表实现相关的STL

描述

第一行两个整数 N 和 Q。
第二行 N 个整数，作为节点的元素值，创建链表。
接下来 Q 行，执行各个操作，具体格式如下：

  • 插入操作 : 1 idx val，在链表的 idx 位置插入元素 val;
  • 删除操作 : 2 val，删除链表中的 val 元素。若链表中存在多个该元素，仅删除第一个。若该元素不存在，输出 -1；
  • 逆置操作 : 3，原地逆置链表；
  • 查询操作 : 4 val，查询链表中的 val 元素，并输出其索引。若链表中存在多个该元素，仅输出第一个的索引。若不存在该元素，输出 -1；
  • 输出操作 : 5，使用 链表迭代器 ，输出当前链表索引与元素的异或和： f ( chain ) = ∑ i = 0 n − 1 i ⊕ chain [ i ] , n = len(chain) f(\text{chain}) = \sum_{i=0}^{n-1}i\oplus \text{chain}[i], n=\text{len(chain)} f(chain)=∑i=0n−1​i⊕chain[i],n=len(chain)；

样例 1

Input

10 10
6863 35084 11427 53377 34937 14116 5000 49692 70281 73704 
4 6863
1 2 44199
5
4 21466
1 6 11483
5
4 34937
5
4 6863
1 10 18635

Output

0
398665
-1
410141
5
410141
0

限制

1s

数据范围

image.png 
/* created by LYZ */
#include<iostream>
using namespace std;
const int N = 1e6 + 10;
int a[N];//用来存储输入的每个元素
int c[N];//用来存储输出的每个元素 
int stand;
template <class T>
struct chainNode {//定义链表中的结点
	//数据成员
	T element;
	chainNode<T> *next;
	//方法
	chainNode(){}
	chainNode(const T& element)
	{
		this->element = element;
	}
	chainNode(const T& element, chainNode<T>* next)
	{
		this->element = element;
		this->next = next;
	}
};
template<class T>
class Iterator
{
public:
	//C++的向前迭代器所需要的typedef 语句省略
	//构造函数
	Iterator(chainNode<T>* theNode = NULL)
	{
		node = theNode;
	}
	//解引用操作符
	T& operator*() const { return node->element; }
	T* operator->() const { return &node->element; }
	//迭代器加法操作
	Iterator & operator++() //前++
	{
		node = node->next; return *this;
	}
	Iterator operator++(int) //后++
	{
		Iterator old = *this; node = node->next; return old;
	}
	bool operator!=(const Iterator right) const
	{
		return node != right.node;
	}
	bool operator==(const Iterator right) const
	{
		return node == right.node;
	}
protected:
	chainNode<T>* node;//指向表节点的指针
};//迭代器类

template <class T>
class chain
{
public:
	//构造函数、复制构造函数、析构函数
	chain(int initialCapacity = 10);
	chainNode<T>* get1(){
		return firstNode;
	}
	//ADT方法
	bool empty() const { return listSize == 0; }
	int size() const { return listSize; }
	int indexOf(const T& theElement) const;
	void erase(int theIndex);
	void insert(int theIndex, const T& theElement);
	void reverse();
	int sum();
	Iterator<T> begin(){ return Iterator<T>(firstNode); }
	Iterator<T> end(){ return Iterator<T>(NULL); }
protected:
	chainNode <T> *firstNode;
	//指向链表中第一个节点的指针
	int listSize; //线性表的元素个数

};

template<class T>
chain<T>::chain(int initialCapacity)
{ //构造函数

	firstNode = NULL;
	listSize = 0;
}
template<class T>

int  chain<T>::sum(){
	int res = 0;
	
	chainNode<T>* currentNode= firstNode;
	for (int i = 0; i < listSize;i++){
		res += i^currentNode->element;
		currentNode=currentNode->next;
	}
	return res;
}
template<class T>
int chain<T>::indexOf(const T& theElement) const
{ //返回元素theElement首次出现时的索引,如果theElement不存在,则返回-1
	//查找元素
	chainNode<T> *currentNode = firstNode;
	int index = 0; // currentNode的索引
	while (currentNode != NULL &&
		currentNode->element != theElement)
	{
		currentNode = currentNode->next;
		index++;
	}
	if (currentNode == NULL) return -1;
	return index;
}//获取链表中某元素的索引
template<class T>
void chain<T>::erase(int theIndex)
{
	//索引有效，需要找要删除的元素节点
	chainNode<T> *deleteNode = firstNode;
	if (theIndex == 0)
	{//删除表中首节点
		deleteNode = firstNode;
		firstNode = firstNode->next;
	}
	else { //用指针p指向第theIndex-1个节点
		chainNode<T> *p = firstNode;
		for (int i = 0; i<theIndex - 1; i++)
			p = p->next;
		deleteNode = p->next;
		p->next = p->next->next;//删除deleteNode指向的节点
	} listSize--;
	delete deleteNode;
}//删除链表中索引值的节点
template<class T>
void chain<T>::insert(int theIndex, const T& theElement)
{

	//在链表表头插入
	if (theIndex ==0) firstNode = new chainNode<T>(theElement, firstNode);
	else
	{//寻找新元素的前驱(第theIndex-1个元素 )
		chainNode<T> *p = firstNode;
		for (int i = 0; i < theIndex - 1; i++)
			p = p->next; //将p移动至第theIndex-1个元素
		//在p之后插入
		p->next = new chainNode<T>(theElement, p->next);
	}
	listSize++;
}//在链表中插入一个数
template<class T>
void  chain<T>::reverse(){
	if (listSize <= 1)return;
	chainNode<T>* pre = NULL;
	chainNode<T>*next = NULL;
	chainNode<T>*head = firstNode;
	while (head!= NULL)
	{
		next = head->next;
		head->next = pre;
		pre = head;
		head = next;
	}
	firstNode = pre;
}//逆置链表

int main(){
	int n, q;
	cin >> n >> q;
	chain<int> b(n+10);
	chainNode<int>* currentNode = b.get1();
	for (int i = 0; i < n; i++)
	{
		cin >> a[i];
	}
	for (int i = 0; i < n; i++)
	{
	b.insert(i,a[i]); 
	}
	int flag = 0;
	for (int i = 0; i < q; i++)
	{
		cin >> flag;
		switch (flag)
		{
		case 1:
		{int index1 = 0; int val1 = 0;
		cin >> index1 >> val1;
		b.insert(index1, val1);
		break; }
		case 2:
		{int val2;
		cin >> val2;
		int index2 = b.indexOf(val2);
		if(index2!=-1)
		b.erase(index2);
		else {c[stand]=-1;
		stand++;
		}
		break; }
		case 3:
		{b.reverse();
		break; }
		case 4:
		{int val4 = 0;
		cin >> val4;
		int index4 = b.indexOf(val4);
	c[stand]=index4;
	stand ++;
		break; }
		case 5:
		{	int res = b.sum();
		c[stand]=res;
		stand ++;
		break;

		}
		}
	}

for(int i=0;i<stand;i++)
cout<<c[i]<<endl;
	
	return 0;
}

链表合并

要求

  1. 使用题目 链表实现 中实现的链表类、迭代器类完成本题
  2. 不得使用与题目实现相关的STL

描述

给定两组整数序列，你需要分别创建两个有序链表，使用链表迭代器实现链表的合并，并分别输出这三个有序链表的索引与元素的异或和。

Note: 给定序列是无序的，你需要首先得到一个有序的链表

格式

输入

第一行两个整数 N 和 M。
第二行 N 个整数，代表第一组整数序列。
第三行 M 个整数，代表第二组整数序列。

输出

三行整数。分别代表第一组数、第二组数对应的有序链表与合并后有序链表的索引与元素的异或和。

链表异或和的计算方式如下：

$$
f(\text{chain})=\sum_{i=0}^{n-1} i\oplus \text{chain}[i], n=\text{len(chain)}

$$

样例 1

输入

3 0
3 1 2

输出

5
0
5

限制

1s

数据范围

image.png 
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e6 + 10;
int a[N];//用来存储输入的每个元素
int c[N];
int S, K, Q;
int stand;
int d[N];
int e[N];
int f[N];
int g[N];
void quick_sort(int q[],int l,int r){
    if(l>=r) return ;
    int x=q[l+r>>1], i=l-1, j=r+1;
    while(i<j){
        do i++;while(q[i]<x);
        do j--;while(q[j]>x);
        if(i<j)swap(q[i],q[j]);
        
    }
    quick_sort(q,l,j);
    quick_sort(q,j+1,r);
}


template <class T>
struct chainNode {//定义链表中的结点
	//数据成员
	T element;
	chainNode<T> *next;
	//方法
	chainNode(){}
	chainNode(const T& element)
	{
		this->element = element;
	}
	chainNode(const T& element, chainNode<T>* next)
	{
		this->element = element;
		this->next = next;
	}
};
template<class T>
class Iterator
{
public:
	//C++的向前迭代器所需要的typedef 语句省略
	//构造函数
	Iterator(chainNode<T>* theNode = NULL)
	{
		node = theNode;
	}
	//解引用操作符
	T& operator*() { return node->element; }
	T* operator->() { return &node->element; }
	//迭代器加法操作
	Iterator & operator++() //前++
	{
		node = node->next; return *this;
	}
	Iterator operator++(int) //后++
	{
		Iterator old = *this; node = node->next; return old;
	}
	bool operator!=(const Iterator right) const
	{
		return node != right.node;
	}
	bool operator==(const Iterator right) const
	{
		return node == right.node;
	}
protected:
	chainNode<T>* node;//指向表节点的指针
};//迭代器类

template <class T>
class chain
{
public:
	//构造函数、复制构造函数、析构函数
	chain(int initialCapacity = 10);
	chainNode<T>* get1(){
		return firstNode;
	}
	//ADT方法
	bool empty() const { return listSize == 0; }
	int size() const { return listSize; }
	int indexOf(const T& theElement) const;
	void erase(int theIndex);
	void insert(int theIndex, const T& theElement);
	void reverse();
	int sum();
	Iterator<T> begin(){ return Iterator<T>(firstNode); }
	Iterator<T> end(){ return Iterator<T>(NULL); }
	int * transpose();
protected:
	chainNode <T> *firstNode;
	//指向链表中第一个节点的指针
	int listSize; //线性表的元素个数

};
template<class T>

int * chain<T>::transpose()

{
	int *a = new int[listSize];
	chainNode<T>*currentNode = firstNode;
	for (int i = 0; i < listSize; i++)
	{
		a[i] = currentNode->element;
		currentNode = currentNode->next;
	}
	return a;

}
int yihuoSum(int a[], int n){
	quick_sort(a,0,n-1);
	int res = 0;
	for (int i = 0; i < n; i++)
		res += a[i] ^ i;
	return res;

}


template<class T>
chain<T>::chain(int initialCapacity)
{ //构造函数

	firstNode = NULL;
	listSize = 0;
}
template<class T>

int  chain<T>::sum(){
	int res = 0;

	chainNode<T>* currentNode = firstNode;
	for (int i = 0; i < listSize; i++){
		res += i^currentNode->element;
		currentNode = currentNode->next;
	}
	return res;
}
template<class T>
int chain<T>::indexOf(const T& theElement) const
{ //返回元素theElement首次出现时的索引,如果theElement不存在,则返回-1
	//查找元素
	chainNode<T> *currentNode = firstNode;
	int index = 0; // currentNode的索引
	while (currentNode != NULL &&
		currentNode->element != theElement)
	{
		currentNode = currentNode->next;
		index++;
	}
	if (currentNode == NULL) return -1;
	return index;
}//获取链表中某元素的索引
template<class T>
void chain<T>::erase(int theIndex)
{
	//索引有效，需要找要删除的元素节点
	chainNode<T> *deleteNode = firstNode;
	if (theIndex == 0)
	{//删除表中首节点
		deleteNode = firstNode;
		firstNode = firstNode->next;
	}
	else { //用指针p指向第theIndex-1个节点
		chainNode<T> *p = firstNode;
		for (int i = 0; i<theIndex - 1; i++)
			p = p->next;
		deleteNode = p->next;
		p->next = p->next->next;//删除deleteNode指向的节点
	} listSize--;
	delete deleteNode;
}//删除链表中索引值的节点
template<class T>
void chain<T>::insert(int theIndex, const T& theElement)
{

	//在链表表头插入
	if (theIndex == 0) firstNode = new chainNode<T>(theElement, firstNode);
	else
	{//寻找新元素的前驱(第theIndex-1个元素 )
		chainNode<T> *p = firstNode;
		for (int i = 0; i < theIndex - 1; i++)
			p = p->next; //将p移动至第theIndex-1个元素
		//在p之后插入
		p->next = new chainNode<T>(theElement, p->next);
	}
	listSize++;
}//在链表中插入一个数
template<class T>
chain<T> combine(chain<T>&a, chain<T>&b){
	chain<T>c;
	int flag = 0;
	Iterator<T> i = a.begin();
	Iterator<T> j = a.end();
	Iterator<T> k = b.begin();
	Iterator<T> n = b.end();
	while (i != j){
		c.insert(flag, (*i));
		i++;
		flag++;
	}
	while (k != n){
		c.insert(flag,(*k));
		k++;
		flag++;
	}
	return c;
}
template<class T>
void  chain<T>::reverse(){
	if (listSize <= 1)return;
	chainNode<T>* pre = NULL;
	chainNode<T>*next = NULL;
	chainNode<T>*head = firstNode;
	while (head != NULL)
	{
		next = head->next;
		head->next = pre;
		pre = head;
		head = next;
	}
	firstNode = pre;
}//逆置链表

int main(){
	int N, M, flag;
	cin >> N >> M;
	chain<int>a;
	chain<int>b;
	chain<int>x;
	chain<int>y;
	
	for (int i = 0; i <N; i++)
	{
		cin >> flag;
		a.insert(i, flag);
	}
	int *c = a.transpose();
	for(int i = 0; i < N; i ++){
		x.insert(i,c[i]);
	}
	for (int i = 0; i <M; i++)
	{
		cin >> flag;
		b.insert(i, flag);
	}
	chain<int>e = combine(c, d);
	int *d = b.transpose();
		for(int i = 0; i < M; i ++){
		y.insert(i,d[i]);
	}
	int *f=e.transpose();


	int res = yihuoSum(c, N);
	int res2 = yihuoSum(d, M);
	int res3=yihuoSum(f,M+N);
	
		cout<<res<<endl;
	cout<<res2<<endl;
		cout<<res3<<endl;
	return 0;
}
咕噜咕噜咕噜128
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
山大数据结构实验4
09-12
山大数据结构实验4，帮助那些不会写代码的同学。
2017--山东大学数据结构实验代码
01-18
2017--山东大学数据结构实验代码，包括实验1-实验8，利用codeblocks编译运行。代码有详细的注释，是辅助学习的好资源。 配套的实验报告在上一个的上传资源里面。 2017--山东大学数据结构实验代码，包括实验1-实验8，利用codeblocks编译运行。代码有详细的注释，是辅助学习的好资源。 配套的实验报告在上一个的上传资源里面。 2017--山东大学数据结构实验代码，包括实验1-实验8，利用codeblocks编译运行。代码有详细的注释，是辅助学习的好资源。 配套的实验报告在上一个的上传资源里面。
山东大学数据结构实验4--使用栈计算多项式（超级详细注释）
weixin_47373497的博客
11-09 693
##使用顺序栈 完成多项式计算 内含栈的基本方法：出栈，压栈，置空栈，get栈顶元素，栈的初始化，栈的结构体定义，栈的判空 实验大纲中要求的是int类型的结果，只需要把代码中的double型数据和方法换成int型即可 我写成double型，是为了以后可以用程序来计算多项式，当作一个多项式计算器 头文件 #ifndef BIAODASHIJISUAN_H #define BIAODASHIJISUAN_H #endif #include<iostream> #include<stdio.h&
山东大学数据结构实验四：在线等价类
Sunnyztg的博客
12-09 862
山东大学数据结构实验四：在线等价类
山东大学数据结构实验四在线等价类
weixin_52099599的博客
12-12 2260
1、 使用5实现本实验。 2、 输入一个1-9的正整数n，代表要创建n个元素，例如输入5，则代表创建一个1,2,3,4,5组成的元素表。 3、 再输入一个大于0正整数m，代表后面要输入m个等价关系。 4、 分行输入m个等价关系，格式如(1,2)。 5、 分行输出所有等价类。 #include <iostream> using namespace std; //模拟指针的定义 //模拟指针可以理解为：在一个模拟空间中， //存在一个指针数组，数组中的每个元素为指针类型， //并且每个指针具有数据域
山东大学数据结构实验4 线性表报告
10-14
山东大学数据结构实验4线性表报告2012年
山东大学数据结构实验报告
12-28
包含矩阵、算法、递归、二叉树、搜索树、图、堆栈等等
山东大学2020数据结构实验报告
01-12
数据结构实验报告中有完整的代码，可直接运行
山东大学软件学院数据结构实验七图的操作
12-28
1、 创建图类，存储结构使用邻接矩阵。 2、 输入图的节点数n（不超过10个）、边数m，节点分别用1-n代表。 3、 采用“起始节点，终止节点，权值”输入图的m条边，创建图。 4、 输出从节点1开始的BFS遍历，要求小的...
山东大学《数据结构》实验教学大纲.docx
12-16
山东大学《数据结构》实验教学大纲.docx
2017--山东大学数据结构实验报告，实验1-8，全面
01-18
2017--山东大学数据结构实验报告，包括实验1-8，详细全面。数据结构 A+的实验报告。 2017--山东大学数据结构实验报告，包括实验1-8，详细全面。数据结构 A+的实验报告。 2017--山东大学数据结构实验报告，包括实验1-8，详细全面。数据结构 A+的实验报告。
山东大学数据结构实验一
05-12
山东大学 数据结构 实验一 C++，实验一递归练习是以后所用到的各种数据结构经常使用的，请同学们一定要熟练掌握。
山大数据结构实验报告
qq_41022936的博客
10-17 1747
山东大学软件学院 《数据结构、算法与应用》实验指导书   一、实验要求 采用良好的编程风格；关键操作要有注释。 程序能够运行，显示运行结果。   二、 开发工具   Microsoft Visual C++ Eclipse IDE For C++   三、 实验题目 实验一 递归练习 一、实验目的 熟悉开发工具的使用。 掌握递归的实现思想。 二、实验内容 1、输出...
山东大学软件学院2017-18学年大二数据结构实验一、二、三、四
谦虚勤奋诚实感恩
10-01 4382
注：实验代码均为自己编写，均能满足实验要求，但实现方法不唯一仅供参考。 实验一 递归练习 1.实验内容（题目内容，输入要求，输出要求） ①、输入2-10个大于0的正整数，如果输入0作为结束。 ②、输出这几个整数的全排列，每个数之间用半角“，”隔开，中间不要有空格，每个排列单独一行。 ③、程序一定要有Input、Output、End提示信息，但是不要有格式没有出现的其他提示 ④、程序最后...
Vj数据结构实验4链式描述线性表（二）
weixin_53437436的博客
10-30 505
要求 使用题目链表实现中实现的链表类、迭代器类完成本题 不得使用与题目实现相关的STL 描述 给定两组整数序列，你需要分别创建两个有序链表，使用链表迭代器实现链表的合并，并分别输出这三个有序链表的索引与元素的异或和。 Note: 给定序列是无序的，你需要首先得到一个有序的链表 格式 输入 第一行两个整数 N 和 M。 第二行 N 个整数，代表第一组整数序列。 第三行 M 个整数，代表第二组整数序列。 输出 三行整数。分别代表第一组数、第二组数对应的有序链表与合并后有序链表的索引与元..
山东大学《数据结构》实验四：堆栈的应用
1个胖墩的课后笔记
01-14 1492
实验四 堆栈的应用 一、 实验目的 掌握堆栈的使用。 二、 实验内容 1、输入一个数学表达式（假定表达式输入格式合法），计算表达式结果 并输出。 2、数学表达式由单个数字和运算符“+”、“-”、“*”、“/”、“(、) ”构成， 例如 2 + 3 * ( 4 + 5 ) - 6 / 4。 3、变量、输出采用整数，只舍不入。 三、 注意事项 本题测试一定要多找几个测试用例，特别是复杂用例、边界用例。...
山东大学《数据库系统》实验四
1个胖墩的课后笔记
01-16 2396
实验题目： 复制表、修改表结构、修改数据 实验目的： 利用 oracle 管理平台完成对表的结构、数据进行修改，每一个问题可以通过多个 SQL 语句完成。 实验原理和方法： 复制表结构及其数据： create table table_name_new as select * from table_name_old 添加一列： alter table table_name add (column1列名 [column2 列名…]） 更新语句： update table_name set 列名=表达式\子查询
数据结构——bitset（位图）模拟实现
最新发布
mastershooter的博客
06-11 603
第一种：构造一个8位的位图，所有为初始化为0//00000000第二种：构造一个8位的位图，根据所给的值初始化位图前N位//01100100第三种：构造一个8位的位图，根据字符串中的0/1序列来初始化位图的前N位//00111001。
山东大学数据结构实验四csdn
12-03
山东大学数据结构实验四是关于CSDN（中国软件开发者社区）的实验。CSDN是中国最大的开发者社区之一，它为广大的软件开发者提供了开发工程师技术社区、知识库、博客、论坛、下载中心等一系列服务。本实验主要目的是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

咕噜咕噜咕噜128

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值