// 1) 带权边的类MyArc:

class MyArc
{
public:
    int m_beginVex;
    int m_endVex;
    int m_weight;
    MyArc(int beginVex,int endVex,int weight);
    MyArc(){}
    bool operator < (const MyArc& arc)
    {
        return m_weight<arc.m_weight;
    }
    bool operator == (const MyArc& arc)
    {
        return m_weight==arc.m_weight;
    }
    bool operator > (const MyArc& arc)
    {
        return m_weight>arc.m_weight;
    }
}  ;

MyArc::MyArc(int beginVex,int endVex,int weight):m_beginVex(beginVex),m_endVex(endVex),m_weight(weight)
{}
//2) 表示图的邻接矩阵类Graph:
class Graph
{
public:
    int m_vexnum;
    int m_arcnum;
    int *m_pmatrix;
public:
    ~Graph();
    Graph(int vexnum);
    Graph(int vexnum,int *pmatrix);
    void insert(MyArc arc);//按权值大小排序插入
    bool bound(int x);   //判断顶点x是否已与其它顶点连通
};
//构造函数
Graph::Graph(int vexnum)
{
    m_pmatrix=new int[vexnum*vexnum];
    m_vexnum=vexnum;m_arcnum=0;
    for(int i=0;i<vexnum*vexnum;++i)
    m_pmatrix[i]=0;

}

//构造函数
Graph::Graph(int vexnum,int *pmatrix)
{
    m_vexnum=vexnum;
    // m_arcnum=arcnum;
    m_pmatrix=new int[m_vexnum*m_vexnum];
    for(int i=0;i<m_vexnum*m_vexnum;++i)
        m_pmatrix[i]=pmatrix[i];
}

//测试 顶点x是否已与其他点连通
bool Graph::bound(int x)
{
    for(int i=0;i<m_vexnum;++i) if(m_pmatrix[x+i*m_vexnum]!=0) return true;
    return false;
}

//在邻接表中连通 arc表示的边，并且设置权
void Graph::insert(MyArc arc)
{
    m_pmatrix[arc.m_beginVex*m_vexnum+arc.m_endVex]=arc.m_weight;
    m_pmatrix[arc.m_endVex*m_vexnum+arc.m_beginVex]=arc.m_weight;
    ++m_arcnum;
}
//析构
Graph::~Graph()
{
    delete[] m_pmatrix;
}
//3) 按权存储边的有序队列类MyQueues:

//边按权值插入队列中合适位置,
class MyQueues
{
public:
    list<MyArc> m_list;
    MyQueues(){}
    void insert(const MyArc& arc);//边按权值插入队列中合适位置,
    void InsertGraph(const Graph &graph);//将图的连通分量插入队列
    MyArc pop();
};
//边出队
MyArc MyQueues::pop()
{
    MyArc arc=m_list.front();
    m_list.pop_front();
    return arc;
}
//边按权值插入队列中合适位置,
void MyQueues::insert(const MyArc& arc)
{
    list<MyArc>::iterator pos;
    pos=m_list.begin();
    while(pos!=m_list.end())
    {
        if(*pos>arc) break;
        else ++pos;
    }
    m_list.insert(pos,arc);
}
//将图的连通分量插入队列
void MyQueues::InsertGraph(const Graph &graph)
{
    for(int i=0;i<graph.m_vexnum;++i)
    {
        for(int j=i+1;j<graph.m_vexnum;++j)
              if(graph.m_pmatrix[i*graph.m_vexnum+j]) insert(MyArc(i,j,graph.m_pmatrix[i*graph.m_vexnum+j]));
    }
}

 //5)判断是否有回路的IsCycle函数：
