（自用）zju fds 第二次课

NatsuKiiiiii

已于 2023-12-04 23:39:45 修改

阅读量398

点赞数 9

分类专栏：数据结构自学记录文章标签：算法 c++ 数据结构

于 2023-11-30 15:51:47 首次发布

本文链接：https://blog.csdn.net/SHIgaNatsuki/article/details/134714487

版权

数据结构自学记录专栏收录该内容

7 篇文章 0 订阅

订阅专栏

zju的数据结构题只能记录到这了，md这课要截止了。之后会通过代码随想录来学习数据结构和算法题。

-----------------------------------------------------------------------------------------------------

第一题一元多项式的和与乘积

不知道为什么在合并上面过不去，大失败。但是基本流程摸清楚了。

//线性结构2 设计函数分别求两个一元多项式的乘积与和
#include<iostream>
using namespace std;
typedef struct polynode* polynomial;
struct polynode {
	int coef;
	int expon;
	polynode* next;//结构指针
};

polynomial read_poly(polynomial p);
void print_poly(polynomial p);
polynomial mult(polynomial p1, polynomial p2);
polynomial add(polynomial p1, polynomial p2);


int main() {
	//大体框架	
	//多项式输出
	//读入多项式1
	//读入多项式2
	//做乘法运算然后输出
	//做加法运算然后输出
	polynomial p1=NULL, p2=NULL, pp=NULL, ps=NULL;
	p1 = read_poly(p1);
	p2 = read_poly(p2);
	pp = mult(p1, p2);
	print_poly(pp);
	ps = add(p1, p2);
	print_poly(ps);


	return 0;
}





//函数1，读多项式
polynomial read_poly(polynomial p) {
	polynomial s=NULL, temp;
	p = ( polynomial)malloc(sizeof(struct polynode));//表头
	temp = p;
	int n, c, e;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> c >> e;
		if (c != 0) {
			s= (polynomial)malloc(sizeof(struct polynode));
			s->coef = c;
			s->expon = e;
			p->next = s;
			p = s;
		}
	}
	p->next = NULL;
	return temp;
}

//函数2 相加
polynomial add(polynomial p1, polynomial p2) {

	polynomial p = (polynomial)malloc(sizeof(struct polynode));
	polynomial temp = p,s=NULL;


	while (p1->next  && p2->next) {

		if (p1->next->expon > p2->next->expon) {
			s = (polynomial)malloc(sizeof(struct polynode));
			s->coef = p1->next->coef;
			s->expon = p1->next->expon;
			p->next = s;
			p = s;
			p1 = p1->next;
			
		}
		else if (p1->next->expon < p2->next->expon) {
			s = (polynomial)malloc(sizeof(struct polynode));
			s->coef = p2->next->coef;
			s->expon = p2->next->expon;
			p->next = s;
			p = s;
			p2 = p2->next;
		}
		else {
			if (p1->next->coef + p2->next->coef != 0) {
				s = (polynomial)malloc(sizeof(struct polynode));
				s->coef = p1->next->coef+p2->next->coef;
				s->expon = p1->next->expon;
				p->next = s;
				p = s;
				p1 = p1->next;
				p2 = p2->next;
			}
			else {
				p1 = p1->next;
				p2 = p2->next;
			}

			
		}
	}
	if (p1->next) p->next = p1->next;
	else p->next = p2->next;

	return temp;
}



