面向对象程序设计-实验三 链表

已于 2024-04-06 13:52:07 修改
阅读量301 收藏 6
点赞数 8
分类专栏： # 面向对象程序设计 文章标签： 算法 数据结构 链表
于 2024-04-06 13:37:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60211220/article/details/137426872
版权
2022/4/11
1.课堂练习：节点类Node，包含整形数data；链表类LinkList，包含头指针Head，完成构造函数和析构函数，实现功能包括：向链表头插入一个整形数push，遍历链表并显示display，查找特定的整形数findData，按照从小到大的顺序插入一个整形数insertData，删除整形数deleteData。编写主函数，测试每个成员函数的输出，运行结果截图。
#include<iostream>
using namespace std;
class node{
public:
	int data;
	node* next;
};//定义节点
node* createList(int n) {
	node* temp, * tail = nullptr, * head = nullptr;
	int num;
	cin >> num;
	head = new node;//为新节点动态分配内存
	if (head == nullptr) {
		cout << "No memory available ! ";
		return nullptr;
	}
	else {
		head->data = num;
		head->next = nullptr;
		tail = head;
	}
	for (int i = 0; i < n - 1; i++) {
		cin >> num;
		temp = new node;// 为新节点动态分配内存
		if (temp == nullptr) {
			cout << "No memory available ! ";
			return head;
		}
		else {
			temp->data = num;
			temp->next = nullptr;
			tail->next = temp;
			tail = temp;
		}
	}
	return head;
}
class Linklist {
public:
	Linklist(int n) {
		head = createList(n);
	}//构造函数
	~Linklist(){
		node* temp = head;
		node* x;
		while (temp) {
			x = temp->next;
			delete temp;
			temp = x;
		}
	}//析构函数
	void display();//显示数据
	void add(int push);//插入开头
	void find(int findData);//寻找数据
	void insert(int insertData);//插入数据
	void deletee(int deleteData);//删除数据
private:
	node* head;
};
void Linklist::display() {
	cout << "List: ";
	node* temp = head; 
	while (temp) {
		cout << temp->data;
		if (temp->next) {
			cout << " -> ";
		}
		temp = temp->next;
	}
	cout << endl;
}
void Linklist::add(int push) {
	node *temp = head;
	head = new node;
	head->data = push;
	head->next = temp;
}
void Linklist::find(int findData) {
	node* temp = head;
	int i;
	while (temp) {
		if (temp->data == findData) {
			cout << "Find "<< findData << " in the list." << endl;
			break;
		}
		temp = temp->next;
	}
	if (temp == nullptr) {
		cout << "Can't find " << findData << " in the list." << endl;
	}
}
void Linklist::insert(int insertData) {
	node* temp = head;
	node* x = new node;
	x->data = insertData;
	while (temp) {
		if (temp->data <= x->data) {
			if (temp->data) {
				x->next = temp->next;
			}
			else {
				x->next = nullptr;
			}
			temp->next = x;
			break;
		}
		temp = temp->next;
	}
}
void Linklist::deletee(int deleteData) {
	node* temp = head;
	if (temp->data == deleteData) {
		head = head->next;
	}
	else {
		while (temp) {
			if (temp->next->data == deleteData) {
				temp->next = temp->next->next;
				break;
			}
			temp = temp->next;
		}
	}
}
int main(){
	int n;
	cout << "P1ease enter the number of nodes : ";
	cin >> n;
	Linklist list(n);
	list.add(1);//在开头插入1
	list.display();//显示数据
	list.find(2);//寻找数据2
	list.insert(4);//插入数据4
	list.deletee(3);//删除数据3
	list.display();//显示数据
	return 0;
}
2. Josephus（约瑟夫）问题：有n个人围成一个圈，从第1个人开始报数，数到第m个人，让他出局；然后从出局的下一个人重新开始报数，数到第m个人，再让他出局，……，如此反复直到剩下一个人，问此人编号为几？

利用链表解决约瑟夫问题。编写主函数，运行结果截图。

