数据结构与算法分析--c语言描述练习自答（第三章）(3.1~3.10)

最新推荐文章于 2021-04-08 10:00:15 发布
最新推荐文章于 2021-04-08 10:00:15 发布
阅读量1.3k 收藏 33
点赞数 8
分类专栏： c/c++及数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuluoyide312/article/details/107072747
版权

list.h

#ifndef _List_H
#define _List_H

struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

typedef int ElementType;

List MakeEmpty(List L); //List L is unused
int IsEmpty(List L);
int IsLast(Position P,List L);
Position Find(ElementType X,List L);
void Delete(ElementType X,List L);
Position FindPrevious(ElementType X,List L);
void Insert(ElementType X,List L,Position P);
void DeleteList(List L);
Position Header(List L);
Position First(List L);
Position Advance(Position P);
ElementType Retrieve(Position P);
void PrintList(List L);
#endif

list.c

#include <stdio.h>
#include <stdlib.h>
#include "list.h"
struct Node
{
        ElementType Element;
        Position Next;
};

static void FataError(char *S);
void FataError(char *S)
{
        fputs("S\n",stderr);
        exit(EXIT_FAILURE);
}


/* Initiate a List,L is unused in this implementation */
List MakeEmpty(List L)
{
        Position P;
        P=(Position)malloc(sizeof(struct Node));
        P->Next=NULL;
        return P;
}

/*  Return true if L is empty */
int IsEmpty(List L)
{
        return L->Next==NULL;
}

/* Return true if P is the last position in List L,Parameter L is unused in this implementation  */
int IsLast(Position P,List L)
{
        return P->Next==NULL;
}

/* Return Position of X in L or NULL if not found  */
Position Find(ElementType X,List L)
{
        Position P;
        P=L->Next;
        while(P!=NULL&&P->Element!=X)
                P=P->Next;
        return P;
}

/* Delete first occurrence of X from a list  */
void Delete(ElementType X,List L)
{
        Position P,TmpCell;
        P=FindPrevious(X,L);
        if(!IsLast(P,L))
        {
                TmpCell=P->Next;
                P->Next=TmpCell->Next;
                free(TmpCell);
        }
}

/* If X is not found , the next field of returned Position is NULL  */
Position FindPrevious(ElementType X,List L)
{
        Position P;
        P=L;
        while(P->Next!=NULL&&P->Next->Element!=X)
                P=P->Next;
        return P;
}

/* Insert after legal position P,Parameter L is unused in this implementation  */
void Insert(ElementType X,List L,Position P)
{
        Position TmpCell;
        TmpCell=malloc(sizeof(struct Node));
        if(TmpCell==NULL)
                FataError("Out of space!!");
        TmpCell->Element=X;
        TmpCell->Next=P->Next;
        P->Next=TmpCell;
}

/* avoid delete header  */
void DeleteList(List L)
{
        Position P,Tmp;
        P=L->Next;
        L->Next=NULL;
        while(P!=NULL)
        {
                Tmp=P->Next;
                free(P);
                P=Tmp;
        }
}

/* Return header  */
Position Header(List L)
{
        return L;
}

/* Return the first node except header  */
Position First(List L)
{
        return L->Next;
}

/* Return the next node   */
Position Advance(Position P)
{
        return P->Next;
}

/* Return the select Element  */
ElementType Retrieve(Position P)
{
        return P->Element;
}

void PrintList(List L)
{
        Position P;
        P=L->Next;
        if(IsEmpty(L))
                FataError("List is empty!!!");
        while(P!=NULL)
        {
                printf("%-5d",P->Element);
                P=P->Next;
        }
}

3.1

#include "list.h"

void PrintList(List L)
{
        Position P;
        P=L->Next;
        if(IsEmpty(L))
                FataError("List is empty!!!");
        while(P!=NULL)
        {
                printf("%-5d",P->Element);
                P=P->Next;
        }
}

3.2

#include <stdio.h>
#include "list.h"
void PrintLots(List L,List P);
int main(void)
{
        int i;
        List L,P,L1,P1;
        L=MakeEmpty(L);
        P=MakeEmpty(P);
        L1=L;
        P1=P;
        fputs("Enter integer for L(q to quit):",stdout);
        while(scanf("%d",&i)==1)
        {
                Insert(i,L,L1);
                L1=Advance(L1);
                fputs("Continue (q to quit):",stdout);
        }
        while(getchar()!='\n')
                continue;
        fputs("Enter integer for P(q to quit):",stdout);
        while(scanf("%d",&i)==1)
        {
                Insert(i,P,P1);
                P1=Advance(P1);
                fputs("Continue (q to quit):",stdout);
        }
        PrintList(L);
        PrintList(P);
        putchar('\n');
        PrintLots(L,P);
        return 0;
}
void PrintLots(List L,List P)
{
        Position PtrL,PtrP;
        PtrL=L;
        PtrP=Advance(P);
        int i,j;
        i=0;
        j=Retrieve(PtrP);
        while(PtrP!=NULL)
        {
                for(;i<j;i++)
                {
                        PtrL=Advance(PtrL);
                }
                printf("%5d",Retrieve(PtrL));
                PtrP=Advance(PtrP);
                if(PtrP!=NULL)
                        j=Retrieve(PtrP);
        }
}

3.3

a.

void SwapWithNext(Positon BeforeP,List L)
{
        Positon P,AfterP;
        P=BeforeP->Next;
        AfterP=P->Next;
        /*Both P and AfterP assumed not NULL*/
        P->Next=AfterP->Next;
        BeforeP->Next=AfterP;
        AfterP->Next=P;
}

b.

void SwapWithNext(Position P,List L)
{
        Position BeforeP,AfterP;
        BeforeP=P->Pre;
        AfterP=P->Next;

        P->Next=AfterP->Next;
        AfterP->Next->Prev=P;
        AfterP->Next=P;
        P->Pre=AfterP;
        AfterP->Pre=BeforeP;
        BeforeP->Next=AfterP;
}

3.4

List Intersect(List L1,List L2)
{
        List Result;
        Position L1Pos,L2Pos,ResPos;
        Result=MakeEmpty(Result);
        L1Pos=First(L1);
        L2Pos=First(L2);
        ResPos=First(Result);
        while(L1Pos!=NULL&&L2Pos!=NULL)
        {
                if(L1Pos->Element>L2Pos->Element)
                        L2Pos=Advance(L2Pos);
                else if(L1Pos->Element<L2Pos->Element)
                        L1Pos=Advance(L1Pos);
                else
                {
                        Insert(L1->Element,Result,ResPos);
                        ResPos=Advance(ResPos);
                        L1Pos=Advance(L1Pos);
                        L2Pos=Advance(L2Pos);
                }
        }
        return Result;
}

3.5

List Union(List L1,List L2)
{
        /*The both lists were assumed sorted from small to large*/
        List Result;
        Position L1Pos,L2Pos,ResPos;
        Result=MakeEmpty(Result);
        L1Pos=First(L1);
        L2Pos=First(L2);
        ResPos=First(Result);
        while(L1Pos!=NULL&&L2Pos!=NULL)
        {
                if(L1Pos->Element<L2Pos->Element)
                {
                        Insert(L1->Element,Result,ResPos);
                        L1Pos=Advance(L1Pos);
                }
                else if(L1Pos->Element>L2Pos->Element)
                {
                        Insert(L2->Element,Result,ResPos);
                        L2Pos=Advance(L2Pos);
                }
                else
                {
                        Insert(L1->Element,Result,ResPos);
                        L1Pos=Advance(L1Pos);
                        L2Pos=Advance(L2Pos);
                }
                ResPos=Advance(ResPos);
        }

        /*Flush out remaining list*/
        while(L1Pos!=NULL)
        {
                Insert(L1Pos->Element,Result,ResPos);
                L1Pos=Advance(L1Pos);
                ResPos=Advance(ResPos);
        }
        while(L2Pos!=NULL)
        {
                Insert(L2Pos->Element,Result,ResPos);
                L2Pos=Advance(L2Pos);
                ResPos=Advance(ResPos);
        }
        return Result;
}

3.6

polynomial.h

#ifndef _POLYNOMIAL_H
#define _POLYNOMIAL_H

typedef struct Node *PtrToNode;
struct Node
{
        int Coefficient;
        int Exponent;
        PtrToNode Next;
};
typedef PtrToNode Polynomial;  /*Node will sorted by Exponent from less to large*/
typedef PtrToNode Position;


Polynomial Initiate(Polynomial A);
int IsEmpty(Polynomial A);
int IsLast(Position P,Polynomial A);
void Insert(int Coef,int Exp,Polynomial A,Position P);
void Print(Polynomial A);
void Sort(Polynomial A);
Position Advance(Position P);
void Delete(Polynomial A);
Polynomial Add(Polynomial A,Polynomial B);
Polynomial Multiply(Polynomial A,Polynomial B);





#endif

polynomial.c