bool IsCycle(Graph& graph, MyArc& arc)
{
    list<int> my_list;
    my_list.push_back(arc.m_beginVex);
    int *ps=new int[graph.m_vexnum];
    for(int i=0;i<graph.m_vexnum;++i)
        ps[i]=0;
    while(!my_list.empty())
    {
        int x=my_list.front();
        ps[x]=1;
        my_list.pop_front();
        for(int i=0;i<graph.m_vexnum;++i)
        {
              if(graph.m_pmatrix[i+x*graph.m_vexnum]!=0)
              {
                  if(i==arc.m_endVex) return true;
                  if(ps[i]!=1) my_list.push_back(i);
              }
        }
    }
    delete[] ps;
    return false;
}
//4) kruskal算法:
void kruskal(const Graph& graph,Graph& smtree)
{
    MyQueues arcqueues;//保存从小到大排列的边
    arcqueues.InsertGraph(graph);
    MyArc myarc;//Arc表示边的类型
    int arcnum=0; //边的个数
    while(arcnum<graph.m_vexnum-1)
    {
        myarc=arcqueues.pop();
        if(!IsCycle(smtree,myarc))
        {
              smtree.insert(myarc);
              ++arcnum;
        }
    }
}

#include<stdio.h>
#define MAX 50
int cycle(char *s)
{
  char *h,*t;
  for(h=s,t=s+strlen(s)-1;t>h;h++,t--)
  {
    if(*h!=*t)
    {
        printf("%c",h);
        break;
    }
  }
  return t<=h;
}

main()
{
  char s[MAX];
  while(1)
  {
    puts("Please input the string you want to judge(input ^ to quit):");
    scanf("%s",s);
    if(s[0]=='^')
      break;
    if(cycle(s))
    printf("%s is a cycle string.\n",s);
    else
    printf("%s is not a cycle string.\n",s);
  }
  puts("\nThank you for you using ,bye bye!\n");
}

输出结果：

Please input the string you want to judge(input ^ to quit):
abcabc
 abcabc is not a cycle string.
Please input the string you want to judge(input ^ to quit):
abccba
abccba is a cycle string.
Please input the string you want to judge(input ^ to quit):

     printf("Enter another character and tow integers;\n");
     printf("Enter a newline to quit.\n");
  }
  printf("Bye.\n");
  return 0;
}
void display(char cr,int lines,int width)
{
  int row ,col;
  for(row =1;row<=lines;row++)
  {
    for(col=1;col<=width;col++)
    {
      putchar(cr);
       }
      putchar('\n');

  }
}
结果输出：
Enter a character and tow integers:
d 3 2
dd
dd
dd
Enter another character and tow integers;
Enter a newline to quit.
Bye.
Press any key to continue...

　可以看见紧跟在2后面的那个换行符，scanf()函数将该换行符留在了输入队列中．而getchar()并不跳过换行符，所以在循环的
下一周期，在你有机会输入其他内容之前，这个换行符由getchar()读出，然后将其赋值给ch，而ch为换行符正是终止循环的条件．

　要解决这个问题，必须跳过一个输入周期中键入的最后一个数字与下一行开始处键入的字符之间的所有换行符或空格．
改进如下：char2.cpp

/*C语言一个I/O问题程序修改版本*/
#include<stdio.h>
void display(char cr,int lines,int width);
int main(void)
{
  int ch;
  int rows,cols;
  printf("Enter a character and tow integers:\n");
  while((ch=getchar())!='\n')
  {
    if( scanf("%d %d",&rows,&cols)!=2)
    break;
     display(ch,rows,cols);
     while(getchar()!='\n')      /*剔除掉scanf()输入后的所有字符．*/
     {

        printf("1");          /*后面有多少字符就输出多少个1*/
        continue;

     }
     printf("Enter another character and tow integers;\n");
     printf("Enter a newline to quit.\n");
  }
  printf("Bye.\n");
  return 0;
}
void display(char cr,int lines,int width)
{
  int row ,col;
  for(row =1;row<=lines;row++)
  {
    for(col=1;col<=width;col++)
    {
      putchar(cr);
       }
      putchar('\n');

  }
}

输出结果：
Enter a character and tow integers:
d 3 4
dddd
dddd
dddd
Enter another character and tow integers;
Enter a newline to quit.
d 3 4
dddd
dddd
dddd
11Enter another character and tow integers;
Enter a newline to quit.

　首先， main() 使用参数 1 调用了函数 up_and_down() ，于是 up_and_down() 中形式参数 n 的值是 1, 故打印语句 #1 输出了 Level1 。
然后，由于 n 的数值小于 4 ，所以 up_and_down() （第 1 级）使用参数 n+1 即数值 2 调用了 up_and_down()( 第 2 级 ). 使得 n 在第 2
级调用中被赋值 2, 打印语句 #1 输出的是 Level2 。与之类似，下面的两次调用分别打印出 Level3 和 Level4 。

