数据结构第三章多项式加法

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <iterator>
#include <initializer_list>
#include <deque>
#include <list>
#include <array>
#include <forward_list>
#include <sstream>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <memory>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <type_traits>
#include <utility>
#include <tuple>
#include <bitset>
#include <regex>
#include <random>
#include <iomanip>
#include <ctime>
#include <cmath>
#define ERROR -1
using namespace::std;
using ElementType = int;
#define ERROR -1
#define MAXSIZE 10
#define FIRSTVOID 88888
struct PolyNode;
typedef PolyNode* PtrToPolyNode;

struct PolyNode
{
	int expon;//eponantional
	int ceof;//系数
	PtrToPolyNode link;
};

using PolyNominal = PtrToPolyNode;

PolyNominal CreatePoly()
{
	PolyNominal P = (PolyNominal)malloc(sizeof(PolyNode));
	P->link = nullptr;
	P->expon = FIRSTVOID;
	P->ceof = FIRSTVOID;
	return P;
}

bool IsEmpty(PolyNominal P)
{
	if (P->link == nullptr)
	{
		return true;
	}
	else
		return false;
}

PtrToPolyNode FindExpo(PolyNominal P, int exp)
{
	if (IsEmpty(P))
	{
		return nullptr;
	}
	else
	{
		PtrToPolyNode Pos=P->link;
		while (Pos)
		{
			if (Pos->expon == exp)
			{
				return Pos;
			}
			Pos = Pos->link;
		}
		return nullptr;
	}
}

PolyNominal Plus(PolyNominal P1, int cf, int exp)
{
	if (IsEmpty(P1))
	{
		PtrToPolyNode addition=(PtrToPolyNode)malloc(sizeof(PolyNode));
		addition->expon = exp;
		addition->ceof = cf;
		addition->link = nullptr;
		P1->link = addition;
		return P1;
	}
	if (auto c=FindExpo(P1, exp))
	{
		c->ceof += cf;
		return P1;
	}
	else
	{
		PtrToPolyNode Pre=P1->link;
		if (Pre->expon < exp)
		{
			PtrToPolyNode addition = (PtrToPolyNode)malloc(sizeof(PolyNode));
			addition->expon = exp;
			addition->ceof = cf;
			addition->link = Pre;
			P1->link = addition;
			return P1;
		}
		while (Pre->link!=NULL)
		{
			if ((Pre->expon > exp) && (Pre->link->expon < exp))
			{
				PtrToPolyNode addition = (PtrToPolyNode)malloc(sizeof(PolyNode));
				addition->expon = exp;
				addition->ceof = cf;
				addition->link = Pre->link;
				Pre->link = addition;
				return P1;
			}
			Pre = Pre->link;
		}
		if (Pre->expon > exp)
		{
			PtrToPolyNode addition = (PtrToPolyNode)malloc(sizeof(PolyNode));
			addition->expon = exp;
			addition->ceof = cf;
			addition->link = nullptr;
			Pre->link = addition;
			return P1;
		}
		return P1;
	}
}

void show(PolyNominal P1)
{
	if (IsEmpty(P1))
	{
		cout << "The PolyNominal is empty." << endl;
		return;
	}
	else
	{
		PtrToPolyNode pos = P1->link;
		while (pos)
		{
			if (pos->expon == FIRSTVOID)
			{
				pos = pos->link;
				continue;
			}
			cout <<((pos->ceof>=0)? "+":"-") << abs(pos->ceof) << "x^" << pos->expon;
			pos = pos->link;
		}
	}
	cout << endl;
}

int Compare(int e1, int e2)
{
	if (e1 > e2)
		return 1;
	else if (e1 == e2)
		return 0;
	else
		return -1;
}

void Attach(int ceof, int expon, PolyNominal* PtrRear)
{
	PolyNominal P = (PolyNominal)malloc(sizeof(PolyNode));
	P->ceof = ceof;
	P->expon = expon;
	P->link = nullptr;

	(*PtrRear)->link = P;
	*PtrRear = P;
}


PolyNominal PolyAdd(PolyNominal P1, PolyNominal P2)
{
	PolyNominal front, rear;
	int sum;
	rear = CreatePoly();
	front = rear;
	while (P1&&P2)
	{
		switch (Compare(P1->expon, P2->expon))
		{
		case 1:
			Attach(P1->ceof, P1->expon, &rear);
			P1 = P1->link;
			break;
		case -1:
			Attach(P2->ceof, P2->expon, &rear);
			P2 = P2->link;
			break;
		case 0:
			sum = P1->ceof + P2->ceof;
			if (sum)
				Attach(sum, P1->expon, &rear);
			P1 = P1->link;
			P2 = P2->link;
			break;
		}
	}
	for (; P1; P1 = P1->link)Attach(P1->ceof, P1->expon, &rear);
	for (; P2; P2 = P2->link)Attach(P2->ceof, P2->expon, &rear);
	rear->link = nullptr;
	return front;
}

int main()
{
	PolyNominal P1 = CreatePoly();
	Plus(P1, 5, 4);
	Plus(P1, 3, 3);
	Plus(P1, 4, 4);
	Plus(P1, 6, 6);
	Plus(P1, -3, -2);
	show(P1);
	PolyNominal P2 = CreatePoly();
	Plus(P2, 4, 5);
	Plus(P2, 3, 2);
	show(P2);
	PolyNominal P3 = PolyAdd(P1, P2);
	show(P3);
	return 0;
}