C实现的一元多项式运算[2]--链表运算

上一次《C实现的一元多项式运算》完成了一元多项式的基本操作，接上一次的工作，本次完成了乘法的运算和将多项式运算的过程输出到HTML文件的功能。另外定义了PRINTF_ARGL和FPRINTF_ARGL宏，用来同时向屏幕和文件输出。

因为多项式的表示是通过单向链表来完成的，多项式的运算也是通过链表的操作来完成的（结点动态申请），所以内存的分配和释放尤为重要。为检测分配和释放状况，代码统一使用宏Create_ENTITY和FREEIF来分配和释放，在宏中输出分配释放情况。

DEBUG_MEMORY宏值如果定义为0，则关闭输出链表结点输出的情况，定义为非0值（如1）则输出当前是在分配结点还是在释放结点，并输出分配或释放结点后剩余的结点数。所以当程序运行结束后，结点数为0则表示为链表分配的内存已经全部释放。

代码中的函数基础的放在前面，提供后面的函数使用，而没用使用函数原型声明，这样可以少贴几行到网页（实际编程时最好不要如此，以来很难控制函数的调用关系，二来如果将函数申明放在一起，用户可以很容易看到该源文件提供哪些函数，主要完成什么功能等）。

main函数被用来创建log文件，用户请在UserMain函数中编写代码。

头文件和源文件本应分开，为方便贴出，暂将其放在一块。

还少一个将字符串如“5y^3 + 3y^2 - 4y -1”parse成一个链表的函数，以后补上。等该功能完成后，可再增加命令行功能，如：“polynomial 5y^3+3y^2-4y-1 * 3y^4-4y-2”。

