数据结构实验代码总结

 顺序表（学生信息表＋附加题）

#include <iostream>
#include<algorithm>
#include<string>

using namespace std;
const int Maxsize = 100;

typedef struct Student {
	string num;
	string name;
	char gender;
	double score;
}Student;

class SeqList
{
public:
	SeqList() {};

	void CreatList(Student& st, int i, int n)//建立顺序表1
	{
		if (length < Maxsize) {
			stu[i] = st;
		}
		else throw"上溢";
		length = n;
	}

	void insert(int pos, Student& s) {//插入学生信息2

		if (pos < 0 || pos>length) {
			cout << "学生信息插入位置不合理" << endl;
		}
		else if (length >= Maxsize) {
			cout << "学生信息表满了" << endl;
		}
		else {
			cout << "输入学生信息：" << endl;
			cout << "学号："; cin >> s.num; cout << endl;
			cout << "姓名："; cin >> s.name; cout << endl;
			cout << "性别："; cin >> s.gender; cout << endl;
			cout << "成绩："; cin >> s.score; cout << endl;
			for (int i = length; i > pos; --i) {
				stu[i] = stu[i - 1];
			}
			stu[pos] = s;
			length++;
			cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
			cout << "            学生信息线性表" << endl;
			cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
			printList();
		}
	}

	void findList(int choose33) {//查询学生信息3
		if (choose33 == 1) {
			cout << "请输入要查找的学号："; string stuID; cin >> stuID; cout << endl;
			int judgment = 0;
			for (int i = 0; i < length; i++) {
				if (stu[i].num == stuID) {
					cout << "您要查询的学生为：" << endl;
					cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
					cout << stu[i].num << "       " << stu[i].name << "       " << stu[i].gender << "       " << stu[i].score << endl;
					judgment++;
				}
			}
			if (judgment == 0) cout << "找不到此学生！" << endl;
		}
		else {
			cout << "请输入要查找的姓名："; string stuName; cin >> stuName; cout << endl;
			int judgment = 0;
			for (int i = 0; i < length; i++) {
				if (stu[i].name == stuName) {
					cout << "您要查询的学生为：" << endl;
					cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
					cout << stu[i].num << "       " << stu[i].name << "       " << stu[i].gender << "       " << stu[i].score << endl;
					judgment++;
				}
			}
			if (judgment == 0) cout << "找不到此学生！" << endl;
		}
	}

	void delNode(int choose44) {//删除单个学生信息4
		if (choose44 == 1) {
			cout << "请输入要查找的学号："; string stuID; cin >> stuID; cout << endl;
			int judgment = 0;
			for (int i = 0; i < length; i++) {
				if (stu[i].num == stuID) {
					length--;
					for (int j = i; j < length; j++) {
						stu[j] = stu[j + 1];
					}
					cout << "该学生的信息已被删除！" << endl;
					judgment++;
				}
			}
			if (judgment == 0)cout << "没有找到要删除的记录！" << endl;
		}
		else {
			cout << "请输入要查找的姓名："; string stuName; cin >> stuName; cout << endl;
			int judgment = 0;
			for (int i = 0; i < length; i++) {
				if (stu[i].name == stuName) {
					length--;
					for (int j = i; j < length; j++) {
						stu[j] = stu[j + 1];
					}
					cout << "该学生的信息已被删除！" << endl;
					judgment++;
				}
			}
			if (judgment == 0)cout << "没有找到要删除的记录！" << endl;
		}
	}

	void printList() {//输出学生信息5
		cout << " 学号       姓名        性别       成绩" << endl;
		for (int i = 0; i < length; i++) {
			cout << stu[i].num << "       " << stu[i].name << "       " << stu[i].gender << "       " << stu[i].score << endl;
		}
	}

	void Remove(int j, int n) {//批量删除学生信息6
		int judgment = 0;
		int m = j + n;
		for (int i = j; i < m; i++) {
			if (i + n - 1 <= length) {
				stu[i - 1] = stu[i + n - 1];
				judgment++;
				length--;
			}
			else {
				judgment++; length--;
			}
		}

		if (judgment == n)cout << "这n个学生的信息已被删除！" << endl;
		else cout << "没有找到要删除的记录！" << endl;
	}

	void Add(int n, int pos, Student& s) {//批量添加学生信息7

		if (pos <= 0 || pos > length + 1) {
			cout << "学生信息插入位置不合理" << endl;
		}
		else if (length >= Maxsize) {
			throw"学生信息表满了";
		}
		else {
			int m = length;
			int x = length - pos + 1;
			int b = pos;
			while (x--) {
				stu[b + n - 1] = stu[b - 1];
				b++;
			}
			for (int i = pos - 1; i < pos + n - 1; i++) {
				cout << "输入学生信息：" << endl;
				cout << "学号："; cin >> s.num; cout << endl;
				cout << "姓名："; cin >> s.name; cout << endl;
				cout << "性别："; cin >> s.gender; cout << endl;
				cout << "成绩："; cin >> s.score; cout << endl;
				stu[i] = s;
				length++;
			}
			cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
			cout << "            学生信息线性表" << endl;
			cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
			printList();
		}
	}

