Chapter 3 List-Stack-and-Queue(2)

多项式运算（数组）

#include <stdio.h>
#include <stdlib.h>
#define MaxDegree 20
typedef struct PolyNode
{
	int CoeffArray[MaxDegree + 1];
	int HighPower;
}*Polynomial;

void ZeroPolynomial(Polynomial Poly)
{
	for (int i = 0; i <= MaxDegree; i++)
		Poly->CoeffArray[i] = 0;
	Poly->HighPower = 0;
}

void AddPolynomial(Polynomial Poly1, Polynomial Poly2, Polynomial PolySum)
{
	ZeroPolynomial(PolySum);
	(Poly1->HighPower > Poly2->HighPower) ? PolySum->HighPower = Poly1->HighPower : PolySum->HighPower = Poly2->HighPower;
	for (int i = PolySum->HighPower; i >= 0; i--)
		PolySum->CoeffArray[i] = Poly1->CoeffArray[i] + Poly2->CoeffArray[i];
}

int MultPolynomial(Polynomial Poly1, Polynomial Poly2, Polynomial PolyProd)
{
	int i, j;
	ZeroPolynomial(PolyProd);
	PolyProd->HighPower = Poly1->HighPower + Poly2->HighPower;
	if (PolyProd->HighPower > MaxDegree)
		return -1;
	for (i = 0; i <= Poly1->HighPower; i++)
		for (j = 0; j <= Poly2->HighPower; j++)
			PolyProd->CoeffArray[i + j] += Poly1->CoeffArray[i] * Poly2->CoeffArray[j];
}

int main()
{
	Polynomial Poly1, Poly2, PolySum, PolyProd;
	Poly1 = (PolyNode*)malloc(sizeof(PolyNode)); //!!!
	Poly2 = (PolyNode*)malloc(sizeof(PolyNode));
	PolySum = (PolyNode*)malloc(sizeof(PolyNode));
	PolyProd = (PolyNode*)malloc(sizeof(PolyNode));
	ZeroPolynomial(Poly1);
	ZeroPolynomial(Poly2);
	int i;
	for (i = 0; i < 8; i++)
	{
		Poly1->CoeffArray[i] = i;
		Poly2->CoeffArray[i] = 8 - i;
	}
	Poly1->HighPower = Poly2->HighPower = 8;
	AddPolynomial(Poly1, Poly2, PolySum);
	MultPolynomial(Poly1, Poly2, PolyProd);

	return 0;
}

多项式运算（链表）

#include <stdio.h>
#include <stdlib.h>

typedef struct PolyNode
{
	int Coefficient;
	int Exponent;
	struct PolyNode *Next;
}*Polynomial, *Position;

void Add(Polynomial Poly, int Coefficient,int Exponent)
{
	Position P1 = (PolyNode*)malloc(sizeof(PolyNode));
	P1->Coefficient = Coefficient;
	P1->Exponent = Exponent;
	P1->Next = NULL;
	Position P2 = Poly;
	while (P2->Next)
		P2 = P2->Next;
	P2->Next = P1;
}

int Delete(Polynomial Poly,Position P1)
{
	Position P2 = Poly->Next;
	while (P2)
	{
		if (P2 == P1) //!!!
		{
			Poly->Next = P1->Next;
			free(P1);
			return 0;
		}
		else if (P2->Next == P1)
		{
			P2->Next = P1->Next;
			free(P1);
			return 0;
		}
		P2 = P2->Next;
	}
	return -1;
}
void PrintAll(Polynomial Poly)
{
	Position P;
	for (P = Poly->Next; P; P = P->Next)
		printf("%d#%d  ", P->Coefficient,P->Exponent);
	printf("\n");
}

void AddPolinomial(Polynomial Poly1, Polynomial Poly2, Polynomial PolySum)
{
	Position P1, P2;
	P1 = Poly1->Next;
	P2 = Poly2->Next;
	while (P1 && P2)
	{
		if (P1->Exponent == P2->Exponent)
		{
			Add(PolySum, P1->Coefficient + P2->Coefficient, P1->Exponent);
			P1 = P1->Next;
			P2 = P2->Next;
		}
		else if (P1->Exponent > P2->Exponent)
		{
			Add(PolySum, P1->Coefficient, P1->Exponent);
			P1 = P1->Next;
		}
		else if (P1->Exponent < P2->Exponent)
		{
			Add(PolySum, P2->Coefficient, P2->Exponent);
			P2 = P2->Next;
		}
	}
	while (P1)
	{
		Add(PolySum, P1->Coefficient, P1->Exponent);
		P1 = P1->Next;
	}
	while (P2)
	{
		Add(PolySum, P2->Coefficient, P2->Exponent);
		P2 = P2->Next;
	}
}

int Find(Polynomial Poly, int Coefficient, int Exponent)
{
	Position P;
	for (P = Poly->Next; P; P = P->Next)
	{
		if (P->Exponent == Exponent)
		{
			P->Coefficient += Coefficient;
			return 0;
		}

	}
	return -1;
}

