線性表完整代碼

順序存儲：

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


typedef int Position;
typedef int ElementType;
typedef struct LNode *PtrToLNode;

#define MAXSIZE 10

struct LNode{
    ElementType Data[MAXSIZE];
    Position Last;
};
typedef PtrToLNode List;

List MakeEmpty(){
    List P;
    P = (List)malloc(sizeof(struct LNode));
    P->Last = -1;
    return P;
}

bool Insert(List L,Position n,ElementType x){
    if(L->Last == MAXSIZE - 1)
    {
        printf("表滿");
        return false;
    }
    if(n<1 || n>L->Last+1+1){
        printf("位序不合法");
        return false;
    }
    for(int j = L->Last;j>=n-1;j--)
    {
        L->Data[j+1] = L->Data[j];
    }
    L->Data[n-1] = x;
    L->Last++;
    return true;
}

Position Find(List L,ElementType x){
    int j;
    for( j = 0;j<L->Last+1;j++)
    {
        if(x == L->Data[j])
        {    
            printf("查找的下表%d位序為：%d\n",L->Data[j],j+1);
            return 0;
        }
    }
    if(j >= L->Last)
    {
        printf("查找的不存在");
    }
    return 0;
        
}

bool Delete(List L,Position n){
        if(L->Last == MAXSIZE - 1)
    {
        printf("表滿");
        return false;
    }
    if(n<1 || n>L->Last+1){
        printf("位序不合法");
        return false;
    }
    for(int j = n-1;j<L->Last+1;j++)
    {
        L->Data[j] = L->Data[j+1];
    }
    L->Last--;
    return true;

}

int Length(List L){
    return L->Last+1;
} 

int Printf(List L){
    for(int i = 0 ; i<L->Last+1;i++)
        printf("%d  ",L->Data[i]);
    printf("\n");
    return 0;
}

int main(){
    List L;
    L = MakeEmpty();
    Insert(L,1,1);
    Insert(L,2,2);
    Insert(L,3,3);
    Insert(L,4,4);
    Printf(L);
    printf("表長：%d\n",Length(L));

    Find(L,4);
    printf("刪除一個\n");
    Delete(L,2);
    Printf(L);
    Find(L,4);

    printf("表長：%d\n",Length(L));

    Insert(L,2,2);
    Insert(L,3,33);
    Printf(L);
    Find(L,33);
    Find(L,4);;
    return 0;
}

 

 

 

 

 

 

線性表的鏈式存儲：

#include<stdio.h>
#include<stdlib.h>
typedef int ElementType;
typedef struct LNode * PtrToLNode;
struct LNode{
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;//這里的位置是結點的地址 
typedef PtrToLNode List; 
//初始化
List MakeEmpty(){
    List L;
    L = (List)malloc(sizeof (struct LNode));
    if (!L)
        exit (-1);
    L->Next = NULL;
    return L;
} 
 
//根據指定的位序查找
int FindKth(List L,int K){
    Position p;
    int cnt = 1;//位序從1開始 
    p = L->Next; 
    while(p&&cnt<K){
        p = p-> Next;
        cnt++;
    }
    if((cnt==K)&&p) printf("您查找的數為：%d\n",p -> Data);
    else printf("您查找數不存在");
}
 
//按值查找 
Position Find(List L,int X){
    Position p;
    p = L->Next; 
    while(p&&p->Data!=X){
        p = p-> Next;
    }
    if(p) printf("查找成功，您查找的數為：%d\n",p->Data);
    else printf("您查找數不存在");
}
 
//插入
List Insert(List L ,ElementType X,int i){
    Position tmp,pre;
    int cnt =0 ;
    pre = L;
    while(pre&&cnt<i-1){
        pre = pre->Next;
        cnt++;
    }
    if(pre==NULL||cnt!=i-1){
        printf("插入位置參數錯誤\n");
    }
    else{
        tmp = (Position)malloc(sizeof(struct LNode));
        tmp->Data=X;
        tmp->Next=pre->Next;
        pre->Next=tmp;
    }
    
} 
 
//刪除
bool Delete(List L,int i){
    Position tmp,pre;
    int cnt = 0;
    pre = L;
    while(pre&&cnt<i-1){
        pre=pre->Next;
        cnt++;
    }
    if(pre==NULL||cnt!=i-1||pre->Next==NULL){
        printf("刪除位置參數錯誤");
    }
    else{
        tmp = pre->Next;
        pre->Next = tmp->Next;
        free(tmp);
        printf("刪除成功"); 
    }
} 
 
//求表長
int Length(List L){
    Position p;
    int cnt = 0;
    p = L->Next;
    while(p){
        p = p -> Next;
        cnt++;
    }
    return cnt;
} 
 
void DisLinkList(List L)
{
    List p = L->Next;
    printf("輸出鏈表： "); 
    while (p)
    {
        printf("%d ", p->Data);
        p = p->Next;
    }
}
 
int main(){
    Position pre;
    Position L = MakeEmpty();
    pre = L;
    int i,n,x,len,cz,del;
    //插入 
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        scanf("%d",&x);
        Insert(pre,x,i);
    }
    //輸出 
    DisLinkList(pre);
    printf("\n");
    //求表長 
    len = Length(L);
    printf("表長為：%d",len);
    printf("\n");
    //按值查找
    printf("請輸入你要按值查找的數：\n");
    scanf("%d",&cz);
    Find(L,cz);
    printf("\n");
    //按序號查找
    printf("請輸入你要按序號查找的數的序號：\n");
    scanf("%d",&cz);
    FindKth(L,cz);
    printf("\n");
    //刪除
    printf("請輸入你要刪除的數的下標：\n",del);
    scanf("%d",&del);
    Delete(L,del);
    DisLinkList(pre);
    printf("\n");
    return 0;
}

 

 

