重學數據結構(一)：鏈表基本操做與一元多項式相加

時間  2019-11-09
標籤 數據 結構 鏈表 基本 一元 1元 多項式 相加 简体版
原文   原文鏈接

1.鏈表的基本操做數組

    鏈表數據結構的定義：因爲鏈表一方面須要在節點中存儲數據，另外一方面還須要存儲"線索"，所以，一般採用結構體定義鏈表節點數據類型。數據結構

struct Node; 
typedef struct Node *PtrToNode; 
typedef PtrToNode List; 
typedef PtrToNode Position; 
typedef int ElementType; 
struct Node  
{ 
    ElementType Element; 
    Position Next; 
};

    鏈表的操做不算太多，下面是一些經常使用的操做：函數

//建立鏈表 
List CreateList(); 
//遍歷鏈表 
void TraverseList(List L); 
//清空鏈表 
List MakeEmpty(List L); 
//判斷給定列表是否爲空 
int IsEmpty(List L); 
//判斷節點在給定鏈表中是否爲空 
int IsLast(Position P, List L); 
//在指定的鏈表中查找給定元素。 
//存在則返回其第一次出現的位置，不存在則返回NULL 
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 Retrive(Position P);

    下面是實現基本操做以及簡單使用的一個完整的例子：spa

#include <stdio.h> 
#include <stdlib.h> 
 
struct Node; 
typedef struct Node *PtrToNode; 
typedef PtrToNode List; 
typedef PtrToNode Position; 
typedef int ElementType; 
struct Node  
{ 
    ElementType Element; 
    Position Next; 
}; 
 
//建立鏈表 
List CreateList(); 
//遍歷鏈表 
void TraverseList(List L); 
//清空鏈表 
List MakeEmpty(List L); 
//判斷給定列表是否爲空 
int IsEmpty(List L); 
//判斷節點在給定鏈表中是否爲空 
int IsLast(Position P, List L); 
//在指定的鏈表中查找給定元素。 
//存在則返回其第一次出現的位置，不存在則返回NULL 
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 Retrive(Position P); 
 
int IsEmpty(List L) 
{ 
     
    return L->Next == NULL; 
} 
 
int IsLast(Position P, List L) 
{ 
    return P->Next == NULL; 
} 
 
Position Find(ElementType X, List L) 
{ 
    Position P = L->Next; 
    while(P != NULL && P->Element != X) 
    { 
        P = P->Next; 
    } 
    return P; 
} 
 
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); 
    } 
} 
 
Position FindPrevious(ElementType X, List L) 
{ 
    Position P = L; 
    while(P->Next != NULL && P->Next->Element != X) 
    { 
        P = P->Next; 
    } 
    return P; 
} 
 
void Insert(ElementType X, List L, Position P) 
{ 
    Position TmpCell; 
    TmpCell = malloc(sizeof(struct Node)); 
    if(TmpCell == NULL) 
    { 
        printf("Out of space!\n"); 
        return; 
    } 
    TmpCell->Element = X; 
    TmpCell->Next = P->Next; 
    P->Next = TmpCell; 
} 
 
void DeleteList(List L) 
{ 
    Position P,Tmp; 
    P = L->Next; 
    L->Next = NULL; 
    while(P != NULL) 
    { 
        Tmp = P->Next; 
        free(P); 
        P = Tmp; 
    } 
} 
 
Position Header(List L) 
{ 
    return L; 
} 
 
Position First(List L) 
{ 
    return L->Next; 
} 
 
Position Advance(Position P) 
{ 
    return P->Next; 
} 
 
ElementType Retrive(Position P) 
{ 
    return P->Element; 
} 
 
List CreateList() 
{ 
    int i; 
    Position P,Tmp; 
    List L = malloc(sizeof(struct Node)); 
    P = L; 
    for(i = 0; i < 5; i++) 
    { 
        Tmp = malloc(sizeof(struct Node)); 
        Tmp->Element = i; 
        P->Next = Tmp; 
        P = Tmp;         
    } 
    P->Next = NULL; 
    return L; 
} 
 