　当开始执行第 4 级调用时， n 的值是 4 ，因此 if 语句的条件不满足。这时候不再继续调用 up_and_down() 函数。第 4 级调用接
着执行打印语句 #2 ，即输出 Level4 ，因为 n 的值是 4 。现在函数需要执行 return 语句，此时第 4 级调用结束，把控制权返回给该
函数的调用函数，也就是第 3 级调用函数。第 3 级调用函数中前一个执行过的语句是在 if 语句中进行第 4 级调用。因此，它继
续执行其后继代码，即执行打印语句 #2 ，这将会输出 Level3 ．当第 3 级调用结束后，第 2 级调用函数开始继续执行，即输出
Level2 ．依次类推．

　注意，每一级的递归都使用它自己的私有的变量 n ．可以查看地址的值来证明．

递归的基本原理：

１　每一次函数调用都会有一次返回．当程序流执行到某一级递归的结尾处时，它会转移到前一级递归继续执行．

２　递归函数中，位于递归调用前的语句和各级被调函数具有相同的顺序．如打印语句 #1 位于递归调用语句前，它按照递
　　归调用的顺序被执行了 4 次．

３　每一级的函数调用都有自己的私有变量．

４　递归函数中，位于递归调用语句后的语句的执行顺序和各个被调用函数的顺序相反．

５　虽然每一级递归有自己的变量，但是函数代码并不会得到复制．

６　递归函数中必须包含可以终止递归调用的语句．

再看一个具体的递归函数调用的例子：以二进制形式输出整数

/*输入一个整数，输出二进制形式*/
#include<stdio.h>
void to_binary(unsigned long n);

int main(void)
{
  unsigned long number;
  printf("Enter an integer(q to quit):\n");
  while(scanf("%ul",&number)==1)
  {
    printf("Binary equivalent :");
    to_binary(number);
    putchar('\n');
    printf("Enter an integer(q to quit):\n");
  }
  printf("Done.\n");
  return 0;
 
}
void to_binary(unsigned long n)    /*递归函数*/
{
  int r;
  r=n%2;    /*在递归调用之前计算n%2的数值，然后在递归调用语句之后进行输出．这样
  　　　　　　计算出的第一个数值反而是在最后一个输出*/
  if(n>=2)
  to_binary(n/2);
  putchar('0'+r);/*如果r是0，表达式'0'+r就是字符'0'；如果r是1，则表达式的值为
  　　　　　　　　　'1'．注意前提是字符'1'的数值编码比字符'0'的数值编码大1．
  　　　　　　　　　ASCII和EBCDIC这两种编码都满足这个条件．*/
  return;
}

typedef struct
{
 char ch[MaxSize];
 int len;
}SqString;

int Index(SqString s,SqString t)/* 简单匹配方法*/
{
  int i=0,j=0,k;
  while(i<s.len&&j<t.len)
  {
    if(s.ch[i]==t.ch[j])/*继续匹配下一个字符*/
 {
   i++;
   j++;
 }
 else/*子串、主串的指针回溯重新开始下一次匹配*/
 {
  i=i-j+1;
  j=0;
 }
  }
  if(j>=t.len)/*匹配成功，返回匹配的第一个字符下标*/
   k=i-t.len;
  else/*匹配不成功*/
   k=-1;
  return k;
}

void GetNext(SqString t,int next[])/*由模式串t求出next值*/
{
 int j,k;
 j=0;k=-1;next[0]=-1;
 while(j<t.len-1)
 {
   if(k==-1||t.ch[j]==t.ch[k])
   {
     j++;k++;
     next[j]=k;
   }
   else k=next[k];
 }
}

void GetNextval(SqString t,int nextval[])/*由模式串t求出nextval值*/
{
   int j=0,k=-1;
   nextval[0]=-1;
   while(j<t.len)
   {
    if(k==-1||t.ch[j]==t.ch[k])
    {
      j++;k++;
   if(t.ch[j]!=t.ch[k])
  
    nextval[j]=k;
   else
       nextval[j]=nextval[k];

   }
   else k=nextval[k];
   
   }
}
int KMPIndex(SqString s,SqString t)/*KMP算法*/
{
   int next[MaxSize];
   int i=0,j=0;
   int v;
   GetNext(t,next);
   while(i<s.len && j<t.len)
   {
     if(j==-1||s.ch[i]==t.ch[j])
     {
      i++;
      j++;
   }
   else j=next[j];
   }
   if(j>=t.len)
   v=i-t.len;
   else
   v=-1;
   return v;
}