	void Sort() {//男女排序
		int left = 0;
		int right = length - 1;
		while (left < right) {
			while (left < right && stu[left].gender == 'M') {//找左边第一个女生
				left++;
			}
			while (left < right && stu[right].gender == 'W') {//找右边第一个男生
				right++;
			}
			if (left < right) {
				stuTransit[0] = stu[right];
				stu[right] = stu[left];
				stu[left] = stuTransit[0];
				left++;
				right--;
			}
		}

	}
private:
	Student stu[Maxsize];
	Student stuTransit[1];
	int length;
};
void MenuList()
{
	cout << "               学生信息管理系统" << endl;
	cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
	cout << "            1.学生信息线性表的建立" << endl;
	cout << "            2.插 入 学 生 信 息" << endl;
	cout << "            3.查 询 学 生 信 息" << endl;
	cout << "            4.删 除 学 生 信 息" << endl;
	cout << "            5.输 出 所 有 学生信息" << endl;
	cout << "            6.批量删除 学生信息" << endl;
	cout << "            7.批量添加 学生信息" << endl;
	cout << "            8.将 男 女 前 后 分 组" << endl;
	cout << "            0.退出学生管理系统" << endl;
	cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
	cout << "请选择功能序号，按数字键0退出：";
}
int main()
{
	SeqList SL;
	Student s;
	int  pos, n;
	while (true)
	{
		MenuList();
		while (cin >> n)
		{
			if (n == 1)//建立学生信息表
			{
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "            学生信息线性表的建立" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "有几位学生？请输入：" << endl;
				int n; cin >> n;
				cout << "以下请输入这" << n << "个学生的信息：" << endl;
				for (int i = 0; i < n; i++) {
					cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
					cout << "第" << i + 1 << "个学生的信息为：" << endl;
					cout << "学号："; cin >> s.num; cout << endl;
					cout << "姓名："; cin >> s.name; cout << endl;
					cout << "性别："; cin >> s.gender; cout << endl;
					cout << "成绩："; cin >> s.score; cout << endl;
					SL.CreatList(s, i, n);
				}
				break;
			}
			if (n == 2)//学生信息表插入
			{
				cout << "请输入要插入的学生数据的位置："; cin >> pos; cout << endl;
				SL.insert(pos - 1, s);

				break;
			}
			if (n == 3)//学生信息查询功能
			{
				cout << "请输入要查找的方式：" << endl;
				cout << "1.按学号查询" << endl;
				cout << "2.按姓名查询" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "请选择1或2："; int choose3; cin >> choose3; cout << endl;
				SL.findList(choose3);
				break;
			}
			if (n == 4)//学生信息的删除
			{
				cout << "请先查找要删除的学生信息" << endl;
				cout << "1.按学号查询" << endl;
				cout << "2.按姓名查询" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "请选择1或2："; int choose4; cin >> choose4; cout << endl;
				SL.delNode(choose4);
				break;
			}
			if (n == 5)//输出学生信息表
			{
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "            输出所有学生信息" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				SL.printList();
				break;
			}
			if (n == 6)
			{
				cout << "请输入从第几个学生开始删除:"; int i; cin >> i; cout << endl;
				cout << "请输入批量删除几个学生:"; int n; cin >> n; cout << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				SL.Remove(i, n);
				break;
			}
			if (n == 7)
			{
				cout << "请输入要插入的学生数据的位置："; int ps; cin >> ps; cout << endl;
				cout << "请输入要插入几个学生："; int k; cin >> k; cout << endl;
				SL.Add(k, ps, s);
				break;
			}
			if (n == 8) {
				SL.Sort();
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "            输出所有学生信息" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				SL.printList();
				break;
			}
			if (n == 0)
			{
				cout << "退出学生信息管理系统，欢迎下次使用！";
				return 0;
			}
		}
	}
}

链表（学生信息表＋附加题）

#include<iostream>
using namespace std;
 
struct Student
{
	string num;
	string name;
	char gender;
	double score;
};
typedef struct _LinkNode {
 
	Student data;
	struct _LinkNode* next;//结点的指针域
 
}LinkNode, Linklist;
 
class XSlist
{
public:
	bool InitList(Linklist*& L);
	void ListInsert_back(Linklist*& L, LinkNode* node);
	bool ListInsert(Linklist*& L, int i, Student dataa);
	void findList(Linklist*& L, int a33);
	void delNode(Linklist*& L, int a44);
	void LinkPrint(Linklist*& L);
	void LinklistDestroy(Linklist*& L);
	void Linklistmodify(Linklist*& L);
	void Linklistinvert(Linklist*& L);
private:
	Linklist* first;
	Linklist* sd;
};
bool XSlist :: InitList(Linklist*& L) {
 
	L = new LinkNode;
 
	if (!L) return false;//生成结点失败
 
	L->next = NULL;
 
	return true;
}
 
 
//尾插法
void XSlist :: ListInsert_back(Linklist*& L, LinkNode* node) {
 
	Linklist* r = nullptr, * s = nullptr;
	first = new Linklist;
	cout << "请输入插入学生的个数:";
	int n; cin >> n;
	r = first;
	while (n--) 
	{
		s = new LinkNode;//生成新结点s
		cout << "请输入学生名字：";
		cin >> s->data.name;
		cout << "请输入学生学号：";
		cin >> s->data.num;
		cout << "请输入学生性别：";
		cin >> s->data.gender;
		cout << "请输入学生成绩：";
		cin >> s->data.score;
		cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
		r->next = s; r = s;
	}
	r->next = nullptr;
}
 
 
//任意位置插入
bool XSlist::ListInsert(Linklist*& L, int i, Student dataa) {
 
	if (!first->next)return false;
 
	int j = 0;
	Linklist* p, * s;
	p = first;
 
	while (p->next && j < i - 1)//查找位置为i-1的结点，p指向该结点
	{
		p = p->next;
		j++;
	}
 
	if ( j > i - 1) {
		return false;
	}
 
	s = new LinkNode;//生成新结点
	s->data = dataa;
	s->next = p->next;
	p->next = s;
	return true;
 
}
 