void TraverseList(List L) 
{ 
    Position P; 
    P = L->Next; 
    while(P != NULL) 
    { 
        printf("%d\n",P->Element);   
        P = P->Next; 
    } 
} 
 
int main(void) 
{ 
    //建立鏈表 
    List L = CreateList(); 
    //查找元素1在鏈表中的位置 
    Position P = Find(1,L); 
    //在元素1後面插入元素8 
    Insert(8,L,P); 
    //查找元素8前驅結點 
    P = FindPrevious(8,L); 
    //遍歷鏈表 
    TraverseList(L); 
    return 0; 
}

2.一元N次多項式相加code

    對於兩個一元多項式，若是須要對他們進行多項式相加操做，常見的兩種思路以下：(1)對於一個多項式，保存其最高項次數HighPowder，以及一個該多項式對應次數分別爲0-HighPowder的各項的係數的數組()。(2)多項式中係數不爲零的每一項，保存其係數與該項的次數。下面分別用這兩種思路實現一元多項式加法操做。it

思路一：io

    數據結構定義：ast

typedef struct Poly 
{ 
    int CoeffArray[11]; 
    int HighPower; 
} *Polynomial;

    實現代碼：class

#include <stdio.h> 
#include <stdlib.h> 
 
typedef struct Poly 
{ 
    int CoeffArray[11]; 
    int HighPower; 
} *Polynomial; 
 
void ZeroPolynomial(Polynomial Poly) 
{ 
    int i; 
    for(i = 0; i < 11; i++) 
    { 
        Poly->CoeffArray[i] = 0; 
    } 
    Poly->HighPower = 0; 
} 
 
void AddPolynomial(Polynomial Poly1,Polynomial Poly2, Polynomial PolySum) 
{ 
    int i; 
    ZeroPolynomial(PolySum); 
    PolySum->HighPower = Poly1->HighPower > Poly2->HighPower? 
        Poly1->HighPower:Poly2->HighPower; 
    for(i = PolySum->HighPower; i >= 0 ; i--) 
    { 
        PolySum->CoeffArray[i] = Poly1->CoeffArray[i] + Poly2->CoeffArray[i]; 
    } 
} 
 
int main(void) 
{ 
    int i,j,k; 
    Polynomial P1,P2,Sum; 
    P1 = malloc(sizeof(struct Poly)); 
    P2 = malloc(sizeof(struct Poly)); 
    Sum = malloc(sizeof(struct Poly)); 
    //初始化 
    ZeroPolynomial(P1); 
    ZeroPolynomial(P2); 
    P1->HighPower = 10; 
    for(i = 10; i >= 0; i--) 
    { 
        P1->CoeffArray[i] = i; 
    } 
     
    P2->HighPower = 8; 
    for(j = 8; j >=0; j--) 
    { 
        P2->CoeffArray[j] = j; 
    } 
    P2->CoeffArray[8] = 8; 
    AddPolynomial(P1,P2,Sum); 
 
    printf("The high power of the Polynomial is %d\n",Sum->HighPower); 
    for(k = 0; k <= 10; k++) 
    { 
        printf("The Coeff of power %d is %d\n",k,Sum->CoeffArray[k]); 
    } 
 
    return 0; 
}

思路二：dva

    數據結構：

typedef struct PolyNode *PtrToNode; 
 
//定義鏈表節點，也就是多項式中的某一項； 
typedef struct PolyNode 
{ 
    int Coeff; 
    int Exponent; 
    PtrToNode Next; 
} PolyNode;

   實現代碼：

#include <stdio.h> 
#include <stdlib.h> 
 
typedef struct PolyNode *PtrToNode; 
 
//定義鏈表節點，也就是多項式中的某一項； 
typedef struct PolyNode 
{ 
    int Coeff; 
    int Exponent; 
    PtrToNode Next; 
} PolyNode; 
 
 
typedef PtrToNode Polynomial; 
 