int KMPIndex1(SqString s,SqString t)/*改进的KMP算法*/
{
 int nextval[MaxSize],next[MaxSize],i=0,j=0,v;
 GetNextval(t,next);
 GetNextval(t,nextval);
 while(i<s.len&&j<t.len)
 {
  if(i==-1||s.ch[i]==t.ch[j])
  {
    i++;
 j++;
  }
  else j=nextval[j];
 }
 if(j>=t.len)
  v=i-t.len;/*返回匹配模式串的首字符下标*/
 else
  v=-1;
 return v;
}

void StrAssign(SqString &str,char cstr[])/*由串常量cstr创建串str */
{
   int i;
   for(i=0;cstr[i]!='\0';i++)
    str.ch[i]=cstr[i];
   str.len=i;
}

void DispStr(SqString s)/*输出串s的所有元素*/
{
  int i;
  if(s.len>0)
  {
    for(i=0;i<s.len;i++)
  printf("%c",s.ch[i]);
 printf("\n");
  }
}
void main()
{
  int j;
  int next[MaxSize],nextval[MaxSize];
  SqString s,t;
  StrAssign(s,"abcabcdabcdeabcdefabcdefg");
  StrAssign(t,"abcdeabcdefab");
  printf("串s:");DispStr(s);
  printf("串t:");DispStr(t);

  printf("简单匹配P算法:\n");
  printf("t在s中的位置:%d\n",Index(s,t));

  GetNext(t,next);
  GetNextval(t,nextval);
  printf(" j     ");
  for(j=0;j<t.len;j++)
  {
   printf("%4d",j);
  }
  printf("\n");
  printf("t[j]   ");
  for(j=0;j<t.len;j++)
  printf("%4c",t.ch[j]);
  printf("\n");
  printf("next   ");
  for(j=0;j<t.len;j++)
  printf("%4d",next[j]);
   printf("\n");
  
   printf("nextval");
   for(j=0;j<t.len;j++)
   printf("%4d",nextval[j]);
   printf("\n");

   printf("KMP算法:\n");
   printf("t在s中的位置:%d\n",KMPIndex(s,t));

   printf("改进的KMP算法:\n");
   printf("t在s中的位置:%d\n",KMPIndex1(s,t));

}

结果如下：
串s:abcabcdabcdeabcdefabcdefg
串t:abcdeabcdefab
简单匹配P算法:
t在s中的位置:7
 j        0   1   2   3   4   5   6   7   8   9  10  11  12
t[j]      a   b   c   d   e   a   b   c   d   e   f   a   b
next     -1   0   0   0   0   0   1   2   3   4   5   0   1
nextval  -1   0   0   0   0  -1   0   0   0   0   5  -1   0
KMP算法:
t在s中的位置:7
改进的KMP算法:
t在s中的位置:7

大学里实行学分制。每门课都有一定的学 分 。每个学生均需要修满规定数量的课程才能毕业。其中有些课程可以直接修读，有些课程需要一定的基础知识，必须在选了其他一些课程的基础上才能修读。例如，《数据结构》必须在选修了《高级语言程序设计》之后才能选修。我们称《高级语言程序设计》是《数据结构》的“先修课”。在我们的大学里，假定每门课的直接先修课至多只有一门，两门课可能存在相同的先修课。例如：

上例中，1是2的先修课，即如果要选修2，则1必定被选。

学生不可能学完大学里开设的所有课程，因此每个学生必须在入学时选定自己要学的课程。每个学生可选课程的总数目是给定的。现在请你们小组编写一个“学生选课系统”，任意给定一种课程体系（总课程数，课程之间的修读先后制约关系，学生毕业要求修的课程数目），该系统能帮助学生找出一种选课方案，使得他能得到的学分最多，并且必须满足先修课程优先的原则

具体实现如下：   

1.          将课程体系存放为课程体系文件 CourseHierarchy.txt ；

2.          将课程体系文件 CourseHierarchy.txt 转换左孩子右兄弟二叉树表示；