void XSlist::findList(Linklist*& L, int a33) {//查询学生信息3
	if (a33 == 1) {
		cout << "请输入要查找的学号："; string xh; cin >> xh; cout << endl;
 
		Linklist* p;
		p = first->next;
 
		if (!first || !first->next) {
			cout << "找不到此学生！" << endl;
		}
		else
		{
			while (p && p->data.num != xh)
			{
				p = p->next;
			}
			if (!p)
			{
				cout << "找不到此学生！" << endl;
			}
			else
			{
				cout << "您要查询的学生为：" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << p->data.num << "       " << p->data.name << "       " << p->data.gender << "       " << p->data.score << endl;
				sd = p;
			}
		}
	}
	else {
		cout << "请输入要查找的姓名："; string xm; cin >> xm; cout << endl;
 
		Linklist* p;
		p = first->next;
 
		if (!first || !first->next) {
			cout << "找不到此学生！" << endl;
		}
		else
		{
			while (p && p->data.name != xm)
			{
				p = p->next;
			}
			if (!p)
			{
				cout << "找不到此学生！" << endl;
			}
			else
			{
				cout << "您要查询的学生为：" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << p->data.num << "       " << p->data.name << "       " << p->data.gender << "       " << p->data.score << endl;
				sd = p;
			}
		}
	}
}
 
 
void XSlist::delNode(Linklist*& L, int a44) {//删除学生信息4
	if (a44 == 1) 
	{
		cout << "请输入要查找的学号："; string xh; cin >> xh; cout << endl;
		Linklist* p, * q = first;
		p = first->next;
 
		if (!first || !first->next) {
			cout << "找不到此学生！" << endl;
		}
		else
		{
			while (p && p->data.num != xh)
			{
				q = p; p = p->next;
			}
			if (!p)
			{
				cout << "找不到此学生！" << endl;
			}
			else
			{
				q->next = p->next;//保存后续结点
				delete p;			//释放被删除结点的空间
				cout << "该学生的信息已被删除！" << endl;
			}
		}
	}
	else 
	{
		cout << "请输入要查找的姓名："; string xm; cin >> xm; cout << endl;
		Linklist* p, * q = first ;
		p = first->next;
		if (!first || !first->next) {
			cout << "找不到此学生！" << endl;
		}
		else
		{
			while (p && p->data.name != xm) 
			{
				q = p; p = p->next;
			}
			if (!p) 
			{
				cout << "找不到此学生！" << endl;
			}
			else
			{
				q->next = p->next;		//保存后续结点
				delete p;			//释放被删除结点的空间
				cout << "该学生的信息已被删除！" << endl;
			}
		}
	}
}
 
//单链表打印
void XSlist::LinkPrint(Linklist*& L) {
 
	LinkNode* p = NULL;
	if (!L) { cout << "此链表为空" << endl; return; }
 
	p = first->next;
 
	cout << " 学号       姓名        性别       成绩" << endl;
	while (p) {
 
		cout << p->data.num << "       " << p->data.name << "       " << p->data.gender << "       " << p->data.score << endl;
		p = p->next;
	}
	cout << endl;
}
 
 
//销毁单链表
void XSlist::LinklistDestroy(Linklist*& L) {
 
	Linklist* p = L;
	cout << "销毁链表" << endl;
 
	while (p) {
		L = L->next; //L指向下一个结点
		delete p;   //删除当前结点
		p = L;     //p移向下一个结点
	}
 
}
 
void XSlist:: Linklistmodify(Linklist*& L) {//学生信息的修改6
	cout << "请问你要修改这位同学的什么信息1-4" << endl;
	cout << "1.姓名	2.学号	3.性别	4.成绩。";
	int a6; cin >> a6;
	if (a6 == 1) {
		cout << "请输入你想修改的姓名结果：";
		string xm; cin >> xm;
		sd->data.name = xm;
	}
	if (a6 == 2) {
		cout << "请输入你想修改的学号结果：";
		string xh; cin >> xh;
		sd->data.num = xh;
	}
	if (a6 == 3) {
		cout << "请输入你想修改的性别结果：";
		char xb; cin >> xb;
		sd->data.gender = xb;
	}
	if (a6 == 4) {
		cout << "请输入你想修改的成绩结果：";
		int cj; cin >> cj;
		sd->data.score= cj;
	}
	LinkPrint(L);
}
 
void XSlist::Linklistinvert(Linklist*& L) {
	Linklist* current = first,*p,*q;
	p = first->next;
	q = p->next;
	current->next = nullptr;
	while (q) {
		p->next = current->next;
		current->next = p;
		p = q;
		q = p->next;
	}
	p->next = current->next;
	current->next = p;
	LinkPrint(L);
}
 