線性表鏈式存儲二：

 

 

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


typedef int ElementType;
typedef struct LNode *PtrToLNode;


struct LNode{
    ElementType Data;
    PtrToLNode next;
};

typedef PtrToLNode List;
typedef List Position;
List MakeEmpty(){
    PtrToLNode L;
    L = (List)malloc(sizeof(struct LNode));
    if(!L)
        exit(-1);
    L->next = NULL;
    return L;

};

bool Insert(List L,int i,ElementType x ){
    Position tmp,pre;
    int cnt = 0;
    pre = L;

    while(pre && cnt < i - 1){
        pre = pre->next;
        cnt++;
    }
    
    if(pre == NULL || cnt!=i-1){
        printf("插入位置不合法\n");
        return false;
    
    }
    else{
        tmp = (List)malloc(sizeof(struct LNode));
        tmp->Data = x;
        tmp->next = pre->next;
        pre->next = tmp;
        printf("插入完成\n");
    }
    return true;
}

void Find(List L,ElementType x){
    Position pre;
    int cnt = 0;
    pre = L->next;
    while(pre!=NULL && pre->Data != x)
    {
        pre = pre->next;
        cnt++;
    }
    if(pre)
    {
        printf("%d的位序為%d\n",pre->Data,cnt);
    }
    else{
        printf("%d沒有找到\n",x);
    }
}

void FindKth(List L,int k){
    Position pre;
    pre = L->next;
    int cnt = 0;
    while(pre && cnt <k-1){
        pre = pre->next;
        cnt++;
    }
    if(k-1 == cnt)
        printf("在%d位置的為%d\n",k,pre->Data);
    else
        printf("位序不合法\n");
}

bool Delete(List L,ElementType x){
    Position pre,tmp,tmp1;
    pre = L->next;
    while(pre && pre->Data != x){
        tmp = pre;
        pre = pre->next;
        
    }
    if(pre){
        tmp1 = pre;
        tmp->next = tmp1->next;
        free(tmp1);
        printf("刪除%d成功\n",x);    
        return true;
    }
    else{
        printf("沒有找到%d\n",x);
        return false;
    }
}
bool DeleteKth(List L,int l){
    Position pre,tmp;
    int cnt = 0;
    pre = L;

    while(pre && cnt < l - 1 ){
        pre = pre->next;
        cnt++;
    }
    if(pre ==NULL || cnt != l - 1 || pre->next == NULL){
        printf("刪除位置錯誤\n");
        return false;
    }else{
        tmp = pre ->next;
        pre ->next = pre->next->next;
        
        printf("在位置%d刪除%d成功\n",l,tmp->Data);
        free(tmp);
        return true;
    }


}

void Length(List L){
    Position p;
    int cnt = 0;
    p = L->next;
    while(p){
        p = p -> next;
        cnt++;
    }
    printf("長度為：%d\n",cnt); 
} 

void Print(List L){
    Position pre;
    pre = L->next;
    while(pre){
        printf("%d ",pre->Data);
        pre =pre->next;
    }
    printf("\n");
}

int main(){
    PtrToLNode L;
    L = MakeEmpty();
    Insert(L,22,22);
    Insert(L,1,1);
    Insert(L,2,2);
    Print(L);
    Find(L,2);
    FindKth(L,1);
    Find(L,33);
    Insert(L,3,3);
    Insert(L,4,4);
    Insert(L,4,41);
    Print(L);
    Delete(L,4);
    DeleteKth(L,3);
    Print(L);
    Length(L);
    return 0;

}

 

 

 

多項式的加法運算：

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

typedef struct PolyNode *Polynomial;
struct PolyNode{
    int coef;//系數
    int expon;//指數 
    Polynomial link;//鏈表指針域指向下一地址 
};

Polynomial ReadPoly();//讀入多項式
void Attach(int c,int e,Polynomial *pRear);//將每次讀入的多項式連接 
Polynomial Add(Polynomial P1,Polynomial P2);//多項式相加 
Polynomial Mult(Polynomial P1,Polynomial P2);//多項式相乘 
int Compare(int a,int b);//比較 
void PrintPoly(Polynomial P);//輸出多項式 


int main(void)
{
    Polynomial P1,P2,PS,PP;
    
    P1=ReadPoly();//讀入數據
    P2=ReadPoly();
    
    PP=Mult(P1,P2);//多項式相乘 
    PrintPoly(PP);
    
    printf("\n");
    
    PS=Add(P1,P2);//多項式相加 
    PrintPoly(PS);
    
    return 0;
}