3.          在此基础上对二叉树进行先序、中序、后序遍历。

4.      　给出最多学分选课方案。

将课程体系文件转换为二叉树

思想：从 CourseHierarchy.txt 头部开始扫描，第一个先修课为 0 （即没有先修课）的课程为整棵二叉树的根节点 i 。从 CourseHierarchy.txt 头部开始扫描，所有 i 的后续课程作为 i 的左子树；课程体系中，其他先修课为 0 的节点，及其后续课程构成 i 的右子树。第一个先修课为 i 的节点作为 i 的左子树的根节点 ，从 CourseHierarchy.txt 头部开始扫描，其他以 i 为先修课的课程构成 的右子树。如此低归构造出课程体系二叉树。

步骤 1 ：从文件 CourseHierarchy.txt 生成课程链表 Course_Slist （参数表）。

步骤 2 ：将指针 CousreSystem_root 指引的 课程链表递归转换为课程体系二叉树
步骤 3 ：先序输出二叉树，以验证生成的二叉树是否正确
实现代码
tree_binary.cpp
// tree_binary.cpp : 定义控制台应用程序的入口点。
//
#pragma once

    设计并实现魔王语言的解释器，具体要求如下：大写字母表示魔王语言的词汇；小写字母表示人的词汇语言；魔王语言中可包含括号。

    如：我们有魔王语言的解释规则：B－>tAdA；A->sae；则魔王语言 B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae。

实现代码如下：

#include<stdlib.h>
#include<stdio.h>
#define STACK_INIT_SIZE 100 //存储空间初始分配量
#define STACK_INCREMENT  10  //存储空间分配增量
#define OVERFLOW          1
#define OK          1
#define ERROR      0
#define TRUE        1
#define FALSE       0
typedef char      SElemType;
typedef char      QElemType;
typedef int     Status;
typedef struct{
 SElemType *base;            //栈基址
SElemType *top;             //栈顶地址
 int stacksize;
}SqStack;
typedef struct QNode{
 QElemType data;
 struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
 QueuePtr front;   //队头指针
 QueuePtr rear;    //队尾指针
}LinkQueue;
Status InitStack(SqStack &S)
//构造一个空栈
{
 S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(char));
 if(!S.base)
  exit (OVERFLOW);//存储单元分配失败
 S.top=S.base;
 S.stacksize=STACK_INIT_SIZE;
 return OK;
}
Status Push(SqStack &S,SElemType e)
//插入元素e栈顶单元
{
 if(S.top-S.base>=S.stacksize)
 {//栈满，追加存储空间
  S.base=(SElemType *)realloc(S.base,(S.stacksize+STACK_INCREMENT)*sizeof(char));
 if(!S.base)
  exit (OVERFLOW);//存储单元分配失败
 S.top=S.base+S.stacksize;
 S.stacksize+=STACK_INCREMENT;
 }
 *(S.top)=e;
 S.top++;
 return OK;
}
Status Pop(SqStack &S,SElemType& e)
//若栈不为空，则删除S的栈顶单元，用e返回其值
{
 if(S.base==S.top)
  return ERROR;
 S.top--;
 e=*(S.top);
 return OK;
}
Status StackEmpty(SqStack S)
{
 if(S.base==S.top)
  return 0;
 else
  return 1;
}