#include <stdio.h>
#include <stdlib.h>
#include "polynomial.h"
static int Compare(Position P1,Position P2);  /*Return 0 equal,-1 when P1 less than P2,1 when P1 more than P2*/
static void FataError(char *S);
static int Compare(Position P1,Position P2)
{
        int result;
        if(P1->Exponent<P2->Exponent)
                result=-1;
        else if(P1->Exponent>P2->Exponent)
                result=1;
        else
                result=0;
        return result;
}
static void FataError(char *S)
{
        fputs(S,stderr);
        putchar('\n');
        exit(EXIT_FAILURE);
}

Polynomial Initiate(Polynomial A)
{
        PtrToNode P;
        P=(PtrToNode)malloc(sizeof(struct Node));
        if(P==NULL)
                FataError("Fail to create polynomial!");
        P->Next=NULL;
        return P;
}
int IsEmpty(Polynomial A)
{
        return A->Next==NULL;
}
int IsLast(Position P,Polynomial A)
{
        return P->Next==NULL;
}
void Insert(int Coef,int Exp,Polynomial A,Position P)
{
        Position Ptr;
        Ptr=(PtrToNode)malloc(sizeof(struct Node));
        if(Ptr==NULL)
                FataError("Fail to create Node.");
        Ptr->Coefficient=Coef;
        Ptr->Exponent=Exp;
        Ptr->Next=P->Next;
        P->Next=Ptr;
}
void Print(Polynomial A)
{
        Position P;
        if(IsEmpty(A))
                puts("Polynomial is empty!");
        else
        {
                P=A->Next;
                while(P!=NULL)
                {
                        printf(" %dX^%d ",P->Coefficient,P->Exponent);
                        P=Advance(P);
                        if(P!=NULL)
                                putchar('+');
                }
        }
        putchar('\n');
        fputs("Polynomial print done!",stdout);
}
Position Advance(Position P)
{
        return P->Next;
}
void Delete(Polynomial A)
{
        Position Temp,P;
        P=A->Next;
        A->Next=NULL;
        while(P!=NULL)
        {
                Temp=P;
                P=Advance(P);
                free(Temp);
        }
}
void Sort(Polynomial A)
{
        Position P,Temp;
        int Sorted=0;
        while(Sorted==0)
        {
                P=A;
                Sorted=1;
                while(P->Next->Next!=NULL)
                {
                        if(Compare(P->Next,P->Next->Next)==1)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                Temp->Next=P->Next;
                                P->Next=Temp;
                                Sorted=0;
                        }
                        else if(Compare(P->Next,P->Next->Next)==0)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                P->Next->Coefficient+=Temp->Coefficient;
                                Sorted=0;
                                free(Temp);
                                continue;
                        }
                        P=Advance(P);
                }
        }
}
Polynomial Add(Polynomial A,Polynomial B)       /*assumed Polynomial A and B are sorted from less to large*/
{
        Polynomial Sum;
        Sum=Initiate(Sum);
        Position Pa,Pb,Psum;
        Pa=A->Next;
        Pb=B->Next;
        Psum=Sum;
        while(Pa!=NULL&&Pb!=NULL)
        {
                if(Compare(Pa,Pb)==-1)
                {
                        Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Psum=Advance(Psum);
                }
                else if(Compare(Pa,Pb)==1)
                {
                        Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
                else
                {
                        Insert(Pa->Coefficient+Pb->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
        }
        while(Pa!=NULL)
        {
                Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                Pa=Advance(Pa);
                Psum=Advance(Psum);
        }
        while(Pb!=NULL)
        {
                Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                Pb=Advance(Pb);
                Psum=Advance(Psum);
        }
        return Sum;
}
Polynomial Multiply(Polynomial A,Polynomial B)  /*assume both polynomial were sorted from less to large*/
{
        Polynomial Product;
        Product=Initiate(Product);
        Position Pa,Pb,Pp;
        Pa=A->Next;
        Pp=Product;
        while(Pa!=NULL)
        {
                Pb=B->Next;
                while(Pb!=NULL)
                {
                        Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Product,Pp);
                        Pb=Advance(Pb);
                        Pp=Advance(Pp);
                }
                Pa=Advance(Pa);
        }
        Sort(Product);
        return Product;
}

test.c

#include <stdio.h>
#include "polynomial.h"
int main(void)
{
        int Coef,Exp;
        Polynomial A,B,Sum,Product;
        Position Temp;
        A=Initiate(A);
        B=Initiate(B);
        puts("Start to create polynomial A:");
        Temp=A;
        fputs("Enter two integers for Coefficient and Exponent(q to quit):",stdout);
        while(scanf("%d%d",&Coef,&Exp)==2)
        {
                Insert(Coef,Exp,A,Temp);
                Temp=Advance(Temp);
                fputs("another two integers(q to quit):",stdout);
        }
        puts("Polynomial A created done!We will print it.");
        Print(A);
        puts("Now sort polynomial A.Print it.");
        Sort(A);
        Print(A);
        while(getchar()!='\n')
                continue;
        puts("Start to create polynomial B:");
        Temp=B;
        fputs("Enter two integers for Coefficient and Exponent(q to quit):",stdout);
        while(scanf("%d%d",&Coef,&Exp)==2)
        {
                Insert(Coef,Exp,B,Temp);
                Temp=Advance(Temp);
                fputs("another two integers(q to quit):",stdout);
        }
        puts("Polynomial B created done!We will print it.");
        Print(B);
        puts("Now sort polynomial B.Print it.");
        Sort(B);
        Print(B);
        puts("A plus B:");
        Sum=Add(A,B);
        Print(Sum);
        puts("A multiply B:");
        Product=Multiply(A,B);
        Print(Product);
        puts("Well done!");
        Delete(A);
        Delete(B);
        Delete(Sum);
        Delete(Product);
        return 0;
}

3.7

a.
polynomial.h

#ifndef _POLYNOMIAL_H
#define _POLYNOMIAL_H

typedef struct Node *PtrToNode;
struct Node
{
        int Coefficient;
        int Exponent;
        PtrToNode Next;
};
typedef PtrToNode Polynomial;  /*Node will sorted by Exponent from less to large*/
typedef PtrToNode Position;


Polynomial Initiate(Polynomial A);
int IsEmpty(Polynomial A);
int IsLast(Position P,Polynomial A);
void Insert(int Coef,int Exp,Polynomial A,Position P);
void Print(Polynomial A);
void Sort(Polynomial A);
Position Advance(Position P);
void Delete(Polynomial A);
Polynomial Add(Polynomial A,Polynomial B);
Polynomial Multiply(Polynomial A,Polynomial B);





#endif

polynomial.c

#include <stdio.h>
#include <stdlib.h>
#include "polynomial.h"
static int Compare(Position P1,Position P2);  /*Return 0 equal,-1 when P1 less than P2,1 when P1 more than P2*/
static void FataError(char *S);
static int Compare(Position P1,Position P2)
{
        int result;
        if(P1->Exponent<P2->Exponent)
                result=-1;
        else if(P1->Exponent>P2->Exponent)
                result=1;
        else
                result=0;
        return result;
}
static void FataError(char *S)
{
        fputs(S,stderr);
        putchar('\n');
        exit(EXIT_FAILURE);
}

Polynomial Initiate(Polynomial A)
{
        PtrToNode P;
        P=(PtrToNode)malloc(sizeof(struct Node));
        if(P==NULL)
                FataError("Fail to create polynomial!");
        P->Next=NULL;
        return P;
}
int IsEmpty(Polynomial A)
{
        return A->Next==NULL;
}
int IsLast(Position P,Polynomial A)
{
        return P->Next==NULL;
}
void Insert(int Coef,int Exp,Polynomial A,Position P)
{
        Position Ptr;
        Ptr=(PtrToNode)malloc(sizeof(struct Node));
        if(Ptr==NULL)
                FataError("Fail to create Node.");
        Ptr->Coefficient=Coef;
        Ptr->Exponent=Exp;
        Ptr->Next=P->Next;
        P->Next=Ptr;
}
void Print(Polynomial A)
{
        Position P;
        if(IsEmpty(A))
                puts("Polynomial is empty!");
        else
        {
                P=A->Next;
                while(P!=NULL)
                {
                        printf(" %dX^%d ",P->Coefficient,P->Exponent);
                        P=Advance(P);
                        if(P!=NULL)
                                putchar('+');
                }
        }
        putchar('\n');
        fputs("Polynomial print done!",stdout);
}
Position Advance(Position P)
{
        return P->Next;
}
void Delete(Polynomial A)
{
        Position Temp,P;
        P=A->Next;
        A->Next=NULL;
        while(P!=NULL)
        {
                Temp=P;
                P=Advance(P);
                free(Temp);
        }
}
void Sort(Polynomial A)
{
        Position P,Temp;
        int Sorted=0;
        while(Sorted==0)
        {
                P=A;
                Sorted=1;
                while(P->Next->Next!=NULL)
                {
                        if(Compare(P->Next,P->Next->Next)==1)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                Temp->Next=P->Next;
                                P->Next=Temp;
                                Sorted=0;
                        }
                        else if(Compare(P->Next,P->Next->Next)==0)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                P->Next->Coefficient+=Temp->Coefficient;
                                Sorted=0;
                                free(Temp);
                                continue;
                        }
                        P=Advance(P);
                }
        }
}
Polynomial Add(Polynomial A,Polynomial B)       /*assumed Polynomial A and B are sorted from less to large*/
{
        Polynomial Sum;
        Sum=Initiate(Sum);
        Position Pa,Pb,Psum;
        Pa=A->Next;
        Pb=B->Next;
        Psum=Sum;
        while(Pa!=NULL&&Pb!=NULL)
        {
                if(Compare(Pa,Pb)==-1)
                {
                        Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Psum=Advance(Psum);
                }
                else if(Compare(Pa,Pb)==1)
                {
                        Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
                else
                {
                        Insert(Pa->Coefficient+Pb->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
        }
        while(Pa!=NULL)
        {
                Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                Pa=Advance(Pa);
                Psum=Advance(Psum);
        }
        while(Pb!=NULL)
        {
                Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                Pb=Advance(Pb);
                Psum=Advance(Psum);
        }
        return Sum;
}
Polynomial Multiply(Polynomial A,Polynomial B)  /*assume both polynomial were sorted from less to large*/
{
        Polynomial Product;
        Product=Initiate(Product);
        Position Pa,Pb,Pp;
        Pa=A->Next;
        Pp=Product;
        while(Pa!=NULL)
        {
                Pb=B->Next;
                while(Pb!=NULL)
                {
                        Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Product,Pp);
                        Pb=Advance(Pb);
                        Pp=Advance(Pp);
                }
                Pa=Advance(Pa);
        }
        Sort(Product);
        return Product;
}

test.c

#include <stdio.h>
#include "polynomial.h"
int main(void)
{
        int Coef,Exp;
        Polynomial A,B,Sum,Product;
        Position Temp;
        A=Initiate(A);
        B=Initiate(B);
        puts("Start to create polynomial A:");
        Temp=A;
        fputs("Enter two integers for Coefficient and Exponent(q to quit):",stdout);
        while(scanf("%d%d",&Coef,&Exp)==2)
        {
                Insert(Coef,Exp,A,Temp);
                Temp=Advance(Temp);
                fputs("another two integers(q to quit):",stdout);
        }
        puts("Polynomial A created done!We will print it.");
        Print(A);
        puts("Now sort polynomial A.Print it.");
        Sort(A);
        Print(A);
        while(getchar()!='\n')
                continue;
        puts("Start to create polynomial B:");
        Temp=B;
        fputs("Enter two integers for Coefficient and Exponent(q to quit):",stdout);
        while(scanf("%d%d",&Coef,&Exp)==2)
        {
                Insert(Coef,Exp,B,Temp);
                Temp=Advance(Temp);
                fputs("another two integers(q to quit):",stdout);
        }
        puts("Polynomial B created done!We will print it.");
        Print(B);
        puts("Now sort polynomial B.Print it.");
        Sort(B);
        Print(B);
        puts("A plus B:");
        Sum=Add(A,B);
        Print(Sum);
        puts("A multiply B:");
        Product=Multiply(A,B);
        Print(Product);
        puts("Well done!");
        Delete(A);
        Delete(B);
        Delete(Sum);
        Delete(Product);
        return 0;
}

b.
polynomial.h

#ifndef _POLYNOMIAL_H
#define _POLYNOMIAL_H

typedef struct Node *PtrToNode;
struct Node
{
        int Coefficient;
        int Exponent;
        PtrToNode Next;
};
typedef PtrToNode Polynomial;  /*Node will sorted by Exponent from less to large*/
typedef PtrToNode Position;


Polynomial Initiate(Polynomial A);
int IsEmpty(Polynomial A);
int IsLast(Position P,Polynomial A);
void Insert(int Coef,int Exp,Polynomial A,Position P);
void Print(Polynomial A);
int CountSize(Polynomial A);
void Sort(Polynomial A);
Position Advance(Position P);
void Delete(Polynomial A);
Polynomial Add(Polynomial A,Polynomial B);
Polynomial Multiply(Polynomial A,Polynomial B);





#endif

polynomial.c

#include <stdio.h>
#include <stdlib.h>
#include "polynomial.h"
static int Compare(Position P1,Position P2);  /*Return 0 equal,-1 when P1 less than P2,1 when P1 more than P2*/
static void FataError(char *S);
static int Compare(Position P1,Position P2)
{
        int result;
        if(P1->Exponent<P2->Exponent)
                result=-1;
        else if(P1->Exponent>P2->Exponent)
                result=1;
        else
                result=0;
        return result;
}
static void FataError(char *S)
{
        fputs(S,stderr);
        putchar('\n');
        exit(EXIT_FAILURE);
}

Polynomial Initiate(Polynomial A)
{
        PtrToNode P;
        P=(PtrToNode)malloc(sizeof(struct Node));
        if(P==NULL)
                FataError("Fail to create polynomial!");
        P->Next=NULL;
        return P;
}
int IsEmpty(Polynomial A)
{
        return A->Next==NULL;
}
int IsLast(Position P,Polynomial A)
{
        return P->Next==NULL;
}
void Insert(int Coef,int Exp,Polynomial A,Position P)
{
        Position Ptr;
        Ptr=(PtrToNode)malloc(sizeof(struct Node));
        if(Ptr==NULL)
                FataError("Fail to create Node.");
        Ptr->Coefficient=Coef;
        Ptr->Exponent=Exp;
        Ptr->Next=P->Next;
        P->Next=Ptr;
}
void Print(Polynomial A)
{
        Position P;
        if(IsEmpty(A))
                puts("Polynomial is empty!");
        else
        {
                P=A->Next;
                while(P!=NULL)
                {
                        printf(" %dX^%d ",P->Coefficient,P->Exponent);
                        P=Advance(P);
                        if(P!=NULL)
                                putchar('+');
                }
        }
        putchar('\n');
        fputs("Polynomial print done!",stdout);
}
int CountSize(Polynomial A)     /*the result is exclude header*/
{
        int Count=0;
        Position P;
        P=A->Next;
        while(P!=NULL)
        {
                Count++;
                P=Advance(P);
        }
        return Count;
}
Position Advance(Position P)
{
        return P->Next;
}
void Delete(Polynomial A)
{
        Position Temp,P;
        P=A->Next;
        A->Next=NULL;
        while(P!=NULL)
        {
                Temp=P;
                P=Advance(P);
                free(Temp);
        }
}
void Sort(Polynomial A)
{
        Position P,Temp;
        int Sorted=0;
        while(Sorted==0)
        {
                P=A;
                Sorted=1;
                while(P->Next->Next!=NULL)
                {
                        if(Compare(P->Next,P->Next->Next)==1)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                Temp->Next=P->Next;
                                P->Next=Temp;
                                Sorted=0;
                        }
                        else if(Compare(P->Next,P->Next->Next)==0)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                P->Next->Coefficient+=Temp->Coefficient;
                                Sorted=0;
                                free(Temp);
                                continue;
                        }
                        P=Advance(P);
                }
        }
}
Polynomial Add(Polynomial A,Polynomial B)       /*assumed Polynomial A and B are sorted from less to large*/
{
        Polynomial Sum;
        Sum=Initiate(Sum);
        Position Pa,Pb,Psum;
        Pa=A->Next;
        Pb=B->Next;
        Psum=Sum;
        while(Pa!=NULL&&Pb!=NULL)
        {
                if(Compare(Pa,Pb)==-1)
                {
                        Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Psum=Advance(Psum);
                }
                else if(Compare(Pa,Pb)==1)
                {
                        Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
                else
                {
                        Insert(Pa->Coefficient+Pb->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
        }
        while(Pa!=NULL)
        {
                Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                Pa=Advance(Pa);
                Psum=Advance(Psum);
        }
        while(Pb!=NULL)
        {
                Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                Pb=Advance(Pb);
                Psum=Advance(Psum);
        }
        return Sum;
}
Polynomial Multiply(Polynomial A,Polynomial B)  //O(MN^2),not O(M^2N),i think
{
        int index,M,N;
        Position Pa,Pb,Pp,Temp;
        M=CountSize(A);
        N=CountSize(B);
        M=M<=N?M:N;
        Position Parray[M];
        for(index=0;index<M;index++)
        {
                Parray[index]=Initiate(Parray[index]);
        }
        Pa=A->Next;
        index=0;
        while(Pa!=NULL)
        {
                Pp=Parray[index];
                Pb=B->Next;
                while(Pb!=NULL)
                {
                        Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Parray[index],Pp);
                        Pb=Advance(Pb);
                        Pp=Advance(Pp);
                }
                Sort(Parray[index]);
                Pa=Advance(Pa);
                index++;
        }
        Pp=Initiate(Pp);
        for(index=0;index<M;index++)
        {
                Temp=Pp;
                Pp=Add(Parray[index],Pp);
                Delete(Temp);
        }
        return Pp;

}

test.c

#include <stdio.h>
#include "polynomial.h"
int main(void)
{
        int Coef,Exp;
        Polynomial A,B,Sum,Product;
        Position Temp;
        A=Initiate(A);
        B=Initiate(B);
        puts("Start to create polynomial A:");
        Temp=A;
        fputs("Enter two integers for Coefficient and Exponent(q to quit):",stdout);
        while(scanf("%d%d",&Coef,&Exp)==2)
        {
                Insert(Coef,Exp,A,Temp);
                Temp=Advance(Temp);
                fputs("another two integers(q to quit):",stdout);
        }
        puts("Polynomial A created done!We will print it.");
        Print(A);
        puts("Now sort polynomial A.Print it.");
        Sort(A);
        Print(A);
        while(getchar()!='\n')
                continue;
        puts("Start to create polynomial B:");
        Temp=B;
        fputs("Enter two integers for Coefficient and Exponent(q to quit):",stdout);
        while(scanf("%d%d",&Coef,&Exp)==2)
        {
                Insert(Coef,Exp,B,Temp);
                Temp=Advance(Temp);
                fputs("another two integers(q to quit):",stdout);
        }
        puts("Polynomial B created done!We will print it.");
        Print(B);
        puts("Now sort polynomial B.Print it.");
        Sort(B);
        Print(B);
        puts("A plus B:");
        Sum=Add(A,B);
        Print(Sum);
        puts("A multiply B:");
        Product=Multiply(A,B);
        Print(Product);
        puts("Well done!");
        Delete(A);
        Delete(B);
        Delete(Sum);
        Delete(Product);
        return 0;
}

3.8

polynomial.h

#ifndef _POLYNOMIAL_H
#define _POLYNOMIAL_H

typedef struct Node *PtrToNode;
struct Node
{
        int Coefficient;
        int Exponent;
        PtrToNode Next;
};
typedef PtrToNode Polynomial;  /*Node will sorted by Exponent from less to large*/
typedef PtrToNode Position;


Polynomial Initiate(Polynomial A);
int IsEmpty(Polynomial A);
int IsLast(Position P,Polynomial A);
void Insert(int Coef,int Exp,Polynomial A,Position P);
void Print(Polynomial A);
int CountSize(Polynomial A);
void Sort(Polynomial A);
Position Advance(Position P);
void Delete(Polynomial A);
Polynomial Add(Polynomial A,Polynomial B);
Polynomial Multiply(Polynomial A,Polynomial B);
Polynomial Pow(Polynomial A,int P);




#endif

polynomial_1.c

#include <stdio.h>
#include <stdlib.h>
#include "polynomial.h"
static int Compare(Position P1,Position P2);  /*Return 0 equal,-1 when P1 less than P2,1 when P1 more than P2*/
static void FataError(char *S);
static int Compare(Position P1,Position P2)
{
        int result;
        if(P1->Exponent<P2->Exponent)
                result=-1;
        else if(P1->Exponent>P2->Exponent)
                result=1;
        else
                result=0;
        return result;
}
static void FataError(char *S)
{
        fputs(S,stderr);
        putchar('\n');
        exit(EXIT_FAILURE);
}

Polynomial Initiate(Polynomial A)
{
        PtrToNode P;
        P=(PtrToNode)malloc(sizeof(struct Node));
        if(P==NULL)
                FataError("Fail to create polynomial!");
        P->Next=NULL;
        return P;
}
int IsEmpty(Polynomial A)
{
        return A->Next==NULL;
}
int IsLast(Position P,Polynomial A)
{
        return P->Next==NULL;
}
void Insert(int Coef,int Exp,Polynomial A,Position P)
{
        Position Ptr;
        Ptr=(PtrToNode)malloc(sizeof(struct Node));
        if(Ptr==NULL)
                FataError("Fail to create Node.");
        Ptr->Coefficient=Coef;
        Ptr->Exponent=Exp;
        Ptr->Next=P->Next;
        P->Next=Ptr;
}
void Print(Polynomial A)
{
        Position P;
        if(IsEmpty(A))
                puts("Polynomial is empty!");
        else
        {
                P=A->Next;
                while(P!=NULL)
                {
                        printf(" %dX^%d ",P->Coefficient,P->Exponent);
                        P=Advance(P);
                        if(P!=NULL)
                                putchar('+');
                }
        }
        putchar('\n');
        fputs("Polynomial print done!",stdout);
}
int CountSize(Polynomial A)     /*the result is exclude header*/
{
        int Count=0;
        Position P;
        P=A->Next;
        while(P!=NULL)
        {
                Count++;
                P=Advance(P);
        }
        return Count;
}
Position Advance(Position P)
{
        return P->Next;
}
void Delete(Polynomial A)
{
        Position Temp,P;
        P=A->Next;
        A->Next=NULL;
        while(P!=NULL)
        {
                Temp=P;
                P=Advance(P);
                free(Temp);
        }
}
void Sort(Polynomial A)
{
        Position P,Temp;
        int Sorted=0;
        while(Sorted==0)
        {
                P=A;
                Sorted=1;
                while(P->Next->Next!=NULL)
                {
                        if(Compare(P->Next,P->Next->Next)==1)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                Temp->Next=P->Next;
                                P->Next=Temp;
                                Sorted=0;
                        }
                        else if(Compare(P->Next,P->Next->Next)==0)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                P->Next->Coefficient+=Temp->Coefficient;
                                Sorted=0;
                                free(Temp);
                                continue;
                        }
                        P=Advance(P);
                }
        }
}
Polynomial Add(Polynomial A,Polynomial B)       /*assumed Polynomial A and B are sorted from less to large*/
{
        Polynomial Sum;
        Sum=Initiate(Sum);
        Position Pa,Pb,Psum;
        Pa=A->Next;
        Pb=B->Next;
        Psum=Sum;
        while(Pa!=NULL&&Pb!=NULL)
        {
                if(Compare(Pa,Pb)==-1)
                {
                        Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Psum=Advance(Psum);
                }
                else if(Compare(Pa,Pb)==1)
                {
                        Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
                else
                {
                        Insert(Pa->Coefficient+Pb->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
        }
        while(Pa!=NULL)
        {
                Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                Pa=Advance(Pa);
                Psum=Advance(Psum);
        }
        while(Pb!=NULL)
        {
                Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                Pb=Advance(Pb);
                Psum=Advance(Psum);
        }
        return Sum;
}
Polynomial Multiply(Polynomial A,Polynomial B)  //O(MN^2),not O(M^2N),i think
{
        int index,M,N,S;
        Position Pa,Pb,Pp,Temp;
        M=CountSize(A);
        N=CountSize(B);
        S=M<=N?M:N;
        Position Parray[S];
        for(index=0;index<S;index++)
        {
                Parray[index]=Initiate(Parray[index]);
        }
        if(M<=N)
        {
                Pa=A->Next;
                index=0;
                while(Pa!=NULL)
                {
                        Pp=Parray[index];
                        Pb=B->Next;
                        while(Pb!=NULL)
                        {
                                Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Parray[index],Pp);
                                Pb=Advance(Pb);
                                Pp=Advance(Pp);
                        }
                        Sort(Parray[index]);
                        Pa=Advance(Pa);
                        index++;
                }
        }
        else
        {
                Pa=B->Next;
                index=0;
                while(Pa!=NULL)
                {
                        Pp=Parray[index];
                        Pb=A->Next;
                        while(Pb!=NULL)
                        {
                                Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Parray[index],Pp);
                                Pb=Advance(Pb);
                                Pp=Advance(Pp);
                        }
                        Sort(Parray[index]);
                        Pa=Advance(Pa);
                        index++;
                }
        }
        Pp=Initiate(Pp);
        for(index=0;index<S;index++)
        {
                Temp=Pp;
                Pp=Add(Parray[index],Pp);
                Delete(Temp);
        }
        return Pp;
        }
Polynomial Pow(Polynomial A,int P)
{
        int i;
        Position Temp;
        Polynomial Unit;
        Unit=Initiate(Unit);
        Insert(1,0,Unit,Unit);
        for(i=0;i<P;i++)
        {
                Temp=Unit;
                Unit=Multiply(Unit,A);
                Delete(Temp);
        }
        return Unit;
}

polynomial_2.c

#include <stdio.h>
#include <stdlib.h>
#include "polynomial.h"
static int Compare(Position P1,Position P2);  /*Return 0 equal,-1 when P1 less than P2,1 when P1 more than P2*/
static void FataError(char *S);
static int Compare(Position P1,Position P2)
{
        int result;
        if(P1->Exponent<P2->Exponent)
                result=-1;
        else if(P1->Exponent>P2->Exponent)
                result=1;
        else
                result=0;
        return result;
}
static void FataError(char *S)
{
        fputs(S,stderr);
        putchar('\n');
        exit(EXIT_FAILURE);
}

Polynomial Initiate(Polynomial A)
{
        PtrToNode P;
        P=(PtrToNode)malloc(sizeof(struct Node));
        if(P==NULL)
                FataError("Fail to create polynomial!");
        P->Next=NULL;
        return P;
}
int IsEmpty(Polynomial A)
{
        return A->Next==NULL;
}
int IsLast(Position P,Polynomial A)
{
        return P->Next==NULL;
}
void Insert(int Coef,int Exp,Polynomial A,Position P)
{
        Position Ptr;
        Ptr=(PtrToNode)malloc(sizeof(struct Node));
        if(Ptr==NULL)
                FataError("Fail to create Node.");
        Ptr->Coefficient=Coef;
        Ptr->Exponent=Exp;
        Ptr->Next=P->Next;
        P->Next=Ptr;
}
void Print(Polynomial A)
{
        Position P;
        if(IsEmpty(A))
                puts("Polynomial is empty!");
        else
        {
                P=A->Next;
                while(P!=NULL)
                {
                        printf(" %dX^%d ",P->Coefficient,P->Exponent);
                        P=Advance(P);
                        if(P!=NULL)
                                putchar('+');
                }
        }
        putchar('\n');
        fputs("Polynomial print done!",stdout);
}
int CountSize(Polynomial A)     /*the result is exclude header*/
{
        int Count=0;
        Position P;
        P=A->Next;
        while(P!=NULL)
        {
                Count++;
                P=Advance(P);
        }
        return Count;
}
Position Advance(Position P)
{
        return P->Next;
}
void Delete(Polynomial A)
{
        Position Temp,P;
        P=A->Next;
        A->Next=NULL;
        while(P!=NULL)
        {
                Temp=P;
                P=Advance(P);
                free(Temp);
        }
}
void Sort(Polynomial A)
{
        Position P,Temp;
        int Sorted=0;
        while(Sorted==0)
        {
                P=A;
                Sorted=1;
                while(P->Next->Next!=NULL)
                {
                        if(Compare(P->Next,P->Next->Next)==1)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                Temp->Next=P->Next;
                                P->Next=Temp;
                                Sorted=0;
                        }
                        else if(Compare(P->Next,P->Next->Next)==0)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                P->Next->Coefficient+=Temp->Coefficient;
                                Sorted=0;
                                free(Temp);
                                continue;
                        }
                        P=Advance(P);
                }
        }
}
Polynomial Add(Polynomial A,Polynomial B)       /*assumed Polynomial A and B are sorted from less to large*/
{
        Polynomial Sum;
        Sum=Initiate(Sum);
        Position Pa,Pb,Psum;
        Pa=A->Next;
        Pb=B->Next;
        Psum=Sum;
        while(Pa!=NULL&&Pb!=NULL)
        {
                if(Compare(Pa,Pb)==-1)
                {
                        Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Psum=Advance(Psum);
                }
                else if(Compare(Pa,Pb)==1)
                {
                        Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
                else
                {
                        Insert(Pa->Coefficient+Pb->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
        }
        while(Pa!=NULL)
        {
                Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                Pa=Advance(Pa);
                Psum=Advance(Psum);
        }
        while(Pb!=NULL)
        {
                Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                Pb=Advance(Pb);
                Psum=Advance(Psum);
        }
        return Sum;
}
Polynomial Multiply(Polynomial A,Polynomial B)  //O(MN^2),not O(M^2N),i think
{
        int index,M,N,S;
        Position Pa,Pb,Pp,Temp;
        M=CountSize(A);
        N=CountSize(B);
        S=M<=N?M:N;
        Position Parray[S];
        for(index=0;index<S;index++)
        {
                Parray[index]=Initiate(Parray[index]);
        }
        if(M<=N)
        {
                Pa=A->Next;
                index=0;
                while(Pa!=NULL)
                {
                        Pp=Parray[index];
                        Pb=B->Next;
                        while(Pb!=NULL)
                        {
                                Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Parray[index],Pp);
                                Pb=Advance(Pb);
                                Pp=Advance(Pp);
                        }
                        Sort(Parray[index]);
                        Pa=Advance(Pa);
                        index++;
                }
        }
        else
        {
                Pa=B->Next;
                index=0;
                while(Pa!=NULL)
                {
                        Pp=Parray[index];
                        Pb=A->Next;
                        while(Pb!=NULL)
                        {
                                Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Parray[index],Pp);
                                Pb=Advance(Pb);
                                Pp=Advance(Pp);
                        }
                        Sort(Parray[index]);
                        Pa=Advance(Pa);
                        index++;
                }
        }
        Pp=Initiate(Pp);
        for(index=0;index<S;index++)
        {
                Temp=Pp;
                Pp=Add(Parray[index],Pp);
                Delete(Temp);
        }
        return Pp;
        }
Polynomial Pow(Polynomial A,int P)
{
        int i;
        Position Temp;
        Polynomial Unit;
        Unit=Initiate(Unit);
        Insert(1,0,Unit,Unit);
        if(P==0)
                return Unit;
        if(P==1)
                return A;
        if(P%2==0)
                return Pow(Multiply(A,A),P/2);
        else
                return Multiply(Pow(Multiply(A,A),P/2),A);
}

test.c

#include <stdio.h>
#include "polynomial.h"
int main(void)
{
        int Coef,Exp;
        Polynomial A,B,Sum,Product;
        Position Temp;
        A=Initiate(A);
        B=Initiate(B);
        puts("Start to create polynomial A:");
        Temp=A;
        fputs("Enter two integers for Coefficient and Exponent(q to quit):",stdout);
        while(scanf("%d%d",&Coef,&Exp)==2)
        {
                Insert(Coef,Exp,A,Temp);
                Temp=Advance(Temp);
                fputs("another two integers(q to quit):",stdout);
        }
        puts("Polynomial A created done!We will print it.");
        Print(A);
        puts("Now sort polynomial A.Print it.");
        Sort(A);
        Print(A);
        while(getchar()!='\n')
                continue;
        puts("Start to create polynomial B:");
        Temp=B;
        fputs("Enter two integers for Coefficient and Exponent(q to quit):",stdout);
        while(scanf("%d%d",&Coef,&Exp)==2)
        {
                Insert(Coef,Exp,B,Temp);
                Temp=Advance(Temp);
                fputs("another two integers(q to quit):",stdout);
        }
        puts("Polynomial B created done!We will print it.");
        Print(B);
        puts("Now sort polynomial B.Print it.");
        Sort(B);
        Print(B);
        puts("A plus B:");
        Sum=Add(A,B);
        Print(Sum);
        puts("A multiply B:");
        Product=Multiply(A,B);
        Print(Product);
        puts("Well done!");
        puts("Now we calculate the Pow of A^2:");
        Print(Pow(A,2));
        puts("Now we calculate the Pow of B^3:");
        Print(Pow(B,3));
        Delete(A);
        Delete(B);
        Delete(Sum);
        Delete(Product);
        return 0;
}

在这里插入图片描述

3.9

biginteger.h

#ifndef _BIGINTEGER_H
#define _BIGINTEGER_H

#include "polynomial.h"
typedef Polynomial BigInteger;
BigInteger IntegerToBigInteger(long long int A);
BigInteger PowOfBigInteger(BigInteger A,int P);
int * Statistics(BigInteger A);
void PrintBigInteger(BigInteger A);






#endif

biginteger.c

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

BigInteger IntegerToBigInteger(long long int A)
{
        int exp=0,coef;
        BigInteger N;
        Position P;
        N=Initiate(N);
        P=N;
        while(A>0)
        {
                coef=A%NumberSystem;
                Insert(coef,exp,N,P);
                P=Advance(P);
                A/=NumberSystem;
                exp++;
        }
        return N;
}

BigInteger PowOfBigInteger(BigInteger A,int P)
{
        return Pow(A,P);
}

int * Statistics(BigInteger A)
{
        int *Array;
        Position P;
        Array=(int *)malloc(sizeof(int)*NumberSystem);
        P=A->Next;
        while(P!=NULL)
        {
                Array[P->Coefficient]++;
                P=Advance(P);
        }
        return Array;
}
void PrintBigInteger(BigInteger A)
{
        Position P;
        P=A->Next;
        if(P!=NULL)
        {
                PrintBigInteger(P);
                printf("%d",P->Coefficient);
        }
}

test.c

#include <stdio.h>
#include "biginteger.h"
int main(void)
{
        int biger,exponent;
        puts("Enter two integer for biger and exponent:");
        fscanf(stdin,"%d%d",&biger,&exponent);
        int *array,i;
        BigInteger T;
        T=IntegerToBigInteger(biger);
        puts("big integer is:");
        PrintBigInteger(T);
        putchar('\n');
        T=PowOfBigInteger(T,exponent);
        array=Statistics(T);
        for(i=0;i<NumberSystem;i++)
                printf("There are %d of %ds in the  result.\n",array[i],i);
        puts("Print the big integer:");
        PrintBigInteger(T);
        return 0;
}

polynomial.h

#ifndef _POLYNOMIAL_H
#define _POLYNOMIAL_H

#define NumberSystem 10
typedef struct Node *PtrToNode;
struct Node
{
        int Coefficient;
        int Exponent;
        PtrToNode Next;
};
typedef PtrToNode Polynomial;  /*Node will sorted by Exponent from less to large*/
typedef PtrToNode Position;


Polynomial Initiate(Polynomial A);
int IsEmpty(Polynomial A);
int IsLast(Position P,Polynomial A);
void Insert(int Coef,int Exp,Polynomial A,Position P);
void Print(Polynomial A);
int CountSize(Polynomial A);
void Sort(Polynomial A);
Position Advance(Position P);
void Delete(Polynomial A);
Polynomial Add(Polynomial A,Polynomial B);
Polynomial Multiply(Polynomial A,Polynomial B);
Polynomial Pow(Polynomial A,int P);




#endif

polynomial_1.c

#include <stdio.h>
#include <stdlib.h>
#include "polynomial.h"
static int Compare(Position P1,Position P2);  /*Return 0 equal,-1 when P1 less than P2,1 when P1 more than P2*/
static void FataError(char *S);
static int Compare(Position P1,Position P2)
{
        int result;
        if(P1->Exponent<P2->Exponent)
                result=-1;
        else if(P1->Exponent>P2->Exponent)
                result=1;
        else
                result=0;
        return result;
}
static void FataError(char *S)
{
        fputs(S,stderr);
        putchar('\n');
        exit(EXIT_FAILURE);
}

Polynomial Initiate(Polynomial A)
{
        PtrToNode P;
        P=(PtrToNode)malloc(sizeof(struct Node));
        if(P==NULL)
                FataError("Fail to create polynomial!");
        P->Next=NULL;
        return P;
}
int IsEmpty(Polynomial A)
{
        return A->Next==NULL;
}
int IsLast(Position P,Polynomial A)
{
        return P->Next==NULL;
}
void Insert(int Coef,int Exp,Polynomial A,Position P)
{
        Position Ptr;
        Ptr=(PtrToNode)malloc(sizeof(struct Node));
        if(Ptr==NULL)
                FataError("Fail to create Node.");
        Ptr->Coefficient=Coef;
        Ptr->Exponent=Exp;
        Ptr->Next=P->Next;
        P->Next=Ptr;
}
void Print(Polynomial A)
{
        Position P;
        if(IsEmpty(A))
                puts("Polynomial is empty!");
        else
        {
                P=A->Next;
                while(P!=NULL)
                {
                        printf(" %dX^%d ",P->Coefficient,P->Exponent);
                        P=Advance(P);
                        if(P!=NULL)
                                putchar('+');
                }
        }
        putchar('\n');
        fputs("Polynomial print done!",stdout);
}
int CountSize(Polynomial A)     /*the result is exclude header*/
{
        int Count=0;
        Position P;
        P=A->Next;
        while(P!=NULL)
        {
                Count++;
                P=Advance(P);
        }
        return Count;
}
Position Advance(Position P)
{
        return P->Next;
}
void Delete(Polynomial A)
{
        Position Temp,P;
        P=A->Next;
        A->Next=NULL;
        while(P!=NULL)
        {
                Temp=P;
                P=Advance(P);
                free(Temp);
        }
}
void Sort(Polynomial A)
{
        Position P,Temp;
        int Sorted=0;
        while(Sorted==0)
        {
                P=A;
                Sorted=1;
                while(P->Next->Next!=NULL)
                {
                        if(Compare(P->Next,P->Next->Next)==1)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                Temp->Next=P->Next;
                                P->Next=Temp;
                                Sorted=0;
                        }
                        else if(Compare(P->Next,P->Next->Next)==0)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                P->Next->Coefficient+=Temp->Coefficient;
                                Sorted=0;
                                free(Temp);
                                continue;
                        }
                        P=Advance(P);
                }
        }
}
Polynomial Add(Polynomial A,Polynomial B)       /*assumed Polynomial A and B are sorted from less to large*/
{
        Polynomial Sum;
        Sum=Initiate(Sum);
        Position Pa,Pb,Psum;
        Pa=A->Next;
        Pb=B->Next;
        Psum=Sum;
        while(Pa!=NULL&&Pb!=NULL)
        {
                if(Compare(Pa,Pb)==-1)
                {
                        Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Psum=Advance(Psum);
                }
                else if(Compare(Pa,Pb)==1)
                {
                        Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
                else
                {
                        Insert(Pa->Coefficient+Pb->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
        }
        while(Pa!=NULL)
        {
                Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                Pa=Advance(Pa);
                Psum=Advance(Psum);
        }
        while(Pb!=NULL)
        {
                Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                Pb=Advance(Pb);
                Psum=Advance(Psum);
        }
        return Sum;
}
Polynomial Multiply(Polynomial A,Polynomial B)  //O(MN^2),not O(M^2N),i think
{
        int index,M,N,S;
        Position Pa,Pb,Pp,Temp;
        M=CountSize(A);
        N=CountSize(B);
        S=M<=N?M:N;
        Position Parray[S];
        for(index=0;index<S;index++)
        {
                Parray[index]=Initiate(Parray[index]);
        }
        if(M<=N)
        {
                Pa=A->Next;
                index=0;
                while(Pa!=NULL)
                {
                        Pp=Parray[index];
                        Pb=B->Next;
                        while(Pb!=NULL)
                        {
                                Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Parray[index],Pp);
                                Pb=Advance(Pb);
                                Pp=Advance(Pp);
                        }
                        Sort(Parray[index]);
                        Pa=Advance(Pa);
                        index++;
                }
        }
        else
        {
                Pa=B->Next;
                index=0;
                while(Pa!=NULL)
                {
                        Pp=Parray[index];
                        Pb=A->Next;
                        while(Pb!=NULL)
                        {
                                Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Parray[index],Pp);
                                Pb=Advance(Pb);
                                Pp=Advance(Pp);
                        }
                        Sort(Parray[index]);
                        Pa=Advance(Pa);
                        index++;
                }
        }
        Pp=Initiate(Pp);
        for(index=0;index<S;index++)
        {
                Temp=Pp;
                Pp=Add(Parray[index],Pp);
                Delete(Temp);
        }
        return Pp;
        }
Polynomial Pow(Polynomial A,int P)
{
        int i;
        Position Temp;
        Polynomial Unit;
        Unit=Initiate(Unit);
        Insert(1,0,Unit,Unit);
        for(i=0;i<P;i++)
        {
                Temp=Unit;
                Unit=Multiply(Unit,A);
                Delete(Temp);
        }
        return Unit;
}

polynomial_2.c

#include <stdio.h>
#include <stdlib.h>
#include "polynomial.h"
static int Compare(Position P1,Position P2);  /*Return 0 equal,-1 when P1 less than P2,1 when P1 more than P2*/
static void FataError(char *S);
static void AdaptCoefficient(Polynomial A);
static void AdaptCoefficient(Polynomial A)
{
        Position P;
        int Adapted=0;
        while(Adapted==0)
        {
                P=A->Next;
                Adapted=1;
                while(P!=NULL)
                {
                        if(P->Coefficient>=NumberSystem)
                        {
                                if(P->Next!=NULL)
                                {
                                        P->Next->Coefficient+=P->Coefficient/NumberSystem;
                                        P->Coefficient%=NumberSystem;
                                }
                                else
                                {
                                        Insert(P->Coefficient/NumberSystem,P->Exponent+1,A,P);
                                        P->Coefficient%=NumberSystem;
                                }
                                Adapted=0;
                        }
                        P=Advance(P);
                }
        }
}
static int Compare(Position P1,Position P2)
{
        int result;
        if(P1->Exponent<P2->Exponent)
                result=-1;
        else if(P1->Exponent>P2->Exponent)
                result=1;
        else
                result=0;
        return result;
}
static void FataError(char *S)
{
        fputs(S,stderr);
        putchar('\n');
        exit(EXIT_FAILURE);
}

Polynomial Initiate(Polynomial A)
{
        PtrToNode P;
        P=(PtrToNode)malloc(sizeof(struct Node));
        if(P==NULL)
                FataError("Fail to create polynomial!");
        P->Next=NULL;
        return P;
}
int IsEmpty(Polynomial A)
{
        return A->Next==NULL;
}
int IsLast(Position P,Polynomial A)
{
        return P->Next==NULL;
}
void Insert(int Coef,int Exp,Polynomial A,Position P)
{
        Position Ptr;
        Ptr=(PtrToNode)malloc(sizeof(struct Node));
        if(Ptr==NULL)
                FataError("Fail to create Node.");
        Ptr->Coefficient=Coef;
        Ptr->Exponent=Exp;
        Ptr->Next=P->Next;
        P->Next=Ptr;
}
void Print(Polynomial A)
{
        Position P;
        if(IsEmpty(A))
                puts("Polynomial is empty!");
        else
        {
                P=A->Next;
                while(P!=NULL)
                {
                        printf(" %dX^%d ",P->Coefficient,P->Exponent);
                        P=Advance(P);
                        if(P!=NULL)
                                putchar('+');
                }
        }
        putchar('\n');
        fputs("Polynomial print done!",stdout);
}
int CountSize(Polynomial A)     /*the result is exclude header*/
{
        int Count=0;
        Position P;
        P=A->Next;
        while(P!=NULL)
        {
                Count++;
                P=Advance(P);
        }
        return Count;
}
Position Advance(Position P)
{
        return P->Next;
}
void Delete(Polynomial A)
{
        Position Temp,P;
        P=A->Next;
        A->Next=NULL;
        while(P!=NULL)
        {
                Temp=P;
                P=Advance(P);
                free(Temp);
        }
}
void Sort(Polynomial A)
{
        Position P,Temp;
        int Sorted=0;
        while(Sorted==0)
        {
                P=A;
                Sorted=1;
                while(P->Next->Next!=NULL)
                {
                        if(Compare(P->Next,P->Next->Next)==1)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                Temp->Next=P->Next;
                                P->Next=Temp;
                                Sorted=0;
                        }
                        else if(Compare(P->Next,P->Next->Next)==0)
                        {
                                Temp=P->Next->Next;
                                P->Next->Next=Temp->Next;
                                P->Next->Coefficient+=Temp->Coefficient;
                                Sorted=0;
                                free(Temp);
                                continue;
                        }
                        P=Advance(P);
                }
        }
}
Polynomial Add(Polynomial A,Polynomial B)       /*assumed Polynomial A and B are sorted from less to large*/
{
        Polynomial Sum;
        Sum=Initiate(Sum);
        Position Pa,Pb,Psum;
        Pa=A->Next;
        Pb=B->Next;
        Psum=Sum;
        while(Pa!=NULL&&Pb!=NULL)
        {
                if(Compare(Pa,Pb)==-1)
                {
                        Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Psum=Advance(Psum);
                }
                else if(Compare(Pa,Pb)==1)
                {
                        Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
                else
                {
                        Insert(Pa->Coefficient+Pb->Coefficient,Pa->Exponent,Sum,Psum);
                        Pa=Advance(Pa);
                        Pb=Advance(Pb);
                        Psum=Advance(Psum);
                }
        }
        while(Pa!=NULL)
        {
                Insert(Pa->Coefficient,Pa->Exponent,Sum,Psum);
                Pa=Advance(Pa);
                Psum=Advance(Psum);
        }
        while(Pb!=NULL)
        {
                Insert(Pb->Coefficient,Pb->Exponent,Sum,Psum);
                Pb=Advance(Pb);
                Psum=Advance(Psum);
        }
        AdaptCoefficient(Sum);
        return Sum;
}
Polynomial Multiply(Polynomial A,Polynomial B)  //O(MN^2),not O(M^2N),i think
{
        int index,M,N,S;
        Position Pa,Pb,Pp,Temp;
        M=CountSize(A);
        N=CountSize(B);
        S=M<=N?M:N;
        Position Parray[S];
        for(index=0;index<S;index++)
        {
                Parray[index]=Initiate(Parray[index]);
        }
        if(M<=N)
        {
                Pa=A->Next;
                index=0;
                while(Pa!=NULL)
                {
                        Pp=Parray[index];
                        Pb=B->Next;
                        while(Pb!=NULL)
                        {
                                Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Parray[index],Pp);
                                Pb=Advance(Pb);
                                Pp=Advance(Pp);
                        }
                        Sort(Parray[index]);
                        Pa=Advance(Pa);
                        index++;
                }
        }
        else
        {
                Pa=B->Next;
                index=0;
                while(Pa!=NULL)
                {
                        Pp=Parray[index];
                        Pb=A->Next;
                        while(Pb!=NULL)
                        {
                                Insert(Pa->Coefficient*Pb->Coefficient,Pa->Exponent+Pb->Exponent,Parray[index],Pp);
                                Pb=Advance(Pb);
                                Pp=Advance(Pp);
                        }
                        Sort(Parray[index]);
                        Pa=Advance(Pa);
                        index++;
                }
        }
        Pp=Initiate(Pp);
        for(index=0;index<S;index++)
        {
                Temp=Pp;
                Pp=Add(Parray[index],Pp);
                Delete(Temp);
        }
        return Pp;
        }