void MenuList()
{
	cout << "               学生信息管理系统" << endl;
	cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
	cout << "            1.学生信息线性表的建立" << endl;
	cout << "            2.插 入 学 生 信 息" << endl;
	cout << "            3.查 询 学 生 信 息" << endl;
	cout << "            4.删 除 学 生 信 息" << endl;
	cout << "            5.输 出 所 有 学生信息" << endl;
	cout << "            6.学 生 信 息 修 改" << endl;
	cout << "            7.学 生 信 息 表倒置" << endl;
	cout << "            0.退出学生管理系统" << endl;
	cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
	cout << "请选择功能序号，按数字键0退出：";
}
 
 
int main()
{
	int n;
	XSlist SL;
	Linklist* L = NULL;
	Linklist* s = NULL;
	//1.初始化一个空的链表
	SL.InitList(L);
	while (true)
	{
		MenuList();
		while (cin >> n)
		{
			if (n == 1)//建立学生信息表
			{
				//使用尾插法插入数据
				SL.ListInsert_back(L, s);
				break;
			}
			if (n == 2)//学生信息表插入
			{
				//5.任意位置插入元素
				cout << "请问你要插入几个学生" << endl;
				int j; cin >> j;
				while (j--) {
					int i;
					cout << "请输入插入学生的位置：";
					cin >> i;
					Student dataadd;
					cout << "请输入学生名字：";
					cin >> dataadd.name;
					cout << "请输入学生学号：";
					cin >> dataadd.num;
					cout << "请输入学生性别：";
					cin >> dataadd.gender;
					cout << "请输入学生成绩：";
					cin >> dataadd.score;
 
					if (SL.ListInsert(L, i, dataadd)) {
						cout << "插入成功" << endl;
					}
					else {
						cout << "插入失败" << endl;
					}
					SL.LinkPrint(L);
				}
				break;
			}
			if (n == 3)//学生信息查询功能
			{
				cout << "请输入要查找的方式：" << endl;
				cout << "1.按学号查询" << endl;
				cout << "2.按姓名查询" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "请选择1或2："; int a3; cin >> a3; cout << endl;
				SL.findList(L, a3);
				break;
			}
			if (n == 4)//学生信息的删除
			{
				cout << "请先查找要删除的学生信息" << endl;
				cout << "1.按学号查询" << endl;
				cout << "2.按姓名查询" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "请选择1或2："; int a4; cin >> a4; cout << endl;
				SL.delNode(L, a4);
				break;
			}
			if (n == 5)//输出学生信息表
			{
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "            输出所有学生信息" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				SL.LinkPrint(L);
				break;
			}
			if (n == 6)//学生信息修改
			{
				cout << "请输入要查找需要修改的同学的方式：" << endl;
				cout << "1.按学号查询" << endl;
				cout << "2.按姓名查询" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "请选择1或2："; int a3; cin >> a3; cout << endl;
				SL.findList(L, a3);
				SL.Linklistmodify(L);
				break;
			}
			if (n == 7)//学生信息表倒置
			{
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				cout << "            输出倒置后的学生信息表" << endl;
				cout << "*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=" << endl;
				SL.Linklistinvert(L);
				break;
			}
			if (n == 0)
			{
				cout << "退出学生信息管理系统，欢迎下次使用！";
 
				//9.销毁单链表
				SL.LinklistDestroy(L);
				system("pause");
				return 0;
			}
		}
	}
}

栈（进制转换） 

#include <iostream>
#include <string>
#include <algorithm> // 用于reverse函数

using namespace std;

class Stack {
private:
    int* arr; // 动态数组
    int top;  // 栈顶位置
    int capacity; // 栈的最大容量

public:
    // 构造函数
    Stack(int size) {
        capacity = size;
        arr = new int[capacity];
        top = -1; // 空栈时栈顶位置为-1
    }

    // 析构函数
    ~Stack() {
        delete[] arr;
    }

    // 入栈操作
    void push(int value) {
        if (top < capacity - 1) {
            arr[++top] = value;
        } else {
            cout << "Stack Overflow" << endl;
        }
    }

    // 出栈操作
    int pop() {
        if (top >= 0) {
            return arr[top--];
        } else {
            cout << "Stack Underflow" << endl;
            return -1; // 返回一个错误值，表示栈为空
        }
    }

    // 判断栈是否为空
    bool isEmpty() {
        return top == -1;
    }
};

// 将十进制数转换为指定进制的函数
string decimalToBase(int decimal, int base) {
    if (base < 2 || base > 9) {
        return "Unsupported base";
    }

    Stack stack(100); // 假设栈的大小足够大
    while (decimal > 0) {
        stack.push(decimal % base);
        decimal /= base;
    }

    string result = "";
    while (!stack.isEmpty()) {
        result += to_string(stack.pop());
    }

    return result;
}

int main() {
    int decimalNumber;
    int base;
    cout << "请输入一个十进制正整数：";
    cin >> decimalNumber;
    cout << "请输入要转换的进制（2-9）：";
    cin >> base;

    string result = decimalToBase(decimalNumber, base);
    cout << "转换结果为：" << result << endl;

    return 0;
}

栈（共享栈）

#include <iostream>

const int StackSize = 100; // 可以根据实际需要调整栈的大小

class BothStack {
private:
    int data[StackSize]; // 动态数组存放栈元素
    int top1, top2; // 两个栈顶指针，分别指向栈1和栈2的栈顶元素

public:
    BothStack() : top1(-1), top2(StackSize) {} // 构造函数，初始化栈顶指针