Status InitQueue(LinkQueue &Q)
//构造一个空队列Q
{
 Q.front=Q.rear=(QueuePtr)malloc(sizeof (QNode));
 if(!Q.front)
  exit (OVERFLOW);
 Q.front->next=NULL;
 return OK;
}
Status EnQueue (LinkQueue&Q,QElemType e)
//插入元素e为Q的新的队尾元素
{
 QueuePtr p;
 p=(QueuePtr)malloc(sizeof (QNode));
 p->data=e;
 p->next=NULL;
 Q.rear->next=p;
 Q.rear=p;
 return OK;
}
Status DeQueue (LinkQueue &Q,QElemType &e)
//若队列不空，则删除Q的队头元素，用e返回其值，并返回OK;
//否则返回ERROR
{
 QueuePtr p;
 if(Q.front==Q.rear)
  return ERROR;
p=Q.front->next;
 e=p->data;
 Q.front->next=p->next;
 if(p==Q.rear)
  Q.rear=Q.front;
 free(p);
 return OK;
}
Status QueueEmpty(LinkQueue Q)
//若队列Q为空队列,则返回TRUE，否则返回FALSE
{
 if(Q.rear==Q.front)
  return FALSE;
 else
  return TRUE;
}
void InStack(char fiend[],SqStack &S)
{
 int m,i=0;
 for(;fiend[i]!='\0';i++);//计算fiend中有多少
 for(m=i-1;m>=0;m--)
  Push(S,fiend[m]);
}
void main()
{
 char e,c,d;
 SqStack S,zhan;
 LinkQueue Q;
   InitQueue(Q);
 char  mowang[]="B(ehnxgz)B";
 printf("你想要解释的魔王语言为：%s\n",mowang);
    char  B[]="tAdA";
 InitStack(S);
 InitStack(zhan);
 InStack(mowang,S);//全部压进栈中
 while(StackEmpty(S))//在栈不为空的情况下
 {
  Pop(S,e);
  if(e=='B')
  InStack(B,zhan);
  else
if(e=='(')//如果为右括号，则输出括号中所有内容
   {
    while(Pop(S,e)&&e!=')')//当为左括号时停止
    {
     if(e!=')')
     EnQueue (Q,e);
    }
     DeQueue (Q,c);//读出队列中第一个元素
    while(QueueEmpty(Q))
    {
     DeQueue (Q,d);//取出元素
     Push(zhan,c);
     Push(zhan,d);
    }
    Push(zhan,c);//再次压入第一个元素
   // Pop(S,e);//去掉左括号
   }

 }
 printf("\n解释的结果为:  ");
    while(StackEmpty(zhan))//在栈不为空的情况下
 {
 
  Pop(zhan,c);
  if(c=='A')
printf("sae");
        else
     printf("%c",c);
  }
  printf("\n");
}

void DispPoly(PolyNode *L)  //输出多项式
{
 PolyNode *p=L->next;
 while (p!=NULL)
 {
  printf("%g,%d;",p->coef,p->exp);
  p=p->next;
 }
 printf("\n");
}
void CreateListR(PolyNode * &L,PolyArray a,int n)    //尾插入法建表
{
 PolyNode *s,*r;int i;
 L=(PolyNode *)malloc(sizeof(PolyNode));          //创建头结点
 L->next=NULL;
// L->exp=n;
// printf("%d\n",L->exp);
 r=L;                                            //r始终指向终端结点，开始时指向头结点
  for(i=0;i<n;i++)
  {
    s=(PolyNode *)malloc(sizeof(PolyNode));   //创建新结点
    s->coef=a[i].coef;
    s->exp=a[i].exp;
    r->next=s;                               //将*s插入*r之后
    r=s;
  }
  r->next=NULL;                               //将终端结点next域置为NULL
}
void Sort(PolyNode * &head)                         //按exp域的值递减排序
{
  PolyNode *p=head->next,*q,*r;
  if(p!=NULL)                                      //当原单链表不为空时
  {
   r=p->next;                                     //r保存*p结点后继结点的指针
   p->next=NULL;                                  //构造只含一个数据结点的有序表
   p=r;
   while(p!=NULL)
   {
     r=p->next;                                   //r保存*p结点后继结点的指针
  q=head;
  while(q->next!=NULL && q->next->exp>p->exp)
   q=q->next;                               //在有序表中找插入*p的前驱结点*q
  p->next=q->next;                             //将*p插入到*q之后
  q->next=p;
  p=r;
   }
  }
}
void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc)//求两个有序表的并
{
  PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;
  float c;
  hc=(PolyNode *)malloc(sizeof(PolyNode));           //创建头结点
  tc=hc;
  while(pa!=NULL && pb!=NULL)
  {
    if(pa->exp>pb->exp)
 {
   s=(PolyNode *)malloc(sizeof(PolyNode));        //复制结点
   s->exp=pa->exp;s->coef=pa->coef;
   tc->next=s;tc=s;
   pa=pa->next;
 }
 else if(pa->exp<pb->exp)
 {
  s=(PolyNode *)malloc(sizeof(PolyNode));           //复制结点
  s->exp=pb->exp;s->coef=pb->coef;
  tc->next=s;tc=s;
  pb=pb->next;
 }
 else                                             //pa->exp=pb->exp时
 {
 c=pa->coef+pb->coef;
 if(c!=0)                                          //系数之和不为0时创建新结点
 {
   s=(PolyNode *)malloc(sizeof(PolyNode));   
   s->exp=pa->exp;s->coef=c;
   tc->next=s;tc=s;
 }
 pa=pa->next;
 pb=pb->next;
 }

  }
  if(pb!=NULL)                                     //复制余下结点
   pa=pb;
  while(pa!=NULL)
  {
    s=(PolyNode *)malloc(sizeof(PolyNode));           //复制结点
 s->exp=pa->exp;s->coef=pa->coef;
 tc->next=s;tc=s;
 pa=pa->next;
  }
  tc->next=NULL;
}