/************************************************************ 
*多項式相加的函數: 
*P、Q爲存儲兩個多項式各項的單鏈表(含頭結點) 
*Sum爲多項式相加結果存放的單鏈表 
* 
************************************************************/ 
void AddPolynomial(Polynomial P,Polynomial Q,Polynomial Sum) 
{ 
    Polynomial PIndex,QIndex,SumIndex; 
    PIndex = P->Next; 
    QIndex = Q->Next; 
    SumIndex = Sum; 
    while(!(PIndex == NULL && QIndex == NULL)) 
    { 
        if(PIndex==NULL) 
        { 
            SumIndex->Next = QIndex; 
            QIndex = QIndex->Next; 
            SumIndex = SumIndex->Next; 
        } 
        else if(QIndex == NULL) 
        { 
            SumIndex->Next = PIndex; 
            PIndex = PIndex->Next; 
            SumIndex = SumIndex->Next; 
        } 
        else 
        { 
            if(PIndex->Exponent > QIndex->Exponent) 
            { 
                SumIndex->Next = PIndex; 
                PIndex = PIndex->Next; 
                SumIndex = SumIndex->Next; 
                //continue在判斷下面if條件時會有異常，相似Java 
                //的空引用異常 
                continue; 
            } 
            if(PIndex->Exponent == QIndex->Exponent) 
            { 
                Polynomial PP = malloc(sizeof(struct PolyNode)); 
                PP->Exponent = PIndex->Exponent; 
                PP->Coeff = PIndex->Coeff + QIndex->Coeff; 
                SumIndex->Next = PP; 
                PIndex = PIndex->Next; 
                QIndex = QIndex->Next; 
                SumIndex = SumIndex->Next; 
                continue; 
            } 
            if(PIndex->Exponent < QIndex->Exponent) 
            { 
                SumIndex->Next = QIndex; 
                QIndex = QIndex->Next; 
                SumIndex = SumIndex->Next; 
                continue; 
            } 
        } 
    } 
    SumIndex->Next = NULL; 
} 
 
/************************************************************ 
*遍歷單鏈表(含頭結點)函數: 
*P：待遍歷的鏈表 
*************************************************************/ 
void TraversePolynomial(Polynomial P) 
{ 
    Polynomial Tmp = P->Next; 
    while(Tmp != NULL) 
    { 
        printf("Coeff is %d and Exponent is %d\n",Tmp->Coeff,Tmp->Exponent); 
        Tmp = Tmp->Next; 
    } 
} 
 
 
 
int main(void) 
{ 
    Polynomial Poly1,Poly2,Poly3,Poly11,Poly22; 
    int i,j; 
    Poly1 = malloc(sizeof(struct PolyNode)); 
    Poly2 = malloc(sizeof(struct PolyNode)); 
    Poly3 = malloc(sizeof(struct PolyNode)); 
    Poly11 = Poly1; 
    Poly22 = Poly2; 
 
    //建立兩個鏈表時，須要保證是按照指數遞減的方式構造的 
    for(i = 5;i >= 1;i--) 
    { 
        Polynomial Tmp  = malloc(sizeof(struct PolyNode)); 
        Tmp->Coeff = i; 
        Tmp->Exponent = i; 
        Poly11->Next = Tmp; 
        Poly11 = Poly11->Next; 
    } 
    Poly11->Next = NULL; 
    for(j = 11;j >= 3;j--) 
    { 
        Polynomial Tmp  = malloc(sizeof(struct PolyNode)); 
        Tmp->Coeff = j; 
        Tmp->Exponent = j; 
        Poly22->Next = Tmp; 
        Poly22 = Poly22->Next; 
    } 
    Poly22->Next = NULL; 
    TraversePolynomial(Poly1); 
    printf("*****************************************\n"); 
    TraversePolynomial(Poly2); 
    AddPolynomial(Poly1,Poly2,Poly3); 
    printf("*****************************************\n"); 
    TraversePolynomial(Poly3); 
    return 0; 
}


參考書目：

《Data Structure and Algorithm Analysis in C》

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程