#include<iostream>
#include<string>
using namespace std;
class node {
public:
	int data;
	node* next;
};//定义节点
class Linklist {
public:
	Linklist() {
		head = new node;
		head->next = nullptr;
	}//构造函数
	void Josephus();
private:
	node* head;
};
void Linklist::Josephus() {
	int n, m;
	cout << "请输入总人数以及出局的数：" << endl;
	cin >> n >> m;
	node* temp = head;
	for (int i = 1; i <= n; i++){
		node* x = new node;
		x->data = i;
		temp->next = x;
		temp = x;
	}
	temp->next = head;
	node* c1 = head;
	int num = 0;
	while (n > 1){
		if (num + 1 == m){
			node* c2 = c1->next->next;
			c1->next = c2;
			c1->next->data = c2->data;
			c1 = c1->next;
			num = 0;//报数清零
			n = n - 1;//人数减一
		}//轮到序号出局
		else {
			c1 = c1->next;
		}
		num = num + 1;//报到的数
	}
	cout << "最后的编号为：" << c1->data << endl;
}
int main() {
	Linklist J;
	J.Josephus();
	return 0;
}
3.输入n以及n个学生的信息（姓名，成绩）（n>=10），再删除其中成绩小于60分的节点，然后将学生按照成绩升序排列。插入一位学生的信息，然后顺序输出这些学生的信息，要求用链表结构完成，并将各操作编写成成员函数。编写主函数，测试每个成员函数的输出，运行结果截图。
#include<iostream>
#include<string>
using namespace std;
class node {
public:
	string name;
	int score;
	node* next;
};//定义节点
node* student(int n) {
	node* temp;
	node* tail = nullptr;
	node* head = nullptr;
	string name;
	int score;
	cout << "请输入学生姓名：";
	cin >> name;
	cout << "请输入学生成绩：";
	cin >> score;
	head = new node;//为新节点动态分配内存
	if (head == nullptr) {
		cout << "No memory available ! ";
		return nullptr;
	}
	else {
		head->name = name;
		head->score = score;
		head->next = nullptr;
		tail = head;
	}
	for (int i = 0; i < n - 1; i++) {
		cout << "请输入学生姓名：";
		cin >> name;
		cout << "请输入学生成绩：";
		cin >> score;
		temp = new node;// 为新节点动态分配内存
		if (temp == nullptr) {
			cout << "No memory available ! ";
			return head;
		}
		else {
			temp->name = name;
			temp->score = score;
			temp->next = nullptr;
			tail->next = temp;
			tail = temp;
		}
	}
	return head;
}
class Linklist {
public:
	Linklist(int n) {
		head = student(n);
		num = n;
	}//构造函数
	void deletee();//删除数据
	node* sor(node* head);//从小到大排序返回指针
	void sortt();//修改链表内指针
	void insert();//插入数据
	void display();//显示数据
private:
	node* head;
	int num;//学生人数
};
void Linklist::deletee() {
	node* temp = head;
	while (temp->score < 60) {
		head = head->next;
		temp = head;
		num = num - 1;
	}//判断开头
	while (temp && temp->next) {
		if (temp->next->score < 60) {
			temp->next = temp->next->next;
			num = num - 1;
		}
		temp = temp->next;
	}
}
node* Linklist::sor(node* head) {
	if (!head || !head->next) {
		return head;
	}//空指针或一个数据
	node* fast = head->next;//快指针
	node* slow = head;//慢指针
	while (fast != nullptr && fast->next != nullptr) {
		fast = fast->next->next;
		slow = slow->next;
	}
	node* ss = slow->next;
	slow->next = nullptr;
	node* left = sor(head);//左递归
	node* right = sor(ss);//右递归
	node* ans = new node;//新链表
	node* temp = ans;
	while (left != nullptr && right != nullptr) {
		if (left->score > right->score) {
			temp->next = right;
			right = right->next;
		}
		else {
			temp->next = left;
			left = left->next;
		}
		temp = temp->next;
	}
	if (left == nullptr) {
		temp->next = right;
	}
	else {
		temp->next = left;
	}
	return ans->next;
}
void Linklist::sortt() {
	head = sor(head);
}
void Linklist::insert() {
	string name;
	int score;
	cout << "请输入插入的学生姓名：";
	cin >> name;
	cout << "请输入插入的学生成绩：";
	cin >> score;
	node* temp = head;
	node* x = new node;
	x->name = name;
	x->score = score;
	while (temp) {
		if (temp->score <= x->score) {
			if (temp->score) {
				x->next = temp->next;
			}
			else {
				x->next = nullptr;
			}
			temp->next = x;
			break;
		}
		temp = temp->next;
	}
}
void Linklist::display() {
	node* temp = head;
	while (temp) {
		cout << temp->name << " " << temp->score << endl;
		temp = temp->next;
	}
}
int main() {
	int n;
	cout << "请输入学生人数: ";
	cin >> n;
	Linklist Stu(n);
	Stu.deletee();//删除小于60分的节点
	Stu.sortt();//从小到大排序
	Stu.insert();//插入数据
	Stu.display();//显示数据
	return 0;
}
实验总结
  1. 注意临时指针移动不改变原链表
  2. 注意指针指向的空间改变同步改变原链表
  3. 注意head的移动和改变
  4. 注意private下的变量无法在外部引用
  5. 注意函数是否存在返回值及其类型