下载：
源文件
生成的log文件
生成的HTML文件（运算过程）

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <assert.h>
4.  
5. //You can set DEBUG_MEMORY to either 0 if do not wanna test whether there is
6. //momery leak or 1(just other than 0) to check.
7. #define DEBUG_MEMORY 1
8. #define WRITE_SCREEN_TO_FILE 1
9. //Write strings(written by PRINTF_ARGL) to the file besides the screen.
10. //this is only used when WRITE_SCREEN_TO_FILE != 0
11. #define SCREEN_LOG_FILE "D:\\PolyLog.txt"
12.  
13. #if defined NULL
14.     #undef NULL
15. #endif
16. #define NULL 0
17.  
18. #define CHECK_NONNULL_POINT(p) assert(NULL != p)
19. #define CHECK_SAME_VALUE(a,b) assert((a) == (b))
20.  
21. #define _ARGL(r) r##,
22. #define _ARGLEND(r) r
23.  
24. //when use PRINTF_ARGL() or FPRINTF_ARGL(), please do not forget to add {}
25. //even if there is only one statement in it, especially when it is after "if".
26. #if WRITE_SCREEN_TO_FILE
27.     FILE* gpLogFile = NULL;
28.     #define PRINTF_ARGL(s) printf(s); \
29.             if (NULL != gpLogFile) \
30.                 fprintf(gpLogFile, s)
31.     #define FPRINTF_ARGL(fp, s) printf(s); \
32.             if (NULL != gpLogFile) \
33.                 fprintf(gpLogFile, s); \
34.             fprintf(fp, s)
35. #else
36.     #define PRINTF_ARGL(s) printf(s)
37.     #define FPRINTF_ARGL(fp, s) printf(s); \
38.             fprintf(fp, s)  
39. #endif
40.  
41. //We can only create one Create_ENTITY in one area,
42. //declaration of variables must be ahead of it.
43. #if DEBUG_MEMORY
44.     int gMemNodeNum = 0;
45.     #define Create_ENTITY(type, name) \
46.             type* name = (type*) malloc(sizeof(type)); \
47.             assert(NULL != name); \
48.             gMemNodeNum++; \
49.             /* PRINTF("\n[Create_ENTITY: %d, 0x%p] ", ++gMemNodeNum, name)*/ \
50.             PRINTF_ARGL(_ARGL("\n[Create_ENTITY: %d, 0x%p] ") \
51.                         _ARGL(gMemNodeNum)_ARGLEND(name))
52.  
53.     #define FREEIF(p) \
54.             if (NULL != p)  \
55.             {               \
56.                 gMemNodeNum--; \
57.                 /* PRINTF("\n[FREE: %d, 0x%p] ", --gMemNodeNum, p); */ \
58.                 PRINTF_ARGL(_ARGL("\n[FREE: %d, 0x%p] ") \
59.                         _ARGL(gMemNodeNum)_ARGLEND(p)); \
60.                 free(p);   \
61.             }   \
62.             p = NULL
63. #else
64.     #define Create_ENTITY(type, name) \
65.             type* name = (type*) malloc(sizeof(type)); \
66.             assert(NULL != name)                    
67.  
68.     #define FREEIF(p) \
69.             if (NULL != p)  \
70.             {               \
71.                 free(p);   \
72.             }   \
73.             p = NULL    
74. #endif
75.  
76.  
77.  
78. typedef unsigned int uint;
79. typedef char BOOL;
80. #define FALSE 0
81. #define TRUE 1
82.  
83. typedef int QType; //use int to simplize
84. typedef int IType;
85.  
86. //多项式中的项
87. typedef struct _ItemNode ItemNode;
88. struct _ItemNode
89. {
90.     ItemNode*   pNext;     //指向下一项
91.     QType       quotiety;  //系数
92.     IType       index;     //指数
93. };
94.  
95. typedef struct _Polynomial
96. {
97.     ItemNode*   pHeader;   //多项式中的第一项
98.     ItemNode*   pLast;     //多项式中的最后一项
99.     char        pronumeral; //未知数名，如x,y,z
100.     uint        ItemNum;   //项数
101. } Polynomial;
102.  
103. //Create one empty polymonial
104. Polynomial* CreateEmptyPolynomial(char name)
105. {
106.     Create_ENTITY(Polynomial, pPoly);
107.     pPoly->pHeader = pPoly->pLast = NULL;
108.     pPoly->pronumeral = name;
109.     pPoly->ItemNum = 0;
110.     return pPoly;
111. }
112.  
113. //Create one polynomial with one item
114. Polynomial* CreatePolynomial(char name, ItemNode* head)
115. {
116.     Polynomial* pPoly = CreateEmptyPolynomial(name);
117.     pPoly->pHeader = pPoly->pLast = head;
118.     pPoly->ItemNum = 1;
119.     return pPoly;
120. }
121.  
122. //Create one Item Node
123. ItemNode* CreateItemNode(QType quotiety, IType index)//系数，指数
124. {
125.     Create_ENTITY(ItemNode, pItem);
126.     pItem->quotiety = quotiety;
127.     pItem->index = index;
128.     pItem->pNext = NULL;
129.     return pItem;
130. }
131.  
132. //Duplicate an ItemNode
133. ItemNode* DuplicateItemNode(ItemNode* pItem)
134. {
135.     Create_ENTITY(ItemNode, pNewItem);
136.     pNewItem->index = pItem->index;
137.     pNewItem->quotiety = pItem->quotiety;
138.     pNewItem->pNext = pItem->pNext;
139.     return pNewItem;
140. }
141.  
142. void FreeItemNode(ItemNode* pItem)
143. {
144.     FREEIF(pItem);
145. }
146.  
147.  
148. void FreePolynomial(Polynomial* pPoly)
149. {
150.     ItemNode *temNode;
151.     CHECK_NONNULL_POINT(pPoly);
152.  
153.     temNode = pPoly->pHeader;
154.     while (NULL != temNode)
155.     {
156.         //we cannot simply use temNode = temNode->pNext after call FreeItemNode
157.         //because the struct has been freed and we would not get proper value
158.         //of temNode->pNext, although temNode isn't NULL
159.         pPoly->pHeader = temNode->pNext;
160.         FreeItemNode(temNode);
161.         temNode = pPoly->pHeader;
162.     }
163.     FREEIF(pPoly);
164. }
165.  
166. //Add one Item to polynomial,and return the ItemNode Num.
167. int AddItemToPolynomial(Polynomial* pPoly, ItemNode* pItem)
168. {
169.     CHECK_NONNULL_POINT(pPoly);
170.     CHECK_NONNULL_POINT(pItem);
171.     if (NULL != pPoly->pLast) //this means pPoly->pHeader != NULL
172.     {
173.         if (NULL == pPoly->pHeader->pNext) //when there is only one item
174.             pPoly->pHeader->pNext = pPoly->pLast;
175.         pPoly->pLast->pNext = pItem;
176.     }
177.     else //the first item node
178.     {
179.         pPoly->pHeader = pItem;
180.     }
181.     pPoly->pLast = pItem;
182.     pPoly->pLast->pNext = NULL;
183.     return ++pPoly->ItemNum;
184. }
185.  
186. //add one item to a formatted polynomial, and return the itemnode num.
187. //please ensure that pPoly is formatted, namely its index is in Desc order.
188. //pItem must be new built(is not a member of another polynomial)
189. int AddItemToFormattedPolynomial(Polynomial* pPoly, ItemNode* pItem)
190. {
191.     CHECK_NONNULL_POINT(pPoly);
192.     CHECK_NONNULL_POINT(pItem);
193.     if (NULL == pPoly->pHeader)
194.     {
195.         pPoly->pHeader = pPoly->pLast = pItem;
196.     }
197.     else
198.     {
199.         ItemNode* pTemItem = pPoly->pHeader;
200.         ItemNode* pLastValidItem = pTemItem; //this cannot be NULL
201.         while (NULL != pTemItem && pTemItem->index > pItem->index)
202.         {
203.             pLastValidItem = pTemItem;
204.             pTemItem = pTemItem->pNext;
205.         }
206.         if (NULL == pTemItem) //insert it to the end
207.         {
208.             pLastValidItem->pNext = pItem;
209.             pPoly->pLast = pItem;
210.         }
211.         else if (pTemItem->index == pItem->index) //no insert it
212.         {
213.             pTemItem->quotiety += pItem->quotiety;
214.             //remember to free pItem, for we have not added it to the pPoly
215.             FreeItemNode(pItem);
216.         }
217.         else //insert it normally
218.         {
219.             pLastValidItem->pNext = pItem;
220.             pItem->pNext = pTemItem;
221.         }
222.     }
223.  
224.     pPoly->pLast->pNext = NULL;
225.     return ++pPoly->ItemNum;
226. }
227.  
228. //Create a Formatted Polynomial from a non-formatted polynomial by index DESC
229. Polynomial* CreateFormattedPolynomial(Polynomial* pPoly)
230. {
231.     Polynomial* pFmtPoly;
232.     ItemNode* pTemNode;
233.     CHECK_NONNULL_POINT(pPoly);
234.     pFmtPoly = CreateEmptyPolynomial(pPoly->pronumeral);
235.     pTemNode = pPoly->pHeader;
236.     while (NULL != pTemNode)
237.     {
238.         AddItemToFormattedPolynomial(pFmtPoly, 
239.                 DuplicateItemNode(pTemNode));
240.         pTemNode = pTemNode->pNext;
241.     }
242.     return pFmtPoly;
243. }
244.  
245. //Create a Formatted Polynomial and delete the old one
246. Polynomial* CreateFormattedAndDelOldPolynomial(Polynomial* pPoly)
247. {
248.     Polynomial* pFmtPoly;
249.     ItemNode* pTemNode;
250.     ItemNode* pCurNode;
251.     CHECK_NONNULL_POINT(pPoly);
252.     pFmtPoly = CreateEmptyPolynomial(pPoly->pronumeral);
253.     pTemNode = pPoly->pHeader;
254.     while (NULL != pTemNode)
255.     {
256.         //it is the defference between this function and
257.         //CreateFormattedPolynomial concerning the freedom of pTemNode.
258.         pCurNode = pTemNode->pNext;
259.         AddItemToFormattedPolynomial(pFmtPoly, pTemNode);
260.         pTemNode = pCurNode;
261.     }
262.     FREEIF(pPoly);
263.     return pFmtPoly;
264. }
265.  
266. //Create a new ItemNode with quotiety and index first,
267. //and then insert the node to pPoly at the tail(non-formatted).
268. int AddItemToPolynomialEx(Polynomial* pPoly, QType quotiety, IType index)
269. {
270.     return AddItemToPolynomial(pPoly, CreateItemNode(quotiety, index));
271. }
272.  
273. /***************************** + - * operations ******************************/
274. //pLeftPoly and pRightPoly can be either formatted or non-formatted in these
275. //three functions, but the new created polynomial(return value) is formatted.
277. //+: pLeftPoly + pRightPoly
278. Polynomial* PolynomialAdd(Polynomial* pLeftPoly, Polynomial* pRightPoly)
279. {
280.     Polynomial* pOutPoly;
281.     CHECK_NONNULL_POINT(pLeftPoly);
282.     CHECK_NONNULL_POINT(pRightPoly);
283.     CHECK_SAME_VALUE(pLeftPoly->pronumeral, pRightPoly->pronumeral);
284.     //pOutPoly = CreateEmptyPolynomial(pLeftPoly->pronumeral);
285.     //just link two polynomials to simplize the actions.
286.     pLeftPoly->pLast->pNext = pRightPoly->pHeader;
287.     //calculating pLeftPoly->ItemNum is not needed,
288.     //just for further consideration
289.     pLeftPoly->ItemNum += pRightPoly->ItemNum;
290.     pOutPoly = CreateFormattedPolynomial(pLeftPoly);
291.     //set back
292.     pLeftPoly->ItemNum -= pRightPoly->ItemNum;
293.     pLeftPoly->pLast->pNext = NULL;
294.     return pOutPoly;
295. }
296.  
297. //-: pLeftPoly - pRightPoly
298. Polynomial* PolynomialSubtract(Polynomial* pLeftPoly, Polynomial* pRightPoly)
299. {
300.     Polynomial* pOutPoly;
301.     ItemNode* pTemNode;
302.     ItemNode* pNewNode;
303.     CHECK_NONNULL_POINT(pLeftPoly);
304.     CHECK_NONNULL_POINT(pRightPoly);
305.     CHECK_SAME_VALUE(pLeftPoly->pronumeral, pRightPoly->pronumeral);
306.     pOutPoly = CreateFormattedPolynomial(pLeftPoly);
307.     pTemNode = pRightPoly->pHeader;
308.     while (NULL != pTemNode)
309.     {
310.         pNewNode = DuplicateItemNode(pTemNode);
311.         pNewNode->quotiety = -pNewNode->quotiety;
312.         AddItemToFormattedPolynomial(pOutPoly, pNewNode);
313.         pTemNode = pTemNode->pNext;
314.     }
315.     return pOutPoly;
316. }
317.  
318. //*: pLeftPoly * pRightPoly
319. Polynomial* PolynomialMultiply(Polynomial* pLeftPoly, Polynomial* pRightPoly)
320. {
321.     Polynomial* pOutPoly;
322.     ItemNode *pCurLeft;
323.     ItemNode *pCurRight;
324.     ItemNode *pOutItem;
325.     CHECK_NONNULL_POINT(pLeftPoly);
326.     CHECK_NONNULL_POINT(pRightPoly);
327.     CHECK_SAME_VALUE(pLeftPoly->pronumeral, pRightPoly->pronumeral);
328.     
329.     pCurLeft = pLeftPoly->pHeader;
330.     pOutPoly = CreateEmptyPolynomial(pLeftPoly->pronumeral);
331.     while (pCurLeft)
332.     {
333.         pCurRight = pRightPoly->pHeader;
334.         while (pCurRight)
335.         {
336.             pOutItem = CreateItemNode(
337.                 pCurLeft->quotiety * pCurRight->quotiety,
338.                 pCurLeft->index + pCurRight->index);
339.             AddItemToFormattedPolynomial(pOutPoly, pOutItem);
340.             pCurRight = pCurRight->pNext;
341.         }
342.         pCurLeft = pCurLeft->pNext;
343.     }
344.     return pOutPoly;
345. }
346.  
347. /********************Write Processes to HTML File in Detail*******************/
348. BOOL HTMLItemNode(FILE* pHTMLFile, ItemNode* pItem, char cPronum, BOOL bHead)
349. {
350.     CHECK_NONNULL_POINT(pItem);
351.     CHECK_NONNULL_POINT(pHTMLFile);
352.     if (0 == pItem->quotiety)
353.         return FALSE;
354.     if (bHead)
355.     {
356.         if (1 == pItem->quotiety)
357.         {
358.         }
359.         else if (-1 == pItem->quotiety)
360.         {
361.             FPRINTF_ARGL(pHTMLFile, "-");
362.         }
363.         else
364.         {
365.             FPRINTF_ARGL(pHTMLFile, _ARGL("%d")_ARGLEND(pItem->quotiety));
366.         }
367.     }
368.     else
369.     {
370.         if (1 == pItem->quotiety)
371.         {
372.             FPRINTF_ARGL(pHTMLFile, " + ");
373.         }
374.         else if (-1 == pItem->quotiety)
375.         {
376.             FPRINTF_ARGL(pHTMLFile, " - ");
377.         }
378.         else
379.         {
380.             QType quot = pItem->quotiety;
381.             char op = '+';
382.             if (quot < 0)
383.             {
384.                 quot = - quot;
385.                 op = '-';
386.             }
387.             FPRINTF_ARGL(pHTMLFile, _ARGL(" %c %d")_ARGL(op)_ARGLEND(quot));
388.         }
389.     }
390.     if (0 != pItem->index)
391.     {
392.         FPRINTF_ARGL(pHTMLFile, _ARGL("%c")_ARGLEND(cPronum));
393.         if (1 != pItem->index)
394.         {
395.             FPRINTF_ARGL(pHTMLFile,
396.                     _ARGL("^%d")_ARGLEND(pItem->index));
397.         }
398.     }
399.     return TRUE;
400. }
401.  
402. BOOL HTMLPolynomial(FILE* pHTMLFile, Polynomial* pPoly)
403. {
404.     ItemNode* pItem;
405.     BOOL bEmpty = TRUE;
406.     CHECK_NONNULL_POINT(pPoly);
407.     pItem = pPoly->pHeader;
408.     
409.     //print first item node
410.     while (NULL != pItem)
411.     {
412.         if (HTMLItemNode(pHTMLFile, pItem, pPoly->pronumeral, TRUE))
413.         {
414.             bEmpty = FALSE;
415.             pItem = pItem->pNext;
416.             break;
417.         }
418.         pItem = pItem->pNext;
419.     }
420.     //print other item node
421.     while (NULL != pItem)
422.     {
423.         HTMLItemNode(pHTMLFile, pItem, pPoly->pronumeral, FALSE);
424.         pItem = pItem->pNext;
425.     }
426.     
427.     //pPoly is empty
428.     if (bEmpty)
429.     {
430.         FPRINTF_ARGL(pHTMLFile, "0");
431.         return FALSE;
432.     }
433.     return TRUE;
434. }
435.  
436. Polynomial* HTMLPolynomialAdd(FILE* pHTMLFile,
437.             Polynomial* pLeftPoly, Polynomial* pRightPoly)
438. {
439.     Polynomial* pTemPoly;
440.     ItemNode* pTemNode;
441.     CHECK_NONNULL_POINT(pHTMLFile);
442.     CHECK_NONNULL_POINT(pLeftPoly);
443.     CHECK_NONNULL_POINT(pRightPoly);
444.     CHECK_SAME_VALUE(pLeftPoly->pronumeral, pRightPoly->pronumeral);
445.     // (a + b) + (c + d)
446.     FPRINTF_ARGL(pHTMLFile, "\n<hr><b>&nbsp;&nbsp;(");
447.     HTMLPolynomial(pHTMLFile, pLeftPoly);
448.     FPRINTF_ARGL(pHTMLFile, ") + (");
449.     HTMLPolynomial(pHTMLFile, pRightPoly);
450.     FPRINTF_ARGL(pHTMLFile, ")</b>");
451.     //=ac + ad + bc +bd(formatted)
452.     pTemPoly = CreateEmptyPolynomial(pLeftPoly->pronumeral);
453.     pTemNode = pLeftPoly->pHeader;
454.     while (NULL != pTemNode)
455.     {
456.         AddItemToFormattedPolynomial(pTemPoly, DuplicateItemNode(pTemNode));
457.         pTemNode = pTemNode->pNext;
458.     }
459.     pTemNode = pRightPoly->pHeader;
460.     while (NULL != pTemNode)
461.     {
462.         AddItemToFormattedPolynomial(pTemPoly, DuplicateItemNode(pTemNode));
463.         pTemNode = pTemNode->pNext;
464.     }
465.     FPRINTF_ARGL(pHTMLFile, "<br>\n<b>=</b>&nbsp;");
466.     HTMLPolynomial(pHTMLFile, pTemPoly);
467.     return pTemPoly;
468. }
469.  
470. Polynomial* HTMLPolynomialSubtract(FILE* pHTMLFile,
471.                               Polynomial* pLeftPoly, Polynomial* pRightPoly)
472. {
473.     Polynomial* pTemPoly;
474.     ItemNode* pTemNode;
475.     CHECK_NONNULL_POINT(pHTMLFile);
476.     CHECK_NONNULL_POINT(pLeftPoly);
477.     CHECK_NONNULL_POINT(pRightPoly);
478.     CHECK_SAME_VALUE(pLeftPoly->pronumeral, pRightPoly->pronumeral);
479.     // (a + b) - (c + d)
480.     FPRINTF_ARGL(pHTMLFile, "\n<hr><b>&nbsp;&nbsp;(");
481.     HTMLPolynomial(pHTMLFile, pLeftPoly);
482.     FPRINTF_ARGL(pHTMLFile, ") - (");
483.     HTMLPolynomial(pHTMLFile, pRightPoly);
484.     FPRINTF_ARGL(pHTMLFile, ")</b>");
485.     //=ac + ad - bc - bd
486.     FPRINTF_ARGL(pHTMLFile, "<br>\n<b>=</b>&nbsp;");
487.     pTemPoly = CreateEmptyPolynomial(pLeftPoly->pronumeral);
488.     pTemNode = pLeftPoly->pHeader;
489.     while (NULL != pTemNode)
490.     {
491.         AddItemToPolynomial(pTemPoly, DuplicateItemNode(pTemNode));
492.         pTemNode = pTemNode->pNext;
493.     }
494.     pTemNode = pRightPoly->pHeader;
495.     while (NULL != pTemNode)
496.     {
497.         ItemNode* pDupItem = DuplicateItemNode(pTemNode);
498.         pDupItem->quotiety = -pDupItem->quotiety;
499.         AddItemToPolynomial(pTemPoly, pDupItem);
500.         pTemNode = pTemNode->pNext;
501.     }
502.     HTMLPolynomial(pHTMLFile, pTemPoly);
503.     //format, pTemPoly(out) != pTemPoly(in)
504.     pTemPoly = CreateFormattedAndDelOldPolynomial(pTemPoly);
505.     FPRINTF_ARGL(pHTMLFile, "<br>\n<b>=</b>&nbsp;");
506.     HTMLPolynomial(pHTMLFile, pTemPoly);
507.     return pTemPoly;
508. }
509.  
510. Polynomial* HTMLPolynomialMultiply(FILE* pHTMLFile,
511.                             Polynomial* pLeftPoly, Polynomial* pRightPoly)
512. {
513.     Polynomial* pOutPoly;
514.     ItemNode *pCurLeft;
515.     ItemNode *pCurRight;
516.     ItemNode *pOutItem;
517.     CHECK_NONNULL_POINT(pHTMLFile);
518.     CHECK_NONNULL_POINT(pLeftPoly);
519.     CHECK_NONNULL_POINT(pRightPoly);
520.     CHECK_SAME_VALUE(pLeftPoly->pronumeral, pRightPoly->pronumeral);
521.     
522.     // (a + b) * (c + d)
523.     FPRINTF_ARGL(pHTMLFile, "\n<hr><b>&nbsp;&nbsp;(");
524.     HTMLPolynomial(pHTMLFile, pLeftPoly);
525.     FPRINTF_ARGL(pHTMLFile, ") * (");
526.     HTMLPolynomial(pHTMLFile, pRightPoly);
527.     FPRINTF_ARGL(pHTMLFile, ")</b>");
528.  
529.     //= ac + ad + bc + bd
530.     pCurLeft = pLeftPoly->pHeader;
531.     pOutPoly = CreateEmptyPolynomial(pLeftPoly->pronumeral);
532.     while (pCurLeft)
533.     {
534.         pCurRight = pRightPoly->pHeader;
535.         while (pCurRight)
536.         {
537.             pOutItem = CreateItemNode(
538.                 pCurLeft->quotiety * pCurRight->quotiety,
539.                 pCurLeft->index + pCurRight->index);
540.             AddItemToPolynomial(pOutPoly, pOutItem);
541.             pCurRight = pCurRight->pNext;
542.         }
543.         pCurLeft = pCurLeft->pNext;
544.     }
545.     FPRINTF_ARGL(pHTMLFile, "<br>\n<b>=</b>&nbsp;");
546.     HTMLPolynomial(pHTMLFile, pOutPoly);
547.     //format
548.     pOutPoly = CreateFormattedAndDelOldPolynomial(pOutPoly);
549.     FPRINTF_ARGL(pHTMLFile, "<br>\n<b>=</b>&nbsp;");
550.     HTMLPolynomial(pHTMLFile, pOutPoly);
551.     return pOutPoly;
552. }
553.  
554. /*****************************************************************************/
555. //print pItem, this function should be changed if the type of
556. //pronumeral or index changs
557. BOOL PrintItemNode(ItemNode* pItem, char cPronum, BOOL bHead)
558. {
559.     CHECK_NONNULL_POINT(pItem);
560.     if (0 == pItem->quotiety)
561.         return FALSE;
562.     if (bHead)
563.     {
564.         if (1 == pItem->quotiety)
565.         {
566.         }
567.         else if (-1 == pItem->quotiety)
568.         {
569.             PRINTF_ARGL("-");
570.         }
571.         else
572.         {
573.             PRINTF_ARGL(_ARGL("%d")_ARGLEND(pItem->quotiety));
574.         }
575.     }
576.     else
577.     {
578.         if (1 == pItem->quotiety)
579.         {
580.             PRINTF_ARGL(" + ");
581.         }
582.         else if (-1 == pItem->quotiety)
583.         {
584.             PRINTF_ARGL(" - ");
585.         }
586.         else
587.         {
588.             QType quot = pItem->quotiety;
589.             char op = '+';
590.             if (quot < 0)
591.             {
592.                 quot = - quot;
593.                 op = '-';
594.             }
595.             PRINTF_ARGL(_ARGL(" %c %d")_ARGL(op)_ARGLEND(quot));
596.         }
597.     }
598.     if (0 != pItem->index)
599.     {
600.         PRINTF_ARGL(_ARGL("%c")_ARGLEND(cPronum));
601.         if (1 != pItem->index)
602.         {
603.             PRINTF_ARGL(_ARGL("^%d")_ARGLEND(pItem->index));
604.         }
605.     }
606.     return TRUE;
607. }
608.  
609. // print the Polynomial
610. BOOL PrintPolynomial(Polynomial* pPoly)
611. {
612.     ItemNode* pItem;
613.     BOOL bEmpty = TRUE;
614.     CHECK_NONNULL_POINT(pPoly);
615.     pItem = pPoly->pHeader;
616.  
617.     //print first item node
618.     while (NULL != pItem)
619.     {
620.         if (PrintItemNode(pItem, pPoly->pronumeral, TRUE))
621.         {
622.             bEmpty = FALSE;
623.             pItem = pItem->pNext;
624.             break;
625.         }
626.         pItem = pItem->pNext;
627.     }
628.     //print other item node
629.     while (NULL != pItem)
630.     {
631.         PrintItemNode(pItem, pPoly->pronumeral, FALSE);
632.         pItem = pItem->pNext;
633.     }
634.     
635.     //pPoly is empty
636.     if (bEmpty)
637.     {
638.         PRINTF_ARGL("Empty Polynomial!!!");
639.         return FALSE;
640.     }
641.     return TRUE;
642. }
643.  
644. //user function to code
645. int UserMain(int argc, char *argv[])
646. {
647.     Polynomial* pPoly = CreateEmptyPolynomial('x');
648.     Polynomial* pPoly1;
649.     Polynomial* pPoly2;
650.     FILE* pHTMLFile = fopen("D:\\test.html", "a+");
651.     CHECK_NONNULL_POINT(pHTMLFile);
652.     AddItemToPolynomialEx(pPoly, -1, 5);
653.     AddItemToPolynomialEx(pPoly, -3, 0);
654.     AddItemToPolynomialEx(pPoly, +5, 2);
655.     AddItemToPolynomialEx(pPoly, -33, -1);
656.     AddItemToPolynomialEx(pPoly, -31, 2);
657.     
658.     PRINTF_ARGL("\npPoly: \n");
659.     PrintPolynomial(pPoly);
660.     PRINTF_ARGL("\n");
661.     pPoly1 = CreateFormattedPolynomial(pPoly);
662.     PRINTF_ARGL("\nFormatted pPoly1: \n");
663.     PrintPolynomial(pPoly1);
664.     PRINTF_ARGL("\n");
665.  
666.     AddItemToPolynomialEx(pPoly1, 4, 0);
667.     AddItemToPolynomialEx(pPoly1, 0, 2);
668.     AddItemToPolynomialEx(pPoly1, 0, 0);
669.     AddItemToPolynomialEx(pPoly1, 1, 1);
670.     PRINTF_ARGL("\nnew pPoly1: \n");
671.     PrintPolynomial(pPoly1);
672.     PRINTF_ARGL("\n");
673.     //+
674.     pPoly2 = PolynomialAdd(pPoly, pPoly1);
675.     PRINTF_ARGL("\nAdd pPoly2: \n");
676.     PrintPolynomial(pPoly2);
677.     PRINTF_ARGL("\n");
678.     FreePolynomial(pPoly2);
679.     //-
680.     pPoly2 = PolynomialSubtract(pPoly, pPoly1);
681.     PRINTF_ARGL("\nSub pPoly2: \n");
682.     PrintPolynomial(pPoly2);
683.     PRINTF_ARGL("\n");
684.     FreePolynomial(pPoly2);
685.     //*
686.     pPoly2 = PolynomialMultiply(pPoly, pPoly1);
687.     PRINTF_ARGL("\nMulti pPoly2: \n");
688.     PrintPolynomial(pPoly2);
689.     PRINTF_ARGL("\n");
690.     FreePolynomial(pPoly2);
691.     //HTML +
692.     pPoly2 = HTMLPolynomialAdd(pHTMLFile, pPoly, pPoly1);
693.     FreePolynomial(pPoly2);
694.     //HTML -
695.     pPoly2 = HTMLPolynomialSubtract(pHTMLFile, pPoly, pPoly1);
696.     FreePolynomial(pPoly2);
697.     //HTML *
698.     pPoly2 = HTMLPolynomialMultiply(pHTMLFile, pPoly, pPoly1);
699.     FreePolynomial(pPoly2);
700.     FreePolynomial(pPoly);
701.     FreePolynomial(pPoly1);
702.     return 0;
703. }
704.  
705. int main(int argc, char *argv[])
706. {
707.     int runRslt;
708. #if WRITE_SCREEN_TO_FILE
709.     gpLogFile = fopen(SCREEN_LOG_FILE, "w+");
710. #endif
711.  
712.     runRslt = UserMain(argc, argv);
713.  
714. #if WRITE_SCREEN_TO_FILE
715.     fclose(gpLogFile);
716. #endif
717.     return runRslt;
718. }