广工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;

}