ch03.表栈队列--单链表实现多项式操作

0.引言

实现多项式的加法与乘法。

1.使用结构体实现

#include <iostream>
#include <algorithm>

using namespace std;

/************************************结构体实现多项式操作**************************/

//demo：  多项式ADT
const int MaxDegree = 20;
typedef struct  polynomialNode
{
	int CoeffArray[MaxDegree + 1];
	int HighPower;
}*polynomial;

//将多项式初始化为0
void ZeroPolynomial(polynomial Poly)
{
	int i;
	for (int i = 0; i <= MaxDegree; i++)
		Poly->CoeffArray[i] = 0;
	Poly->HighPower = 0;
}

//将多项式初始化为0
void ZeroPolynomial(polynomial Poly,int N)
{
	int i;
	for (int i = 0; i <= N; i++)
		Poly->CoeffArray[i] = 0;
	Poly->HighPower = 0;
}

//初始化多项式
void InitPolynomial(polynomial Poly,const int A[],const int N)
{
	int i;
	for (int i = 0; i <= N; i++)
		Poly->CoeffArray[i] = A[i];
	Poly->HighPower = N - 1;
}

//两个多项式相加
void Struct4AddPolynomial(const polynomial Poly1, const polynomial Poly2, polynomial PolySum)
{
	int i;
	ZeroPolynomial(PolySum);
	PolySum->HighPower = std::max(Poly1->HighPower, Poly2->HighPower);
	for (i = PolySum->HighPower; i >= 0; i--)
		PolySum->CoeffArray[i] = Poly1->CoeffArray[i] + Poly2->CoeffArray[i];
}

//多项式相乘
void Struct4MultPolynomial(const polynomial Poly1, const polynomial Poly2, polynomial PolyProd)
{
	int i, j;
	ZeroPolynomial(PolyProd);
	PolyProd->HighPower = Poly1->HighPower + Poly2->HighPower;
	if (PolyProd->HighPower > MaxDegree)  std::cout << "MaxDegree Error!" << endl;
	else
		for (size_t i = 0; i < Poly1->HighPower; i++)
			for (size_t j = 0; j < Poly2->HighPower; j++)
				PolyProd->CoeffArray[i + j] += Poly1->CoeffArray[i] * Poly2->CoeffArray[j];
}
void DisplayPolynomial(polynomial Poly,int N)
{
	int i;
	int tmpN = N;
	for (int i = 0; i < N; i++)
		cout << Poly->CoeffArray[i] << "X^" << --tmpN << "+";
}

void StructPolynomialTest()
{
	int A1[] = { 1,2,3 };
	int A2[] = { 4,5,6 };
	int N1 = sizeof(A1) / sizeof(int);
	int N2 = sizeof(A2) / sizeof(int);
	//polynomial poly1 = (polynomial)malloc(sizeof(struct polynomialNode));
	//polynomial poly2 = (polynomial)malloc(sizeof(struct polynomialNode));
	//poly1->CoeffArray = A1;
	//poly2->CoeffArray = A2;

	polynomialNode poly1 = { {1,2,3},3 };
	polynomialNode poly2 = { {4,5,6},3 };

	polynomial p1 = &poly1;
	polynomial p2 = &poly2;

	polynomialNode polysum;
	polynomial psum = &polysum;
	ZeroPolynomial(psum, N1 > N2 ? N1 : N2);


	DisplayPolynomial(p1, N1);
	cout << endl;
	DisplayPolynomial(p2, N2);
	cout << endl;

	//加法
	cout <<endl<< "AddPolynomial Result:  " << endl;
	Struct4AddPolynomial(p1,p2,psum);
	DisplayPolynomial(psum, N1 > N2 ? N1 : N2);
	cout << endl;

	//乘法
	cout <<endl<< "MultPolynomial Result:  " << endl;
	polynomialNode polyprod;
	polynomial pd = &polyprod;
	ZeroPolynomial(pd, (N1 + N2 - 1));
	Struct4MultPolynomial(p1, p2, pd);
	DisplayPolynomial(pd, N1 + N2 - 1);
	cout << endl;
}

int main(int argc, char** argv)
{
	StructPolynomialTest();
	//ListPolynomialTest();
	//RadioSortTest();
	//StudentCourseTest();
	system("pause");
	return 0;
}

2.单链表实现

#include <iostream>
#include <algorithm>

using namespace std;
/*************使用单链表实现，多项式的操作，多项式的每一项包含在Node里面，随着次数排列*************/

typedef struct Node *PtrToNode;

struct Node
{
	int Coefficient;
	int Exponent;
	PtrToNode Next;
};

typedef PtrToNode Polynomial;
typedef PtrToNode List;
typedef PtrToNode Position;



//两种创建链表方法之一，头插法
void InitListHead(List* L, int N)
{
	List p;
	*L = (List)malloc(sizeof(Node));
	(*L)->Next = NULL;//先建立一个带头结点的单链表

	for (int i= 0;i<N;i++)
	{
		p = (List)malloc(sizeof(Node));//新节点
		p->Coefficient = 0;
		p->Coefficient = 0;

		p->Next = (*L)->Next;//指向
		(*L)->Next = p;//插入到表头
	}
}


//初始化为0
//两种创建链表方法之二，尾插法
void InitListTail(List *L, int N)
{
	List p, tail;
	*L = (List)malloc(sizeof(Node));
	
	(*L)->Coefficient = 0;//不需要头结点
	(*L)->Exponent = 0;
	/*  如果定义了头结点，读取的时候
		p = poly1->next;  //指向第一个节点，跳过头结点
	*/

	tail = *L;//tail指向尾部的节点

	for (int i = 0; i < N; i++)
	{
		p = (List)malloc(sizeof(Node));//新节点
		p->Coefficient = 0;
		p->Exponent = 0;

		tail->Next = p;//记住指针域里面只是一个数：地址，这里将当前节点的指针域更新
		tail = p;//这里就将tail滑动到新节点，指针域此时是乱码
	}
	tail->Next = NULL;//记住最后一位的指针需要置为NUll
}