    // 入栈操作，将元素x入栈
    bool Push(int x, int stackNumber) {
        if (stackNumber == 1 && top1 < StackSize - 1) { // 奇数栈
            data[++top1] = x;
        } else if (stackNumber == 2 && top2 > -1) { // 偶数栈
            data[--top2] = x;
        } else {
            return false; // 栈满
        }
        return true;
    }

    // 出栈操作，将栈顶元素弹出
    int Pop(int stackNumber) {
        if (stackNumber == 1 && top1 >= 0) { // 奇数栈
            return data[top1--];
        } else if (stackNumber == 2 && top2 < StackSize) { // 偶数栈
            return data[top2++];
        } else {
            return -1; // 栈空
        }
    }

    // 判断栈是否为空
    bool IsEmpty(int stackNumber) {
        if (stackNumber == 1) {
            return top1 == -1;
        } else if (stackNumber == 2) {
            return top2 == StackSize;
        }
        return true; // 非法输入
    }
};

int main() {
    BothStack bothStack;
    int nums[] = {1, 4, 6, 3, 5, 8, 9, 2, 3, 1, 5};
    int n = sizeof(nums) / sizeof(nums[0]);

    for (int i = 0; i < n; ++i) {
        if (nums[i] % 2 == 0) {
            bothStack.Push(nums[i], 2); // 偶数入栈2
        } else {
            bothStack.Push(nums[i], 1); // 奇数入栈1
        }
    }

    std::cout << "栈1输出（奇数）：";
    while (!bothStack.IsEmpty(1)) {
        std::cout << bothStack.Pop(1) << " ";
    }
    std::cout << std::endl;

    std::cout << "栈2输出（偶数）：";
    while (!bothStack.IsEmpty(2)) {
        std::cout << bothStack.Pop(2) << " ";
    }
    std::cout << std::endl;

    return 0;
}

链队列（学生排队系统）

#include<iostream>
using namespace std;
 
typedef int QElemType;       
 
typedef struct QNode
{
    string ID;
    string name;
    struct QNode* next;
} QNode, * QueuePtr;
 
typedef struct
{
    QueuePtr front;     
    QueuePtr rear;       
} LinkQueue;
 
//销毁队列
void DestroyQueue(LinkQueue& Q)
{
    while (Q.front)
    {
        Q.rear = Q.front->next;
        delete Q.front;
        Q.front = Q.rear;
    }
}
 
//链队列初始化
void InitQueue(LinkQueue& Q)
{
    Q.front = new QNode;       
    Q.rear = Q.front;             
    Q.front->next = NULL;
    cout << "队列初始化成功" << endl;
}
 
//求链队列长度
int QueueLength(LinkQueue Q)
{
    QNode* p1 = Q.front;
    QNode* p2 = Q.rear;
    int length = 0;
    while (p1 != p2)
    {
        p1 = p1->next;
        length++;
    }
    return length;
}
 
//求链队列队头元素
void GetHead(LinkQueue Q)
{
    if (Q.front == Q.rear)
        cout << "链队列为空" << endl;
    else {
        cout << "队头学生的学号为:" << Q.front->next->ID << endl;
        cout << "队头学生的姓名为:" << Q.front->next->name << endl;
    }
     
}
 
//入队
void EnQueue(LinkQueue& Q)
{
    QNode* p = new QNode;
    cout << "请输入学号：" << endl;
    cin >> p->ID;
    cout << "请输入姓名：" << endl;
    cin >> p->name;
    p->next = NULL;
    Q.rear->next = p;
    Q.rear = p;
    cout << "入队成功" << endl;
}
 
//出队
void DeQueue(LinkQueue& Q)
{
    if (Q.front == Q.rear)
        cout << "没有同学正在排队" << endl;
    else
    {
        string id, Name;
        QNode* p = Q.front->next;
        id = p->ID;
        Name = p->name;
        Q.front->next = p->next;
        if (Q.rear == p)
            Q.rear = Q.front;
        delete p;              //释放被删结点
        cout << "请以下同学进入办公室答疑：" << endl;
        cout <<"学号："<< id<<"姓名：" << Name << endl;
    }
}
 
//输出队列元素
void DisplayQueue(LinkQueue Q)
{
    if (Q.front == Q.rear)
        cout << "链队列为空" << endl;
    else
    {
        QNode* p = Q.front->next;
        cout << "队头->";
        while (p)
        {
            cout << p->ID<<p->name << " ";
            p = p->next;
        }
        cout << "->队尾" << endl;
    }
}
 
 
void  Queueshow_help()
{
    cout << "\n******* 欢迎进入答疑系统 ******" << endl;
    cout << "1----排队" << endl;
    cout << "2----答疑" << endl;
    cout << "3----查看答疑人数" << endl;
    cout << "4----输出正在排队的学生" << endl;
    cout << "0----退出" << endl;
}
int main(){
 
LinkQueue Q;            
Queueshow_help();
InitQueue(Q);
while (1)
{
    int operate;
    cout << "输入要执行操作：";
    cin >> operate;
    
    if (operate == 1) 
    {
        
        cout << "请输入入队元素:";
        EnQueue(Q);
        continue;
    }
    else if (operate == 2)
    {
        DeQueue(Q);
        continue;
       
    }
    else if (operate == 3)
    {
        cout << "答疑队列中同学的数量为：" << QueueLength(Q) << endl;
        continue;
    }
   
    else if (operate == 4)
    {
        DisplayQueue(Q);
        continue;
    }
    else if (operate == 0)
    {
        break;
        cout<<"已到下班时间" << endl;
    }
    else
    {
        cout << "\n操作码错误！！！" << endl;
        Queueshow_help();
    }
}
DestroyQueue(Q);
}