//函数3 相乘，这里是逐项插入
polynomial mult(polynomial p1, polynomial p2) {

	if (!p1->next || !p2->next) return NULL;//p1,p2中有一个是空的 乘积就是空，null

	polynomial p, temp = NULL, s = NULL;
	p = (polynomial)malloc(sizeof(struct polynode));
	temp = p;
	polynomial pa = p1;//pa为第一项的前置点
	while (pa->next) {//先用p2的第一项去乘p1所有项得到初始p
		s = (polynomial)malloc(sizeof(struct polynode));
		s->coef = pa->next->coef * p2->next->coef;
		s->expon = pa->next->expon + p2->next->expon;
		p->next = s;
		p = s;
		pa = pa->next;

	}
	p->next = NULL;//到这初始项就列好了

	p = temp;//重新设置结果起点
	polynomial pb = p2->next;//pb为第二项的前置点
	while (pb->next!= NULL) 
	{//现在要做的是把p2的第二项之后的去乘p1所有项然后插入
		pa = p1;//设置p1起点
		while (pa->next != NULL) {
			int c = pa->next->coef * pb->next->coef;
			int e = pa->next->expon + pb->next->expon;
			//这里相乘得到的数需要在原列中找到对应的位置，分成两者情况（如果e从没出现过，就在找到的位置插入，如果已经出现过了，就加上）
			//加上的时候又会有两者情况，如果加上的c=0，那就把这个点删掉，如果c不等于就保留
			while (p->next) {
				if (p->next->expon < e) {
					polynomial s = (polynomial)malloc(sizeof(struct polynode));
					s->coef = c;
					s->expon = e;
					s->next = p->next;
					p->next = s;
					break;
				}
				else if(p->next->expon == e) {
					int sum = p->next->coef + c;
					if (sum != 0) {
						p->next->coef = sum;
						break;
					}
					else {
						polynomial t = p->next;
						p->next = p->next->next;
						delete t;
						break;
					}
				}
				p = p->next;
			}
			if (p->next == NULL) {
				//到末尾了还没插入
				polynomial s = (polynomial)malloc(sizeof(struct polynode));
				s->coef = c;
				s->expon = e;
				p->next = s;
				s->next = NULL;
			}
			p = temp;//p回到起点
			pa = pa->next;		
		}
		pb = pb->next;

	}

	return temp;
}

//函数4，输出多项式
void print_poly(polynomial P)
{
	int num = 0, temp = 0;  //temp用于统计P里面有多少个元素，num 用于统计有多少个系数为0的数 
	polynomial val = P;
	while (val->next)
	{
		val = val->next;
		temp++;
	}
	if (P->next != NULL)
	{
		while (P->next)
		{
			if (P->next->coef != 0)
			{
				cout << P->next->coef << " " << P->next->expon;
				polynomial val = P->next;
				while (val->next && val->next->coef == 0)
				{
					val = val->next;
				}
				if (val->next == NULL)
					cout << endl;
				else
					cout << " ";
			}
			else
				num++;
			P = P->next;
		}
		if (num == temp)
			cout << 0 << " " << 0 << endl;
	}
	else
		cout << 0 << " " << 0 << endl;
}

第一题用另外一种方法搞清楚了，把乘法换成 p1和p2的每一项相乘的结果再加起来就行，复用之前的add函数，提高效率。现在这版是可以通过测试的。

//线性结构2 设计函数分别求两个一元多项式的乘积与和
#include<iostream>
using namespace std;

typedef struct polynode* polynomial;
 struct polynode {
	int coef;
	int expon;
	polynomial next;//结构指针
};

polynomial read_poly();
void print_poly(polynomial p);
polynomial mult(polynomial p1, polynomial p2);
polynomial add(polynomial p1, polynomial p2);


int main() {
	//大体框架	
	//多项式输出
	//读入多项式1
	//读入多项式2
	//做乘法运算然后输出
	//做加法运算然后输出
	polynomial p1, p2, pp, ps;
	p1 = read_poly();
	p2 = read_poly();
	pp = mult(p1, p2);
	print_poly(pp);
	ps = add(p1, p2);
	print_poly(ps);


	return 0;
}





//函数1，读多项式
polynomial read_poly() {
	
	polynomial head = new polynode;//表头
	head->next = NULL;
	int n;
	cin >> n;
	polynomial last = head, temp;

	for (int i = 0; i < n; i++) {
		temp = new polynode;
		cin >> temp->coef >> temp->expon;
		temp->next = NULL;
		last->next = temp;
		last = last->next;	
	}
	return head;
}

//函数2 相加
polynomial add(polynomial p1, polynomial p2) {

	polynomial head = new polynode;
	head->next = NULL;
	polynomial last = head, temp,t1=p1->next, t2=p2->next;
	while (t1 && t2) {
		temp = new polynode;
		temp->next = NULL;
		if (t1->expon > t2->expon) {
			temp->coef = t1->coef;
			temp->expon = t1->expon;
			t1 = t1->next;
		}
		else if (t1->expon < t2->expon) {
			temp->coef = t2->coef;
			temp->expon = t2->expon;
			t2 = t2->next;
		}
		else {
			if (t1->coef + t2->coef != 0) {
				temp->coef = t1->coef + t2->coef;
				temp->expon = t1->expon;

			}
			else {
				delete(temp);
				temp = NULL;
			}
			t1 = t1->next;
			t2 = t2->next;
		}
		if (temp) {
			last->next = temp;
			last = last->next;
		}
	}
	if (t1) last->next = t1;
	if (t2) last->next = t2;
	return head;
}