Polynomial Pow(Polynomial A,int P)
{
        int i;
        Position Temp;
        Polynomial Unit;
        Unit=Initiate(Unit);
        Insert(1,0,Unit,Unit);
        if(P==0)
                return Unit;
        if(P==1)
                return A;
        if(P%2==0)
                return Pow(Multiply(A,A),P/2);
        else
                return Multiply(Pow(Multiply(A,A),P/2),A);
}

3.10

list.h

#ifndef _List_H
#define _List_H

struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;

typedef int ElementType;
struct Node
{
        ElementType Element;
        Position Next;
};
List MakeEmpty(List L); //List L is unused
int IsEmpty(List L);
int IsLast(Position P,List L);
Position Find(ElementType X,List L);
void Delete(ElementType X,List L);
Position FindPrevious(ElementType X,List L);
void Insert(ElementType X,List L,Position P);
void DeleteList(List L);
Position Header(List L);
Position First(List L);
Position Advance(Position P,List L);
ElementType Retrieve(Position P);
void PrintList(List L);
#endif

list.c

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


static void FataError(char *S);
void FataError(char *S)
{
        fputs("S\n",stderr);
        exit(EXIT_FAILURE);
}


/* Initiate a List,L is unused in this implementation */
List MakeEmpty(List L)
{
        Position P;
        P=(Position)malloc(sizeof(struct Node));
        P->Next=P;
        return P;
}