对称矩阵压缩存储＋对称矩阵加法

#include <iostream>

class SymMatrix {
private:
    int order; // 阶数
    int *data; // 存放下三角的一维数组

    // 计算下标
    int index(int i, int j) {
        return i * (i + 1) / 2 + j;
    }

public:
    // 初始化矩阵阶数
    SymMatrix(int n) : order(n) {
        data = new int[(order * (order + 1)) / 2];
    }

    // 析构函数，释放动态分配的内存
    ~SymMatrix() {
        delete[] data;
    }

    // 输入元素值
    void Creat() {
        std::cout << "请输入对称矩阵的下三角元素值：" << std::endl;
        for (int i = 0; i < order; ++i) {
            for (int j = 0; j <= i; ++j) {
                std::cin >> data[index(i, j)];
            }
        }
    }

    // 查询i行j列元素值
    int Get(int i, int j) {
        if (i < 0 || i >= order || j < 0 || j >= order) {
            std::cerr << "索引超出矩阵范围" << std::endl;
            return -1;
        }
        if (i > j) {
            // 对称矩阵，交换i和j
            return data[index(j, i)];
        } else {
            return data[index(i, j)];
        }
    }

    // 输出矩阵
    void Print() {
        for (int i = 0; i < order; ++i) {
            for (int j = 0; j < order; ++j) {
                int val = Get(i, j);
                std::cout << val << " ";
            }
            std::cout << std::endl;
        }
    }

    // 对称矩阵的加法
    SymMatrix Add(SymMatrix A, SymMatrix B) {
        if (A.order != B.order) {
            std::cerr << "矩阵阶数不匹配，无法进行加法操作" << std::endl;
            return *this;
        }

        SymMatrix result(A.order);
        for (int i = 0; i < A.order; ++i) {
            for (int j = 0; j <= i; ++j) {
                int idx = A.index(i, j);
                result.data[idx] = A.data[idx] + B.data[idx];
            }
        }
        return result;
    }
};

int main() {
    int n;
    std::cout << "请输入矩阵的阶数：" << std::endl;
    std::cin >> n;

    SymMatrix A(n), B(n), C(n);
    A.Creat();
    std::cout << "矩阵A：" << std::endl;
    A.Print();

    B.Creat();
    std::cout << "矩阵B：" << std::endl;
    B.Print();

    C = A.Add(A, B);
    std::cout << "矩阵A和B的和：" << std::endl;
    C.Print();

    // 查找元素
    int i, j;
    std::cout << "请输入要查找的行号和列号：" << std::endl;
    std::cin >> i >> j;
    std::cout << "元素[" << i << "][" << j << "]的值是：" << A.Get(i, j) << std::endl;

    return 0;
}

稀疏矩阵压缩存储＋对称矩阵加法

#include <iostream>

using namespace std;

// 定义三元组结构体，用于存储稀疏矩阵中的非零元素
struct Triple {
    int row, col; // 行号和列号
    double value; // 元素值
};

// 稀疏矩阵加法函数
// a, b是输入的两个稀疏矩阵的三元组数组，aRows, aCols, bRows, bCols分别是矩阵的行数和列数
// aNum, bNum是非零元素的个数，c是结果矩阵的三元组数组，cNum是结果矩阵非零元素的个数
void addSparseMatrices(Triple* a, int aRows, int aCols, int aNum, Triple* b, int bRows, int bCols, int bNum, Triple*& c, int& cNum) {
    // 检查两个矩阵的维度是否相同
    if (aRows != bRows || aCols != bCols) {
        cout << "Matrices dimensions do not match." << endl;
        return;
    }

    // 初始化结果矩阵的非零元素个数为0
    cNum = 0;

    // 创建临时数组存储结果，最坏情况下，非零元素个数等于两个矩阵非零元素个数之和
    Triple* tempC = new Triple[aNum + bNum];

    int i = 0, j = 0, k = 0; // 分别是a, b和tempC的索引
    while (i < aNum && j < bNum) {
        if (a[i].row < b[j].row || (a[i].row == b[j].row && a[i].col < b[j].col)) {
            // 如果a的当前元素的行号或列号小于b的，将a的元素复制到tempC
            tempC[k++] = a[i++];
        } else if (a[i].row > b[j].row || (a[i].row == b[j].row && a[i].col > b[j].col)) {
            // 如果b的当前元素的行号或列号小于a的，将b的元素复制到tempC
            tempC[k++] = b[j++];
        } else {
            // 如果行号和列号相同，将两个元素的值相加
            tempC[k].row = a[i].row;
            tempC[k].col = a[i].col;
            tempC[k].value = a[i].value + b[j].value;
            if (tempC[k].value != 0) {
                k++; // 如果相加的结果不为0，则加入tempC
            }
            i++;
            j++;
        }
    }

    // 将a或b中剩余的元素复制到tempC
    while (i < aNum) {
        tempC[k++] = a[i++];
    }
    while (j < bNum) {
        tempC[k++] = b[j++];
    }

    // 更新非零元素个数
    cNum = k;

    // 动态分配最终结果数组
    c = new Triple[cNum];

    // 复制临时数组到最终结果数组
    for (int m = 0; m < cNum; ++m) {
        c[m] = tempC[m];
    }

    // 释放临时数组
    delete[] tempC;
}