void Subs(PolyNode *ha,PolyNode *hb,PolyNode *&hc)   //求两个有序表的差
{
  PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;
  float c;
  hc=(PolyNode *)malloc(sizeof(PolyNode));           //创建头结点
  tc=hc;
  while(pa!=NULL && pb!=NULL)
  {
    if(pa->exp>pb->exp)
 {
   s=(PolyNode *)malloc(sizeof(PolyNode));        //复制结点
   s->exp=pa->exp;s->coef=pa->coef;
   tc->next=s;tc=s;
   pa=pa->next;
 }
 else if(pa->exp<pb->exp)
 {
  s=(PolyNode *)malloc(sizeof(PolyNode));           //复制结点
  s->exp=pb->exp;s->coef=-pb->coef;                 //如果前个多项式中的指数小于后个多项式指数加上负号
  tc->next=s;tc=s;
  pb=pb->next;
 }
 else                                             //pa->exp=pb->exp时
 {
 c=pa->coef-pb->coef;
 if(c!=0)                                          //系数之差不为0时创建新结点
 {
   s=(PolyNode *)malloc(sizeof(PolyNode));   
   s->exp=pa->exp;s->coef=c;
   tc->next=s;tc=s;
 }
 pa=pa->next;
 pb=pb->next;
 }

  }
  if(pb!=NULL)                                     //复制余下结点
   pa=pb;
  while(pa!=NULL)
  {
    s=(PolyNode *)malloc(sizeof(PolyNode));           //复制结点
 s->exp=pa->exp;s->coef=pa->coef;
 tc->next=s;tc=s;
 pa=pa->next;
  }
  tc->next=NULL;
}
void main()
{
   PolyNode *ha,*hb,*hc;
   //PolyArray a={{1.2,0},{2.5,1},{3.2,3},{-2.5,5}};
   //PolyArray b={{-1.2,0},{2.5,1},{3.2,3},{2.5,5},{5.4,10}};
   int m=4,n=5;
   PolyArray a,b;
   for(int i=0;i<m;i++)
   {
     printf("请输入A多项式中第%d项的系数和指数",i);
  scanf("%f%d",&a[i].coef,&a[i].exp);
   }
 
    for(int j=0;j<n;j++)
   {
     printf("请输入B多项式中第%d项的系数和指数",j);
  scanf("%f%d",&b[j].coef,&b[j].exp);
   }

   CreateListR(ha,a,4);
   CreateListR(hb,b,5);
   printf("原来A:\n");DispPoly(ha);
   printf("原来B:\n");DispPoly(hb);

   Sort(ha);
   Sort(hb);
   printf("排序后A:\n");DispPoly(ha);
   printf("排序后B:\n");DispPoly(hb);

   Add(ha,hb,hc);
   printf("相加后:\n");DispPoly(hc);
   Subs(ha,hb,hc);
   printf("相减后:\n");DispPoly(hc);
}

void CreatComplex(Complex& c,float a,float b);

void AddComplex(Complex& sum,Complex c1,Complex c2 );

void Subtract_C(Complex& Sub,Complex c1,Complex c2 );

void Multiple_C(Complex& product,Complex c1,Complex c2 );

void Print_C(Complex c);

void CreatComplex(Complex& c,float a,float b)
{
 c.real = a;
 c.image = b;
}

void AddComplex(Complex& sum,Complex c1,Complex c2)
{
 sum.real = c1.real + c2.real ;
 sum.image = c1.image  + c2.image  ;
}