广工anyview数据结构-01~02（部分乱码我就不贴出来了）

/**********
【题目】试写一算法，如果三个整数a，b和c的值
不是依次非递增的，则通过交换，令其为非递增。
***********/
void Descend(int &a, int &b, int &c)
/* 通过交换，令 a >= b >= c */
{
 int t;
 if(a<=b){t=b;b=a;a=t;}
 if(b<=c){t=c;c=b;b=t;}
 if(a<=b){t=b;b=a;a=t;}

}

/**********
【题目】已知k阶裴波那契序列的定义为
    f(0)=0, f(1)=0, ..., f(k-2)=0, f(k-1)=1;
    f(n)=f(n-1)+f(n-2)+...+f(n-k), n=k,k+1,...
试编写求k阶裴波那契序列的第m项值的函数算法，
k和m均以值调用的形式在函数参数表中出现。
**********/
Status Fibonacci(int k, int m, int &f) 
/* 求k阶斐波那契序列的第m项的值f */
{
   int t[100],i,j,sum;
   if(k<2||m<0) return ERROR;
   if(m<k-1) f=0;  
   else if(m==k-1) f=1; 
   else
      {for(i=0;i<=k-2;i++) 
         t[i]=0; 
       t[k-1]=1;  
       for(i=k;i<=m;i++) 
         { sum=0; 
           for(j=i-k;j<=i;j++) 
              sum+=t[j]; 
           t[i]=sum; 
         } 
        f=t[m];  
       } 
   return OK;
}

/**********
【题目】试编写算法，计算i!×2^i的值并存入数组
a[0..n-1]的第i-1个分量中 (i=1,2,…,n)。假设计
算机中允许的整数最大值为MAXINT，则当对某个k
(1≤k≤n)使k!×2^k>MAXINT时，应按出错处理。注意
选择你认为较好的出错处理方法。
**********/
Status Series(int a[], int n) 
/* 求i!*2^i序列的值并依次存入长度为n的数组a；     */
/* 若所有值均不超过MAXINT，则返回OK，否则OVERFLOW */
{
   int i,s=1;
   if(n<0) return ERROR;
   for(i=1;i<=n;i++)
     {       
       a[i-1]=s*2*i;
       if(a[i-1]>MAXINT) return OVERFLOW;
       s=a[i-1];
     }
   return OK;     
}

/**********
【题目】试写一算法，对序列S的第i个元素赋以值e。
序列的类型定义为：
typedef struct {
  ElemType  *elem;
  int  length;
} Sequence;
***********/
Status Assign(Sequence &S, int i, ElemType e) 
/* 对序列S的第i个元素赋以值e，并返回OK。 */
/* 若S或i不合法，则赋值失败，返回ERROR   */
{
   int j;
   if(S.length<=i||S.length==0)return ERROR;
   for(j=0;j!=i;j++);
   S.elem[j]=e;
   return OK;
}

/**********
【题目】试写一算法，由长度为n的一维数组a构建一个序列S。
序列的类型定义为：
typedef struct {
  ElemType  *elem;
  int  length;
} Sequence;
***********/
Status CreateSequence(Sequence &S, int n, ElemType *a) 
/* 由长度为n的一维数组a构建一个序列S，并返回OK。 */
/* 若构建失败，则返回ERROR                       */
{
  int i;
  if(n<=0) return ERROR;
  S.elem=(ElemType*)malloc(sizeof(ElemType));
  S.length=n;
  for(i=0;i<n;i++)
   S.elem[i]=a[i];
  return OK; 
}

/**********
【题目】链表的结点和指针类型定义如下
    typedef struct LNode {
       ElemType  data;
       struct LNode *next;
    } LNode, *LinkList;
试写一函数，构建一个值为x的结点。
***********/
LinkList MakeNode(ElemType x)
/* 构建一个值为x的结点，并返回其指针。*/
/* 若构建失败，则返回NULL。           */
{
  LNode *p;
  p=(LNode *)malloc(sizeof(LNode));
  if(x=='\0')return NULL;
  (*p).data=x;
  (*p).next=NULL;
  return p;  
}

/**********
【题目】链表的结点和指针类型定义如下
    typedef struct LNode {
       ElemType  data;
       struct LNode *next;
    } LNode, *LinkList;
试写一函数，构建长度为2且两个结点的值依次为x和y的链表。
**********/
LinkList MakeNode(ElemType x)
{
    LinkList Node;
    Node = (LinkList)malloc(sizeof(LNode));
    if(Node == NULL)  return NULL;
    Node->data = x;
    Node->next = NULL;
    return Node;
}
LinkList CreateLinkList(ElemType x, ElemType y) 
/* 构建其两个结点的值依次为x和y的链表。*/
/* 若构建失败，则返回NULL。            */
{
     LinkList Node_x,Node_y;
     Node_x = MakeNode(x);
     Node_y = MakeNode(y);
     if(Node_x==NULL&&Node_y==NULL)   return NULL;
     Node_x->next = Node_y;
     return Node_x;
}

/**********
【题目】链表的结点和指针类型定义如下
    typedef struct LNode {
       ElemType  data;
       struct LNode *next;
    } LNode, *LinkList;
试写一函数，构建长度为2的升序链表，两个结点的值
分别为x和y，但应小的在前，大的在后。
**********/
LinkList MakeNode(ElemType x)
{
    LinkList Node;
    Node = (LinkList)malloc(sizeof(LNode));
    if(Node == NULL)  return NULL;
    Node->data = x;
    Node->next = NULL;
    return Node;
}
LinkList CreateOrdLList(ElemType x, ElemType y)
/* 构建长度为2的升序链表。  */
/* 若构建失败，则返回NULL。 */
{
    LinkList p,q;
    p=MakeNode(x);
    q=MakeNode(y);
    if((p->data)>(q->data)) {q->next=p;  return q;}
    else p->next=q;
    return p;
}