// 输出稀疏矩阵函数
void printSparseMatrix(Triple* matrix, int rows, int cols, int num) {
    cout << rows << " " << cols << " " << num << endl;
    for (int i = 0; i < num; ++i) {
        cout << matrix[i].row << " " << matrix[i].col << " " << matrix[i].value << endl;
    }
}

int main() {
    int rows, cols, numA, numB;

    // 输入第一个稀疏矩阵的行数、列数和非零元素个数
    cout << "Enter the number of rows, columns, and non-zero elements for matrix A: ";
    cin >> rows >> cols >> numA;
    Triple* a = new Triple[numA]; // 动态分配矩阵A的内存
    // 输入矩阵A的非零元素
    cout << "Enter the row, column, and value for each non-zero element of matrix A:" << endl;
    for (int i = 0; i < numA; ++i) {
        cin >> a[i].row >> a[i].col >> a[i].value;
    }

    // 输入第二个稀疏矩阵的行数、列数和非零元素个数
    cout << "Enter the number of rows, columns, and non-zero elements for matrix B: ";
    cin >> rows >> cols >> numB;
    Triple* b = new Triple[numB]; // 动态分配矩阵B的内存
    // 输入矩阵B的非零元素
    cout << "Enter the row, column, and value for each non-zero element of matrix B:" << endl;
    for (int i = 0; i < numB; ++i) {
        cin >> b[i].row >> b[i].col >> b[i].value;
    }

    // 计算稀疏矩阵的和
    Triple* c; // 用于存储结果矩阵的三元组数组
    int cNum; // 结果矩阵非零元素的个数
    addSparseMatrices(a, rows, cols, numA, b, rows, cols, numB, c, cNum);

    // 输出结果矩阵
    cout << "Matrix C (A + B):" << endl;
    printSparseMatrix(c, rows, cols, cNum);

    // 释放内存
    delete[] a;
    delete[] b;
    delete[] c;

    return 0;
}

二叉树的顺序存储

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>

using namespace std;

class SeqTree {
private:
    char data[100]; // 存储结点数据的数组，大小为100，足以存储99个节点的完全二叉树
    int NodeNum, EndIndex; // NodeNum代表结点数量，EndIndex代表最后一个叶子结点的索引

    // 计算左孩子和右孩子的位置
    int left(int i) { return 2 * i + 1; } // 返回节点i的左孩子索引
    int right(int i) { return 2 * i + 2; } // 返回节点i的右孩子索引
    int parent(int i) { return (i - 1) / 2; } // 返回节点i的父节点索引

public:
    SeqTree() : NodeNum(0), EndIndex(-1) { // 构造函数，初始化空树
        fill(data, data + 100, '#'); // 初始化数组，将所有元素设置为'#'，表示空节点
    }

    void CreatTree() { // 输入各个结点数据，建立二叉树
        char ch; 
        cout << "Enter node values (use # for null nodes): ";
        for (int i = 0; i < 100; ++i) {
            cin >> ch;
            if (ch == '*') break; // 输入结束标志
            data[i] = ch;
            NodeNum++;
            if (ch != '#') EndIndex = i; // 更新最后一个叶子结点的索引
        }
    }

    void LeverOrder() { // 层序遍历输出每个结点
        cout << "Level order traversal: ";
        for (int i = 0; i < NodeNum; ++i) {
            if (data[i] != '#') cout << data[i]; // 只输出非空节点
        }
        cout << endl;
    }

    void PrintMessage() { // 输出每个结点的双亲和孩子信息
        for (int i = 0; i < NodeNum; ++i) {
            if (data[i] != '#') {
                char parentChar = (parent(i) >= 0 && parent(i) < NodeNum) ? data[parent(i)] : '无';
                char leftChar = (left(i) < NodeNum && data[left(i)] != '#') ? data[left(i)] : '无';
                char rightChar = (right(i) < NodeNum && data[right(i)] != '#') ? data[right(i)] : '无';
                cout << data[i] << "结点的双亲是" << parentChar << "，左孩子是" << leftChar << "，右孩子是" << rightChar << endl;
            }
        }
    }

    void PrintLeaves() { // 输出叶子结点信息
        cout << "Leaf nodes: ";
        for (int i = 0; i < NodeNum; ++i) {
            if (data[i] != '#' && left(i) >= NodeNum && right(i) >= NodeNum) {
                cout << data[i]; // 输出叶子结点的值
            }
        }
        cout << endl;
    }

    int GetLeavesNum() { // 返回叶子结点数量
        int count = 0;
        for (int i = 0; i < NodeNum; ++i) {
            if (data[i] != '#' && left(i) >= NodeNum && right(i) >= NodeNum) {
                count++; // 计数叶子结点
            }
        }
        return count;
    }

    void PreOrder(int i) { // 前序遍历结点
        if (i < NodeNum && data[i] != '#') {
            cout << data[i]; // 访问当前节点
            PreOrder(left(i)); // 遍历左子树
            PreOrder(right(i)); // 遍历右子树
        }
    }