/*  Return true if L is empty */
int IsEmpty(List L)
{
        return L->Next==L;
}

/* Return true if P is the last position in List L,Parameter L is unused in this implementation  */
int IsLast(Position P,List L)
{
        return P->Next==L;
}

/* Return Position of X in L or L if not found  */
Position Find(ElementType X,List L)
{
        Position P;
        P=L->Next;
        while(P!=L&&P->Element!=X)
                P=P->Next;
        return P;
}

/* Delete first occurrence of X from a list  */
void Delete(ElementType X,List L)
{
        Position P,TmpCell;
        P=FindPrevious(X,L);
        if(!IsLast(P,L))
        {
                TmpCell=P->Next;
                P->Next=TmpCell->Next;
                free(TmpCell);
        }
        else
        {
                TmpCell=L->Next;
                L->Next=TmpCell->Next;
                free(TmpCell);
        }
}

/* If X is not found , the next field of returned Position is NULL  */
Position FindPrevious(ElementType X,List L)
{
        Position P;
        P=L;
        while(P->Next!=L&&P->Next->Element!=X)
                P=P->Next;
        if(P==L)
        {
                while(!IsLast(P,L))
                        P=Advance(P,L);
        }
        return P;
}

/* Insert after legal position P,Parameter L is unused in this implementation  */
void Insert(ElementType X,List L,Position P)
{
        Position TmpCell;
        TmpCell=malloc(sizeof(struct Node));
        if(TmpCell==NULL)
                FataError("Out of space!!");
        TmpCell->Element=X;
        TmpCell->Next=P->Next;
        P->Next=TmpCell;
}