void MuiltPolynomial(Polynomial Poly1, Polynomial Poly2, Polynomial PolyProd)
{
	Position P1, P2, P3;
	if (Poly1->Next->Exponent > Poly2->Next->Exponent)
	{
		P1 = Poly1->Next;
		P3 = Poly2->Next;
	}
	else
	{
		P1 = Poly2->Next;
		P3 = Poly1->Next;
	}
	for (; P1; P1 = P1->Next)
		for (P2 = P3; P2; P2 = P2->Next)
			if(Find(PolyProd,P1->Coefficient * P2->Coefficient,P1->Exponent + P2->Exponent) != 0)
			   Add(PolyProd, P1->Coefficient * P2->Coefficient, P1->Exponent + P2->Exponent);
}

int main()
{
	int n, m;
	Polynomial Poly1, Poly2, PolySum, PolyProd;
	Poly1 = (PolyNode*)malloc(sizeof(PolyNode)); Poly1->Next = NULL; //!!!
	Poly2 = (PolyNode*)malloc(sizeof(PolyNode)); Poly2->Next = NULL;
	PolySum = (PolyNode*)malloc(sizeof(PolyNode)); PolySum->Next = NULL;
	PolyProd = (PolyNode*)malloc(sizeof(PolyNode)); PolyProd->Next = NULL;
	do {
		scanf("%d %d", &n, &m);
		if (n != 0)
		   Add(Poly1, n, m);
	} while (n != 0);
	do {
		scanf("%d %d", &n, &m);
		if (n != 0)
		  Add(Poly2, n, m);
	} while (n != 0);
	AddPolinomial(Poly1, Poly2, PolySum);
	MuiltPolynomial(Poly1, Poly2, PolyProd);
	PrintAll(PolySum);
	PrintAll(PolyProd);
}

/*
1 4
2 3
3 2
4 1
5 0
0 0
5 5
4 3
3 1
7 0
0 0

*/

栈（链表实现）

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct Node
{
   ElementType Element;
   struct Node *Next;
}*Stack;

Stack InitStack()
{
   Stack S = (Node*)malloc(sizeof(Node));
   S->Next = NULL;
   return S;
}

void Push(Stack S,ElementType X)
{
     Node *Tmp = (Node*)malloc(sizeof(Node));
     Tmp->Element = X;
     Tmp->Next = S->Next;
     S->Next = Tmp;
}

int Pop(Stack S)
{
   if(S->Next == NULL)
       return -1;
   Node *Tmp = S->Next;
   S->Next = Tmp->Next;
   free(Tmp);
   return 0;
}

int main()
{
   Stack S = InitStack();
   Push(S,1);
   Pop(S);
}

栈（数组实现）

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct StackRecord
{
	int Top;
	int Capacity;
	ElementType *Array;
}*Stack;

Stack CreatStack(int MaxSize)
{
	Stack S = (StackRecord*)malloc(sizeof(StackRecord));
	S->Capacity = MaxSize;
	S->Array = (ElementType*)malloc(sizeof(ElementType) * S->Capacity);
	return S;
}

void InitStack(Stack S)
{
	S->Top = 0;//!!!
}

int Push(Stack S,ElementType X)
{
	if (S->Top == S->Capacity)
		return -1;
	S->Array[++S->Top] = X; //!!!
	return 0;
}

ElementType Pop(Stack S)
{
	if (S->Top == 0)
		return -1;
	return S->Array[S->Top--]; //!!!
}

ElementType Peek(Stack S)
{
	if (S->Top == 0)
		return -1;
	return S->Array[S->Top]; //!!!
}

int main()
{
	Stack S = CreatStack(4);
	InitStack(S);//!!!
	printf("%d ", Push(S, 1));
	printf("%d ", Push(S, 2));
	printf("%d ", Push(S, 3));
	printf("%d ", Push(S, 4));
	printf("%d ", Push(S, 5));
	printf("%d ", Peek(S));
	printf("%d ", Pop(S));
	printf("%d ", Pop(S));
	printf("%d ", Pop(S));
	printf("%d ", Pop(S));
	printf("%d ", Pop(S));

	return 0;
}

队列（循环队列）

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct QueueRecord
{
	int Front;
	int Rear;
	int Capacity;
	ElementType *Array;
}*Queue;

void InitQueue(Queue Q)
{
	Q->Front = 0;
	Q->Rear = 0;
}

Queue CreatQueue(int MaxSize)
{
	Queue Q = (QueueRecord*)malloc(sizeof(QueueRecord));
	Q->Capacity = MaxSize;
	Q->Array = (ElementType*)malloc(sizeof(ElementType) * MaxSize);
	InitQueue(Q);
	return Q;
}

int Enqueue(Queue Q, ElementType X)
{
	if((Q->Rear + 1) % Q->Capacity == Q->Front)
		return -1;
	Q->Rear = (Q->Rear + 1) % Q->Capacity;
	Q->Array[Q->Rear] = X;
	return 0;
}

ElementType Dequeue(Queue Q)
{
	if (Q->Front == Q->Rear)
		return -1;
	Q->Front = (Q->Front + 1) % Q->Capacity;
	return Q->Array[Q->Front];
}

int main()
{
	Queue Q = CreatQueue(4);
	printf("%d ", Enqueue(Q, 1));
	printf("%d ", Enqueue(Q, 2));
	printf("%d ", Enqueue(Q, 3));
	printf("%d ", Enqueue(Q, 4));
	printf("%d ", Dequeue(Q));
	printf("%d ", Dequeue(Q));
	printf("%d ", Dequeue(Q));
	printf("%d ", Dequeue(Q));
}