//函数3 整体相乘，就是每一项相乘然后相加的结果
//simple中p1的第一项与p2all相乘,传入的是去了头的链
polynomial simpleMult(polynomial p1, polynomial p2) {
	polynomial head = new polynode;
	head->next = NULL;
	polynomial last = head, t2 = p2, temp;
	while (t2) {
		temp = new polynode;
		temp->next = NULL;
		temp->coef = p1->coef * t2->coef;
		temp->expon = p1->expon + t2->expon;
		last->next = temp;
		last = last->next;
		t2 = t2->next;
	}
	return head;
}
polynomial mult(polynomial p1, polynomial p2) {
	polynomial head = new polynode;
	head->next = NULL;
	polynomial temp,t1=p1->next;
	while (t1){
		polynomial t2 = p2->next;//重新设置起点
		temp = simpleMult(t1, t2);
		head = add(head, temp);
		t1 = t1->next;
	}
	return head;

}


//函数4，输出多项式
void print_poly(polynomial head)
{
	polynomial p = head->next;
	if (!p) {
		cout << "0 0";
	}
	while (p) {
		cout << p->coef << " " << p->expon;
		if (p->next) cout << " ";
		p = p->next;
	}
	cout << endl;
}


//https://zhuanlan.zhihu.com/p/113356941

第二题，反转链表，这里的知识点我主要从力扣上学习，这里的代码以后有时间再看吧

#include<iostream>
#include<vector>
using namespace std;
#define MAX_ADDRESS_SIZE 100000

struct Node
{
	int Address = -1;
	int Data = 0;
	int Next = -1;
};

void reverse_linked_nodes(vector<Node>& list, int start, int end)
{
	while (start < end)
	{
		Node temp = list[start];
		list[start] = list[end];
		list[end] = temp;
		start++;
		end--;
	}
}
int main()
{
	int head_addr, node_count, reverse_node_count;
	cin >> head_addr >> node_count >> reverse_node_count;

	vector<Node> nodes(MAX_ADDRESS_SIZE);
	for (int i = 0; i < node_count; i++)
	{
		int addr, data, next;
		cin >> addr >> data >> next;
		nodes[addr].Address = addr;
		nodes[addr].Data = data;
		nodes[addr].Next = next;
	}

	vector<Node> node_list;
	node_list.push_back(nodes[head_addr]);
	while (node_list.back().Next != -1)
	{
		node_list.push_back(nodes[node_list.back().Next]);
	}

	int reverse_times = node_list.size() / reverse_node_count;
	for (int i = 0; i < reverse_times; i++)
	{
		int start = i * reverse_node_count;
		int end = start + reverse_node_count - 1;
		reverse_linked_nodes(node_list, start, end);
	}
	for (int i = 0; i < node_list.size() - 1; i++)
	{
		printf("%05d %d %05d\n", node_list[i].Address, node_list[i].Data, node_list[i + 1].Address);
	}
	printf("%05d %d %d\n", node_list.back().Address, node_list.back().Data, -1);
	return 0;
}

第三题，出栈合法检测

这里用一个队列和栈来检测。

先用一个队列来存出栈数据，然后进行比较。外面最大的循环是看队列q没有空以及栈没有满。

然后开始将y入栈，这里y从1到n。每一次压入都需要判断一下：栈顶top和队列头front是否相等，如果相等就都pop，直到有一个吐空了或者不相等。

一直压到y大于我的合法数为止。

那么，什么时候不合法。就是我的栈或者队列没有吐干净。

#include<iostream>
#include<queue>
#include<stack>
using namespace std;

int main()
{
	int m, n, k;
	cin >> m >> n >> k;
	stack<int> s;
	queue<int> q;
	for (int i = 0; i < k; i++) {
		while (!s.empty()) {
			s.pop();
		}
		while (!q.empty()) {
			q.pop();
		}
				
		int x;
		for (int j = 0; j < n; j++) {
			cin >> x;
			q.push(x);
		}

		int y = 1;
		while (!q.empty() && s.size() < m) {
			s.push(y);
			y++;
			while (!s.empty() && !q.empty() && s.top() == q.front()) {
				q.pop();
				s.pop();
			}
			if (y == n + 1) {
				break;
			}
		}
		if (s.empty ()&& q.empty()) {
			cout << "YES" << endl;
		}
		else {
			cout << "NO" << endl;
		}
	}
	return 0;
}
//https://www.bilibili.com/video/BV1CT4y1R7Z2/?spm_id_from=333.337.search-card.all.click&vd_source=4aa8d7d8acd52d0ab8cb2136814e456a