/* avoid delete header  */
void DeleteList(List L)
{
        Position P,Tmp;
        P=L->Next;
        L->Next=NULL;
        while(P!=L)
        {
                Tmp=P->Next;
                free(P);
                P=Tmp;
        }
}

/* Return header  */
Position Header(List L)
{
        return L;
}

/* Return the first node except header  */
Position First(List L)
{
        return L->Next;
}

/* Return the next node   */
Position Advance(Position P,List L)
{
        if(IsLast(P,L))
                return P->Next->Next;
        return P->Next;
}

/* Return the select Element  */
ElementType Retrieve(Position P)
{
        return P->Element;
}

void PrintList(List L)
{
        Position P;
        P=L->Next;
        if(IsEmpty(L))
                FataError("List is empty!!!");
        while(P!=L)
        {
                printf("%-5d",P->Element);
                P=P->Next;
        }
}

josephus.c

#include <stdio.h>
#include "list.h"
int main(void)
{
        int M,N,i,j,count;
        List L;
        Position P,Temp;
        L=MakeEmpty(L);
        puts("M   N:");
        scanf("%d%d",&M,&N);
        for(i=1,P=L;i<=N;i++)
        {
                Insert(i,L,P);
                P=Advance(P,L);
        }
        PrintList(L);
        putchar('\n');
        P=L->Next;
        for(count=0;count<N-1;count++)
        {
                for(j=M;j>0;j--)
                {
                        P=Advance(P,L);
                }
                printf("%5d",Retrieve(P));
                Temp=P;
                P=Advance(P,L);
                Delete(Retrieve(Temp),L);
        }
        PrintList(L);
        return 0;
}