    void InOrder(int i) { // 中序遍历结点
        if (i < NodeNum && data[i] != '#') {
            InOrder(left(i)); // 遍历左子树
            cout << data[i]; // 访问当前节点
            InOrder(right(i)); // 遍历右子树
        }
    }

    void PostOrder(int i) { // 后序遍历结点
        if (i < NodeNum && data[i] != '#') {
            PostOrder(left(i)); // 遍历左子树
            PostOrder(right(i)); // 遍历右子树
            cout << data[i]; // 访问当前节点
        }
    }
};

int main() {
    SeqTree tree;
    tree.CreatTree(); // 创建二叉树
    cout << "Lever Order: " << endl;
    tree.LeverOrder(); // 层序遍历
    cout << "Message: " << endl;
    tree.PrintMessage(); // 输出结点信息
    cout << "Leaves: " << endl;
    tree.PrintLeaves(); // 输出叶子结点
    cout << "Leaves Number: " << tree.GetLeavesNum() << endl; // 输出叶子结点数量
    cout << "PreOrder: ";
    tree.PreOrder(0); // 前序遍历
    cout << endl;
    cout << "InOrder: ";
    tree.InOrder(0); // 中序遍历
    cout << endl;
    cout << "PostOrder: ";
    tree.PostOrder(0); // 后序遍历
    cout << endl;
    return 0;
}

二叉树的链式存储

#include <iostream>

using namespace std;

// 定义二叉树节点结构体
struct BiNode {
    char data;       // 节点存储的数据
    BiNode* lchild;  // 左孩子指针
    BiNode* rchild;  // 右孩子指针

    // 构造函数，初始化节点数据和指针
    BiNode(char val) : data(val), lchild(nullptr), rchild(nullptr) {}
};

// 定义二叉树类
class BiTree {
private:
    BiNode* root; // 二叉树的根节点

    // 私有成员函数：递归计算二叉树的结点个数
    int getNodeNum(BiNode* bt) {
        if (bt == nullptr) { // 如果节点为空，返回0
            return 0;
        } else {
            return 1 + getNodeNum(bt->lchild) + getNodeNum(bt->rchild); // 递归计算左右子树的结点个数，并加1
        }
    }

    // 私有成员函数：递归按前序次序打印出二叉树中的叶子结点
    void PreOrderLeaf(BiNode* bt) {
        if (bt != nullptr) {
            if (bt->lchild == nullptr && bt->rchild == nullptr) { // 如果是叶子结点
                cout << bt->data << " "; // 打印结点数据
            }
            PreOrderLeaf(bt->lchild); // 递归左子树
            PreOrderLeaf(bt->rchild); // 递归右子树
        }
    }

    // 私有成员函数：递归计算二叉树的深度
    int getDepth(BiNode* bt) {
        if (bt == nullptr) {
            return 0; // 如果节点为空，返回深度为0
        } else {
            int leftDepth = getDepth(bt->lchild); // 计算左子树深度
            int rightDepth = getDepth(bt->rchild); // 计算右子树深度
            return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1; // 返回较大深度加1
        }
    }

public:
    // 构造函数，初始化根节点为空
    BiTree() : root(nullptr) {}

    // 公共成员函数：求二叉树的结点个数
    void getNodeNum() {
        int count = getNodeNum(root); // 调用私有成员函数计算结点个数
        cout << "The number of nodes is: " << count << endl; // 输出结点个数
    }

    // 公共成员函数：按前序次序打印出二叉树中的叶子结点
    void PreOrderLeaf() {
        PreOrderLeaf(root); // 调用私有成员函数按前序打印叶子结点
        cout << endl; // 输出换行
    }

    // 公共成员函数：求二叉树的深度
    int getDepth() {
        return getDepth(root); // 调用私有成员函数计算深度
    }

    // 插入节点的公共成员函数
    void insertNode(BiNode*& node, char data) {
        BiNode* newNode = new BiNode(data); // 创建新节点
        if (node == nullptr) {
            node = newNode; // 如果插入位置为空，则设置新节点为该位置的节点
        } else {
            // 这里可以添加代码来插入新节点，例如按某种顺序插入
            // 例如，这里我们简单地将新节点作为右孩子插入
            if (node->rchild == nullptr) {
                node->rchild = newNode;
            } else {
                // 如果右孩子不为空，则需要添加更复杂的逻辑来确定插入位置
                // 这里省略
            }
        }
    }
};

int main() {
    BiTree tree;
    tree.insertNode(tree.root, 'A'); // 插入根节点
    tree.insertNode(tree.root->lchild, 'B'); // 插入左孩子
    tree.insertNode(tree.root->rchild, 'C'); // 插入右孩子
    tree.insertNode(tree.root->lchild->lchild, 'D'); // 插入左左孩子
    tree.insertNode(tree.root->lchild->rchild, 'E'); // 插入左右孩子
    tree.insertNode(tree.root->rchild->rchild, 'F'); // 插入右右孩子

    cout << "Number of nodes: ";
    tree.getNodeNum(); // 调用getNodeNum函数

    cout << "PreOrder Leaf nodes: ";
    tree.PreOrderLeaf(); // 调用PreOrderLeaf函数

    cout << "Depth of tree: " << tree.getDepth() << endl; // 调用getDepth函数

    return 0;
}