闻闻闻闻笛声
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
实验三单链表
Simpthan的博客
05-24 261
#include &lt;iostream&gt;     using namespace std;     const int N=5;     struct Std{         int date;         Std *next;     }*p,*r;     class Student{     private:         Std *first;         int l...
燕山大学C++面向对象程序设计实验报告
12-18
"燕山大学C++面向对象程序设计实验报告" 本实验报告是燕山大学信息科学与工程学院（软件学院）的一份C++面向对象程序设计实验报告。该报告包括三个实验，涵盖了C++面向对象程序设计的基本概念和技术。 一、实验1：...
《C++面向对象程序设计》✍千处细节、万字总结（建议收藏）
热门推荐
像写诗一样优雅地写代码~
06-04 65万+
《C++面向对象程序设计》✍千处细节、万字总结 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++在非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联函数带有默认参数值的函数函数重载作用域标识符"::"强制类型转换new和delete运算符引用三、类和对象（一）3.1 类的构成3.2 成员函数的定义3.3 对象的定义和使用3.4 构造函数与析构函数构造函数成员初始化列表
面向对象程序设计实验 - 实验9 模板类的构造
qq_41626672的博客
08-10 575
实验九 模板类的构造 目录 实验九 模板类的构造 9.1 实验目的 9.2 实验内容 9.2.1程序阅读 9.2.2 程序设计 9.3思考题 9.1 实验目的 1．理解和应用类模板和函数模板； 2．复习数据结构的相关知识； 3．学习用C++的编程思想实现链表类。 9.2 实验内容 9.2.1程序阅读 1．理解下面的动态数组类模板，它由一系列位置连续、任意数量相同类型的元素组成，其元素个数可在程序运行时改变，并完成该类中没有完成的成员函数（不允许改变已有代码），并设计主函数，实现对
面向对象程序设计C++——利用链表实现栈和队列（继承）
ChristensonLee的博客
05-08 1737
**【问题描述】**利用链表实现栈和队列 队列具有先进先出的特点，所有新来的元素都放在队列尾部，出队列的元素从队列头部出去。下面是队列的示意图： 栈具有后进先出的特点。所有入栈的元素都放在栈顶，出栈时栈顶元素先出。下面是栈的示意图： 这两种结构具有很多相似的地方：都存放了一系列的元素，元素的操作都在两头进行，元素个数都是动态可变的。我们可以设计一个基类，完成它们共同的功能，然后分别派生出队列类和栈类。本实验要求以上一个实验实现的链表类作为基类并设计它的两个派生类。 要求： (1) 在上一个实验实现的链表
面向对象程序设计实验报告
06-14
综上所述，这个面向对象程序设计实验报告涵盖了C++中的面向对象编程基础，包括类的设计与实现、对象的使用，以及数据结构（如链表）和文件I/O的相关知识。通过这个实验，学生可以深入理解和掌握面向对象编程的关键...
面向对象程序设计实验报告五 - 打印1
08-03
面向对象程序设计实验报告主要涉及了使用C++进行公交地图导航的系统开发，该系统旨在帮助用户规划从起点到终点的最少转乘公交线路。以下是关键知识点的详细说明： 1. **面向对象编程**：实验的核心是利用面向对象的...
面向对象程序设计课程实验报告.doc
09-29
【面向对象程序设计课程实验报告】 本实验报告主要围绕面向对象程序设计这一核心主题展开，旨在通过实践加深对面向对象编程的理解和应用。面向对象编程（Object-Oriented Programming，OOP）是一种软件开发方法，它...
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 514
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 601
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1042
动态规划
树状数组记录
最新发布
volcan的博客
09-06 454
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
P7492 [传智杯 #3 决赛] 序列
summ1ts的博客
09-03 407
的数组，表示区间内所有数的二进制表示下某一位是否为1，但这太难写，最后无奈去看官方题解，发现只要维护区间所有数的按位与和And，如果(And&k)==k的话那就不用修改了。那样的话这个题就很简单了，维护最大子段和可以见。一道类似势能线段树的题，区间按位或上k，不满足区间可合并的性质，只能暴力的单点修改。，如果我们能找到一个方法，能够判定区间里的数，或上k后是否有改变，就可以避免。至于时间复杂度用类似势能分析的方法分析一波就行了，时间复杂度。我一开始想的是线段树里维护一个。但是考虑按位或的性质，
【滑动窗口】将 x 减到 0 的最小操作数
qq_42150700的博客
09-03 1068
当然也是没有必要的, 因为你要求区间里面的和至少要 target. 你刚刚区间, 就恰好是 >= target 的边界. 也就是说, 左边的值应该都是 <= target 的, 也就是下面这个图蓝色区间的和, 肯定是小于 target 的. 因为是正好加了右侧指针的值才 >= target 停下的。更新结果: 结果的更新, 可以说是最好写的一个部分, 你要什么, 你就在什么时候更新. 我们要的是 sum = target 的长度, 那我们就在 sum = target 的时候更新长度不就行了?
算法训练营|图论第8天 拓扑排序 dijkstra
qq_53125539的博客
09-02 510
拓扑排序。
备战秋招60天算法挑战，Day30
溜达虎的博客
09-03 420
给你一个字符串 和一个字符串列表 作为字典。请你判断是否可以利用字典中出现的单词拼接出 。注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。举个例子： 视频题解 单词拆分 思路来源 思路来源 知识回顾 动态规划是一种通过将原问题分解为子问题来求解复杂问题的算法思想。它通常用于求解最优化问题，例如最长公共子序列、背包问题等。动态规划的核心思想是将原问题分解为若干个子问题，通过求解子问题的最优解推导出原问题的最优解。可以通过两点来判断一个问题能不能通过动态规划来解，一是该问题是否存在递
循环结构程序
BlueBachke的博客
09-03 474
循环结构的基础知识
碰撞检测 | 详解矩形AABB与OBB碰撞检测算法(附ROS C++可视化)
FRIGIDWINTER的博客
09-03 2140
矩形包围盒碰撞检测的核心原理是用矩形近似待检测物体轮廓，通过计算两个矩形间是否有重叠区域来进行碰撞判断。常用的包围形式有轴对齐包围盒(Axis-Aligned Bounding Box, AABB)以及更精细化具有角度的方向包围盒(Oriented Bounding Box, OBB)。本文详解这两种碰撞检测算法，并给出基于C++的算法实现和ROS可视化仿真案例
C++程序设计：链表复制和面向对象编程
* 第４章类与对象：面向对象的思想、面向对象程序设计的基本特点、类和对象、构造函数和析构函数、类的组合、类模板、面向对象标记等。 * 第５章ｃ＋＋高级主题：将在后续课程中介绍。 实验、学时、考核形式、教材...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

闻闻闻闻笛声

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

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

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

打赏作者

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

抵扣说明：

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

余额充值