//使用系数和指数数组进行初始化
void InitPolynomial(const double A[],Polynomial polynomial,int N)
{
	int i = 0;
	//int N = sizeof(A) / sizeof(double);

	while (polynomial->Next!=NULL)
	{
		polynomial->Coefficient = A[i];
		polynomial->Exponent = --N;
		polynomial = polynomial->Next;
		i++;
	}
}


int GetListLen(List L)
{
	int len = 0;
	while (L->Next!=NULL)
	{
		len++;
		L = L->Next;
	}
	return len;
}


//两个多项式相加
void AddPolynomial(Polynomial Poly1, Polynomial Poly2, Polynomial* PolySum)
{
	int  len1 = GetListLen(Poly1);
	//int N = sizeof(A) / sizeof(double);
	int  len2 = GetListLen(Poly2);
	Polynomial p1,p2,ps;//需要重新定义一个节点来滑动
	p1 = Poly1;
	p2 = Poly2;
	
	if (len1 >= len2)		InitListTail(PolySum, len1);
	else             		InitListTail(PolySum, len2);

	//我大概知道为什么要头结点了，如果加了头结点，这里赋值ps=(*PolySum)->Next,则PS赋值的是一个节点的地址，如果没有，赋值的是整个链表
	ps = *PolySum;

	while (p1->Next != NULL && p2->Next != NULL)
	{
		if (p1->Exponent > p2->Exponent)
		{
			ps->Exponent = p1->Exponent;
			ps->Coefficient = p1->Coefficient;
			p1 = p1->Next;
			ps = ps->Next;
		}
		else if (p1->Exponent < p2->Exponent)
		{
			ps->Exponent = p2->Exponent;
			ps->Coefficient = p2->Coefficient;
			p2 = p2->Next;
			ps = ps->Next;
		}
		else //相等的情况
		{
			ps->Coefficient = p1->Coefficient + p2->Coefficient;
			ps->Exponent = p1->Exponent;
			p1 = p1->Next;
			p2 = p2->Next;
			ps = ps->Next;

		}
	}
}

//根据指数寻找
Position FindExponent(int exp, List L)
{
	Position P;

	P = L;//如果定义了首节点：P = L->Next;
	while (P != NULL && P->Exponent != exp)
		P = P->Next;
	return P;
}


//多项式相乘
void MultPolynomial(const Polynomial Poly1, const Polynomial Poly2, Polynomial* PolyProd)
{
	int  len1 = GetListLen(Poly1);
	//int N = sizeof(A) / sizeof(double);
	int  len2 = GetListLen(Poly2);
	Polynomial p1, p2, ps;//需要重新定义一个节点来滑动
	p1 = Poly1;
	p2 = Poly2;
	int N = len1 + len2 - 1;
	InitListTail(PolyProd, N);

	ps = *PolyProd;
	while (ps->Next!=NULL)
	{
		ps->Exponent = --N;
		ps = ps->Next;
	}
	
	//搞得像是for循环了！！
	ps = *PolyProd;
	while (p1->Next != NULL )
	{
		p2 = Poly2;
		while(p2->Next != NULL)
		{ 
		int tmp = p1->Exponent + p2->Exponent;
		ps = FindExponent(tmp, *PolyProd);
		ps->Coefficient += p1->Coefficient*p2->Coefficient;
		p2 = p2->Next;
		}
		p1 = p1->Next;
	}

}


void DisplayPolynomial(Polynomial polynomial)
{
	while (polynomial->Next != NULL)
	{
		cout << polynomial->Coefficient << "*X^" << polynomial->Exponent << " + ";
		polynomial = polynomial->Next;
	}
}

int MaxElementOfArray(const int X[])
{
	int max = 0;
	for (int i = 0;i<sizeof(X)/sizeof(int);i++)
	{
		if (X[i] > max)  max = X[i];
	}
	//cout << "max element of array: " << max << endl;
	return max;
}


void ListPolynomialTest()
{
	
	Polynomial poly1;
	double A1[] = { 1,2,3,4 };
	//int B1[] = { 6,5,4,3,2,1 };
	//int N1 = MaxElementOfArray(B1) +1 ;//得按照指数最大值进行初始化，同时还有常数项
	int N1 = sizeof(A1) / sizeof(double);
	double A2[] = { 4,5,6 };
	int N2 = sizeof(A2) / sizeof(double);

	InitListTail(&poly1, N1);
	//DisplayPolynomial(poly1);
	InitPolynomial(A1, poly1, N1);
	DisplayPolynomial(poly1);
	cout << endl;
	Polynomial poly2;
	InitListTail(&poly2, N2);
	//DisplayPolynomial(poly1);
	InitPolynomial(A2, poly2, N2);
	DisplayPolynomial(poly2);
	cout << endl;


	//加法
	Polynomial polySum;
	//AddPolynomial(poly1, poly2, &polySum);
	//DisplayPolynomial(polySum);


	//乘法
	Polynomial polyProd;
	MultPolynomial(poly1, poly2, &polyProd);
	DisplayPolynomial(polyProd);
}


int main(int argc, char** argv)
{
	//StructPolynomialTest();
	ListPolynomialTest();
	//RadioSortTest();
	//StudentCourseTest();
	system("pause");
	return 0;
}