在这里插入图片描述

fuluoyide312
关注
  • 8
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法分析--c语言描述(原书第二版)练习自答（第三章）(3.18~3.26)
fuluoyide312的博客
07-01 1000
3.18 stack.h #ifndef _Stack_H #define _Stack_H #define symbolsize 10 struct Node; typedef char *ElementType; typedef struct Node *PtrToNode; typedef PtrToNode Stack; int IsEmpty(Stack S); Stack CreateStack(void); void MakeEmpty(Stack S); void Push(Elemen
c语言第一版第三章答案,《数据结构与算法分析——c语言描述》第三章笔记与课后练习解答...
weixin_33068783的博客
05-17 336
关于第三章：第三章正式开始谈数据结构的实现，说的是最基本的链表、栈和队列。链表的用处非常多，以后的其他数据结构(比如散列表、图)也会用到，非常基本而实用的数据结构。而栈，则是编译器中递归实现的核心，学习这个数据结构可以有效的帮助理解递归的工作原理。至于队列，经常用在模拟一些比如顾客排队时间，进程时间调度的问题上。笔记：抽象数据类型(ADT，abstract data type)：ADT是一些操作的...
数据结构与算法分析-3.1
m0_37756557的博客
10-10 264
打印一个单列表的所有元素 查了CSDN中其他人关于这题的思路，加上自己的理解，现在是自己的代码。 首先，声明一个结构体。我属于初学者，开始很难懂结构体里还会有一个结构体，只知道是嵌套要用。在这题里，我很能理解这个要求了。因为curr->next与head后面要赋值，也只有curr的next为结构体才能这样，而且还非要是指针才能运行成功，关于malloc的使用，getchar的用法，
数据结构与算法分析（C语言描述）（十一）第三章课后习题
Night___Raid的博客
08-25 495
3.2.The comments for Exercise 3.4 regarding the amount of abstractness used apply here. The running time of the procedure in Fig. 3.1 is OO(LO + PO). void PrintLots(List L, List P) { int Counter;...
数据结构与算法分析3.10
qq_28161649的博客
11-14 181
/*Josephus 问题  N个人从1到N编号，围坐成一个圆圈。从1号开始传递一个热土豆。经过M次传递后拿着热土豆的人被清除离座，围坐的圆圈缩紧，由坐在被清除的人后面的人拿起热土豆继续进行游戏，最后剩下的人取胜*/ //头文件 #ifndef _Josephus_H typedef struct Node *PtrToNode; typedef PtrToNode Positio
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法C语言版本，帮助数据结构快速入门
数据结构与算法分析 C语言描述（原书第2版）课后习题参考答案
01-02
数据结构与算法分析 C语言描述（原书第2版）课后习题参考答案
数据结构与算法分析3.1 栈实现表达式+-*/运算
weixin_30746129的博客
04-16 196
用栈实现了表达式的运算，基本功能可以实现，enhance 给QA测试一下应该可以做个简单的计算器。 root@ubuntu:data-struct# cat stack_cal.c  #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; typedef int element_t; type...
《数据结构与算法 C语言版》—— 3.1栈
weixin_33699914的博客
07-04 217
本节书摘来自华章出版社《数据结构与算法 C语言版》一 书中的第3章，第3.1节，作者：徐凤生，更多章节内容可以访问云栖社区“华章计算机”公众号查看。 3.1栈 3.1.1栈的抽象数据类型定义 栈(stack)是限定仅在表尾进行插入或删除操作的线性表。表尾端称为栈顶，表头端称为栈底。不含元素的栈称为空栈。由于后进栈的元素先出栈，所以栈又称为后进先出(Las...
《数据结构与算法分析：C语言描述》习题3.2~3.3
idjke的博客
07-30 440
3.2 （题目中两个链表均以升序排列） #include<stdio.h> #include<malloc.h> /*假设输入都合法*/ typedef struct node { int data; struct node* pNext; }Node, * PtrNode; PtrNode MakeList(void); //创建链表 void PrintLots(PtrNode L, PtrNode P); int main(void) { .
《数据结构与算法分析：C语言描述》习题3.6
idjke的博客
08-07 511
3.6 #include<stdio.h> #include<malloc.h> #include<stdlib.h> /* 进行书p45上两个多项式的加法(懒得用scanf输入) */ /* 要求多项式必须有次数为0的项(没有则设为0) */ typedef struct Node { //多项式中每一个部分的系数及指数 int coefficient; int exponent; struct Node* pNext; }PolyNode,*PtrPolyN.
数据结构与算法分析:C语言描述(pdf+源码+答案)
热门推荐
Tracyhuixingfu的专栏
11-28 1万+
书    名：数据结构与算法分析：C语言描述                   作    者：Mark Allen Weiss (维斯)                    ISBN   ：9787111127482                   页    数：391                   定    价：35                   出版社：机械工
《数据结构与算法分析-C语言描述》笔记
le062的专栏
07-07 706
第一章 引论     观念：写出一个可以工作的程序并不够。如果这个程序在巨大的数据集上运行，那么运行时间就变成了重要的问题。 第二章 算法分析      2.4.3 最大子序列和问题的解    算法1 O(N^3) le062@Ubuntu20120606102912:~/algorithm$ cat source2-4-3_1.c #include #include
数据结构---栈(指针实现)
luo560的博客
02-18 703
用C语言描述栈，以下是源代码：#include "stack.h" Stack CreatStack(void) { PtrToNode S = (PtrToNode)malloc(sizeof(Node)); if (S == NULL) { printf("Out of space!\r\n"); return NULL; } S->Next = NULL; memset
数据结构与算法（二） 线性表
weixin_44988083的博客
08-03 298
数据结构与算法（二） 线性表 文章目录数据结构与算法（二） 线性表第二章 线性表第一节 基本概念第二节 顺序结构 --- 数组实现2.1优缺点第三节 链式结构 --- 链表实现3.1 优缺点3.2 单向链表（1）结构体声明（2）测试链表是否为空（3）查找数据的位置（4）删除数据（5）插入数据3.3 双向链表3.4 循环链表3.4.1 单向循环链表：3.4.2 双向循环链表...
PTA第十章题目集合
CSDN_YJX的博客
04-08 4044
2-1 The value of expression *((int *)(p+1)+2) is D. static struct { int x, y[3]; } a[3] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}}, *p; p = a+1; (2分) A.3 B.7 C.10 D.11 实现代码： #include <stdio.h> #include <stdlib.h> #include<string.h> stati
两个多项式相乘 使用散列表加速 在计算时合并多项式的项
wwj_bupt
05-13 794
数据结构与算法分析——c语言描述 练习5.7 答案 使用散列表加速，O（1）时间找到相同的指数多项式进行合并，原来是一遍又一遍扫表链表找到相同指数的合并，复杂度为O（M^2*N^2）,现在为O（MN），由于散列表并不能比较大小之类的。所以要相乘后再遍历一遍散列表添加到链表（此时指数顺序是乱的）。没有排序。 头文件管理好麻烦，没有c++的命名空间，所以hash的position和list
有表头的链表的部分实现
atomer3的博客
06-27 182
有表头的链表的部分实现把事情做漂亮代码删除结点插入结点 把事情做漂亮 在链表中，插入和删除的操作需要对第一个结点特殊考虑，使得编程不便，容易出错，使用一个哑结点(dummy node)作为表头就可以解决这个问题。 代码 #ifndef _List_H struct Node; typedef struct Node *PtrToNode; typedef struct PtrToNode List...
c 打印二叉树_常见基本数据结构——树，二叉树，二叉查找树，AVL树
weixin_39609166的博客
11-21 138
常见数据结构——树处理大量的数据时，链表的线性时间太慢了，不宜使用。在树的数据结构中，其大部分的运行时间平均为O(logN)。并且通过对树结构的修改，我们能够保证它的最坏情形下上述的时间界。树的定义有很多种方式。定义树的自然的方式是递归的方式。一棵树是一些节点的集合，这个集合可以是空集，若非空集，则一棵树是由根节点r以及0个或多个非空子树T1,T2,T3,......,Tk组成，这些子树中每一棵的...
数据结构与算法分析--c语言描述(原书第二版)练习答案(第五章)
最新发布
01-25
数据结构与算法分析-C语言描述(原书第二版)是一本经典的计算机科学教材，它涵盖了数据结构和算法的基本概念和实现方法。下面是第五章的练习题答案： 1. 编写一个递归算法，计算一个整数n的阶乘。 ```c #include <stdio.h> int factorial(int n) { if (n == 0) { return 1; } else { return n * factorial(n-1); } } int main() { int n = 5; printf("Factorial of %d is %d\n", n, factorial(n)); return 0; } ``` 2. 编写一个递归算法，输出一个整数n的二进制表示。 ```c #include <stdio.h> void decimalToBinary(int n) { if (n > 0) { decimalToBinary(n / 2); printf("%d", n % 2); } } int main() { int n = 10; printf("Decimal %d is binary ", n); decimalToBinary(n); printf("\n"); return 0; } ``` 3. 编写一个非递归算法，求一个数组的最大值。 ```c #include <stdio.h> int findMax(int arr[], int size) { int max = arr[0]; for (int i = 1; i < size; i++) { if (arr[i] > max) { max = arr[i]; } } return max; } int main() { int arr[] = {2, 8, 4, 1, 6}; int size = sizeof(arr) / sizeof(arr[0]); printf("The maximum value in the array is %d\n", findMax(arr, size)); return 0; } ``` 4. 编写一个非递归算法，将一个字符串进行反转。 ```c #include <stdio.h> #include <string.h> void reverseString(char str[]) { int len = strlen(str); for (int i = 0, j = len - 1; i < len / 2; i++, j--) { char temp = str[i]; str[i] = str[j]; str[j] = temp; } } int main() { char str[] = "Hello World"; printf("Original string: %s\n", str); reverseString(str); printf("Reversed string: %s\n", str); return 0; } ``` 以上是第五章的练习题答案，希望对您有帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值