Polynomial ReadPoly()//讀入數據 
{
    Polynomial P,Rear,t;
    int c,e,N; 
    scanf("%d",&N);
    P=(Polynomial)malloc(sizeof(struct PolyNode));//為方便表頭插入，先產生一個臨時空節點做為鏈表頭
    P->link =NULL;
    Rear=P;//Rear始終指向鏈表的尾部
    while(N--)
    {
        
        scanf("%d %d",&c,&e);
        if(c!=0)//對系數為零的項進行判斷 
        Attach(c,e,&Rear);
    }
    t=P;//釋放表頭為空的節點 
    P=P->link;
    free(t);
    return P;
}


void Attach(int c,int e,Polynomial *pRear)//將數據連接成鏈表 
{
    Polynomial P;
    P=(Polynomial)malloc(sizeof(struct PolyNode));//為方便表頭插入，先產生一個臨時空節點做為鏈表頭
    P->coef=c;
    P->expon=e;
    P->link =NULL;
    (*pRear)->link=P;//將P指向的新節點插入到當前結果表達式尾項的后面
    *pRear=P;//最后一項指向P
}

int Compare(int a,int b)//比較 ，a>b return 1，a<b return -1, a==b return 0 
{
    if(a>b)
    return 1;
    else if(a==b)
    return 0;
    else
    return -1;
}

Polynomial Add(Polynomial P1,Polynomial P2)//多項式相加 
{
    Polynomial front,rear,temp;//front為頭，Rear為尾
    int sum;
    rear=(Polynomial)malloc(sizeof(struct PolyNode));//為方便表頭插入，先產生一個臨時空節點做為鏈表頭
    front=rear;
    while(P1&&P2)
        switch(Compare(P1->expon ,P2->expon))
        {
            case 1://如果P1->expon>P2->expon
                Attach(P1->coef,P1->expon,&rear);
                P1=P1->link ;
                break;
            case -1://如果P1->expon<P2->expon
                Attach(P2->coef,P2->expon,&rear);
                P2=P2->link ;
                break;
            case 0://如果P1->expon=P2->expon
                sum=P1->coef +P2->coef;
                if(sum)//如果指數相等，先判斷系數和是否為0 
                Attach(sum,P1->expon,&rear);
                P1=P1->link;
                P2=P2->link ;
                break;
        }
        //將未處理完的多項式中所有節點復制到結果多項式中
        while(P1)
        {
            Attach(P1->coef,P1->expon,&rear);
            P1=P1->link;
        }
        while(P2)
        {
            Attach(P2->coef,P2->expon,&rear);
            P2=P2->link;
        }

        rear->link=NULL;//釋放頭為空的節點 
        temp=front;
        front=front->link ;
        free(temp);
        return front;
}

void PrintPoly(Polynomial P)//打印 
{
    int flag=0;
    if(!P)
    {
        printf("0 0");
        return ;
    }
    
    while(P)
    {
        if(!flag)
            flag=1;
        else
            printf(" ");
        printf("%d %d",P->coef ,P->expon );
        P=P->link ;
    }
}

Polynomial Mult(Polynomial P1, Polynomial P2)//多項式相乘 
{
    Polynomial P, Rear;
    Polynomial t1, t2, t;
    if (!P1 ||!P2)//判斷兩個鏈表是否為空
    {
        return NULL;

    }
    t1 = P1;
    t2 = P2;
    P = (Polynomial)malloc(sizeof(struct PolyNode));
    Rear = P;
    while (t2)//先讓t1的第一項和t2的每一項相乘，構建出一個新鏈表，用於后來數據的插入
    {
        Attach(t1->coef*t2->coef, t1->expon + t2->expon, &Rear);
        t2 = t2->link;
    }
    t1 = t1->link;

    while (t1)
    {
        t2 = P2;
        Rear = P;//Rear每次都從所構建的鏈表頭開始，以便於尋找插入位置 
        while (t2) 
        {
            int c = t1->coef*t2->coef;
            int e = t1->expon + t2->expon;
            while (Rear->link&&Rear->link->expon > e)//Rear每次都從所構建的鏈表頭開始，以便於尋找插入位置 
            {
                Rear = Rear->link;
            }
            if (Rear->link&&Rear->link->expon == e)//相等就不需要申請一個新的節點，只要把系數相加。
            {
                if (Rear->link->coef + c)//系數和不為0，
                {
                    Rear->link->coef += c;
                }
                else//系數和為0，刪除節點
                {
                    t = Rear->link;
                    Rear->link = t->link;
                    free(t);
                }
            }
            else//如果指數不相等，申請空間將將此項插入
            {
                t = (Polynomial)malloc(sizeof(struct PolyNode));
                t->link = NULL;
                t->coef = c;
                t->expon = e;
                t->link = Rear->link;
                Rear->link = t;

                Rear = Rear->link;
            }
            t2 = t2->link;
        }
        t1 = t1->link;
    }
    t2 = P;//釋放空節點 
    P = P->link;
    free(t2);

    return P;
}