重学数据结构001——链表基本操作与一元多项式相加

最新推荐文章于 2021-10-12 16:47:56 发布
最新推荐文章于 2021-10-12 16:47:56 发布
阅读量925 收藏
点赞数
分类专栏： C语言 数据结构 文章标签： 数据结构 null 存储 insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wawlian/article/details/6973093
版权

1.链表的基本操作

        链表数据结构的定义：由于链表一方面需要在节点中存储数据，另一方面还需要存储"线索"，因此，通常采用结构体定义链表节点数据类型。

 

 
 
  1. struct Node; 
  2. typedef struct Node *PtrToNode; 
  3. typedef PtrToNode List; 
  4. typedef PtrToNode Position; 
  5. typedef int ElementType; 
  6. struct Node  
  7. { 
  8.     ElementType Element; 
  9.     Position Next; 
  10. }; 

        链表的操作不算太多，下面是一些常用的操作：

 

 
 
  1. //创建链表 
  2. List CreateList(); 
  3. //遍历链表 
  4. void TraverseList(List L); 
  5. //清空链表 
  6. List MakeEmpty(List L); 
  7. //判断给定列表是否为空 
  8. int IsEmpty(List L); 
  9. //判断节点在给定链表中是否为空 
  10. int IsLast(Position P, List L); 
  11. //在指定的链表中查找给定元素。 
  12. //存在则返回其第一次出现的位置，不存在则返回NULL 
  13. Position Find(ElementType X, List L); 
  14. //删除链表中的某个元素 
  15. void Delete(ElementType X, List L); 
  16. //在指定链表中查找给定元素的前驱节点 
  17. Position FindPrevious(ElementType X, List L); 
  18. //在链表给定位置的后面插入元素 
  19. void Insert(ElementType X, List L, Position P); 
  20. //删除链表 
  21. void DeleteList(List L); 
  22. //返回链表的头结点 
  23. Position Header(List L); 
  24. //返回链表第一个数据元素节点 
  25. Position First(List L); 
  26. //返回当前位置的下一个位置 
  27. Position Advance(Position P); 
  28. //获取当前位置元素的值 
  29. ElementType Retrive(Position P); 

        下面是实现基本操作以及简单使用的一个完整的例子：

 

 
 
  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3.  
  4. struct Node; 
  5. typedef struct Node *PtrToNode; 
  6. typedef PtrToNode List; 
  7. typedef PtrToNode Position; 
  8. typedef int ElementType; 
  9. struct Node  
  10. { 
  11.     ElementType Element; 
  12.     Position Next; 
  13. }; 
  14.  
  15. //创建链表 
  16. List CreateList(); 
  17. //遍历链表 
  18. void TraverseList(List L); 
  19. //清空链表 
  20. List MakeEmpty(List L); 
  21. //判断给定列表是否为空 
  22. int IsEmpty(List L); 
  23. //判断节点在给定链表中是否为空 
  24. int IsLast(Position P, List L); 
  25. //在指定的链表中查找给定元素。 
  26. //存在则返回其第一次出现的位置，不存在则返回NULL 
  27. Position Find(ElementType X, List L); 
  28. //删除链表中的某个元素 
  29. void Delete(ElementType X, List L); 
  30. //在指定链表中查找给定元素的前驱节点 
  31. Position FindPrevious(ElementType X, List L); 
  32. //在链表给定位置的后面插入元素 
  33. void Insert(ElementType X, List L, Position P); 
  34. //删除链表 
  35. void DeleteList(List L); 
  36. //返回链表的头结点 
  37. Position Header(List L); 
  38. //返回链表第一个数据元素节点 
  39. Position First(List L); 
  40. //返回当前位置的下一个位置 
  41. Position Advance(Position P); 
  42. //获取当前位置元素的值 
  43. ElementType Retrive(Position P); 
  44.  
  45. int IsEmpty(List L) 
  46. { 
  47.      
  48.     return L->Next == NULL; 
  49. } 
  50.  
  51. int IsLast(Position P, List L) 
  52. { 
  53.     return P->Next == NULL; 
  54. } 
  55.  
  56. Position Find(ElementType X, List L) 
  57. { 
  58.     Position P = L->Next; 
  59.     while(P != NULL && P->Element != X) 
  60.     { 
  61.         P = P->Next; 
  62.     } 
  63.     return P; 
  64. } 
  65.  
  66. void Delete(ElementType X, List L) 
  67. { 
  68.     Position P,TmpCell; 
  69.     P = FindPrevious(X,L);   
  70.     if(!IsLast(P,L)) 
  71.     { 
  72.         TmpCell = P->Next; 
  73.         P->Next = TmpCell->Next; 
  74.         free(TmpCell); 
  75.     } 
  76. } 
  77.  
  78. Position FindPrevious(ElementType X, List L) 
  79. { 
  80.     Position P = L; 
  81.     while(P->Next != NULL && P->Next->Element != X) 
  82.     { 
  83.         P = P->Next; 
  84.     } 
  85.     return P; 
  86. } 
  87.  
  88. void Insert(ElementType X, List L, Position P) 
  89. { 
  90.     Position TmpCell; 
  91.     TmpCell = malloc(sizeof(struct Node)); 
  92.     if(TmpCell == NULL) 
  93.     { 
  94.         printf("Out of space!\n"); 
  95.         return; 
  96.     } 
  97.     TmpCell->Element = X; 
  98.     TmpCell->Next = P->Next; 
  99.     P->Next = TmpCell; 
  100. } 
  101.  
  102. void DeleteList(List L) 
  103. { 
  104.     Position P,Tmp; 
  105.     P = L->Next; 
  106.     L->Next = NULL; 
  107.     while(P != NULL) 
  108.     { 
  109.         Tmp = P->Next; 
  110.         free(P); 
  111.         P = Tmp; 
  112.     } 
  113. } 
  114.  
  115. Position Header(List L) 
  116. { 
  117.     return L; 
  118. } 
  119.  
  120. Position First(List L) 
  121. { 
  122.     return L->Next; 
  123. } 
  124.  
  125. Position Advance(Position P) 
  126. { 
  127.     return P->Next; 
  128. } 
  129.  
  130. ElementType Retrive(Position P) 
  131. { 
  132.     return P->Element; 
  133. } 
  134.  
  135. List CreateList() 
  136. { 
  137.     int i; 
  138.     Position P,Tmp; 
  139.     List L = malloc(sizeof(struct Node)); 
  140.     P = L; 
  141.     for(i = 0; i < 5; i++) 
  142.     { 
  143.         Tmp = malloc(sizeof(struct Node)); 
  144.         Tmp->Element = i; 
  145.         P->Next = Tmp; 
  146.         P = Tmp;         
  147.     } 
  148.     P->Next = NULL; 
  149.     return L; 
  150. } 
  151.  
  152. void TraverseList(List L) 
  153. { 
  154.     Position P; 
  155.     P = L->Next; 
  156.     while(P != NULL) 
  157.     { 
  158.         printf("%d\n",P->Element);   
  159.         P = P->Next; 
  160.     } 
  161. } 
  162.  
  163. int main(void) 
  164. { 
  165.     //创建链表 
  166.     List L = CreateList(); 
  167.     //查找元素1在链表中的位置 
  168.     Position P = Find(1,L); 
  169.     //在元素1后面插入元素8 
  170.     Insert(8,L,P); 
  171.     //查找元素8前驱结点 
  172.     P = FindPrevious(8,L); 
  173.     //遍历链表 
  174.     TraverseList(L); 
  175.     return 0; 
  176. } 

2.一元N次多项式相加

        对于两个一元多项式，如果需要对他们进行多项式相加操作，常见的两种思路如下：(1)对于一个多项式，保存其最高项次数HighPowder，以及一个该多项式对应次数分别为0-HighPowder的各项的系数的数组()。(2)多项式中系数不为零的每一项，保存其系数与该项的次数。下面分别用这两种思路实现一元多项式加法操作。

思路一：

数据结构定义：

 

 
 
  1. typedef struct Poly 
  2. { 
  3.     int CoeffArray[11]; 
  4.     int HighPower; 
  5. } *Polynomial; 

实现代码：

 

 
 
  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3.  
  4. typedef struct Poly 
  5. { 
  6.     int CoeffArray[11]; 
  7.     int HighPower; 
  8. } *Polynomial; 
  9.  
  10. void ZeroPolynomial(Polynomial Poly) 
  11. { 
  12.     int i; 
  13.     for(i = 0; i < 11; i++) 
  14.     { 
  15.         Poly->CoeffArray[i] = 0; 
  16.     } 
  17.     Poly->HighPower = 0; 
  18. } 
  19.  
  20. void AddPolynomial(Polynomial Poly1,Polynomial Poly2, Polynomial PolySum) 
  21. { 
  22.     int i; 
  23.     ZeroPolynomial(PolySum); 
  24.     PolySum->HighPower = Poly1->HighPower > Poly2->HighPower? 
  25.         Poly1->HighPower:Poly2->HighPower; 
  26.     for(i = PolySum->HighPower; i >= 0 ; i--) 
  27.     { 
  28.         PolySum->CoeffArray[i] = Poly1->CoeffArray[i] + Poly2->CoeffArray[i]; 
  29.     } 
  30. } 
  31.  
  32. int main(void) 
  33. { 
  34.     int i,j,k; 
  35.     Polynomial P1,P2,Sum; 
  36.     P1 = malloc(sizeof(struct Poly)); 
  37.     P2 = malloc(sizeof(struct Poly)); 
  38.     Sum = malloc(sizeof(struct Poly)); 
  39.     //初始化 
  40.     ZeroPolynomial(P1); 
  41.     ZeroPolynomial(P2); 
  42.     P1->HighPower = 10; 
  43.     for(i = 10; i >= 0; i--) 
  44.     { 
  45.         P1->CoeffArray[i] = i; 
  46.     } 
  47.      
  48.     P2->HighPower = 8; 
  49.     for(j = 8; j >=0; j--) 
  50.     { 
  51.         P2->CoeffArray[j] = j; 
  52.     } 
  53.     P2->CoeffArray[8] = 8; 
  54.     AddPolynomial(P1,P2,Sum); 
  55.  
  56.     printf("The high power of the Polynomial is %d\n",Sum->HighPower); 
  57.     for(k = 0; k <= 10; k++) 
  58.     { 
  59.         printf("The Coeff of power %d is %d\n",k,Sum->CoeffArray[k]); 
  60.     } 
  61.  
  62.     return 0; 
  63. } 

思路二：

数据结构：

 

 
 
  1. typedef struct PolyNode *PtrToNode; 
  2.  
  3. //定义链表节点，也就是多项式中的某一项； 
  4. typedef struct PolyNode 
  5. { 
  6.     int Coeff; 
  7.     int Exponent; 
  8.     PtrToNode Next; 
  9. } PolyNode; 

实现代码：

 

 
 
  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3.  
  4. typedef struct PolyNode *PtrToNode; 
  5.  
  6. //定义链表节点，也就是多项式中的某一项； 
  7. typedef struct PolyNode 
  8. { 
  9.     int Coeff; 
  10.     int Exponent; 
  11.     PtrToNode Next; 
  12. } PolyNode; 
  13.  
  14.  
  15. typedef PtrToNode Polynomial; 
  16.  
  17. /************************************************************ 
  18. *多项式相加的函数: 
  19. *P、Q为存储两个多项式各项的单链表(含头结点) 
  20. *Sum为多项式相加结果存放的单链表 
  21. * 
  22. ************************************************************/ 
  23. void AddPolynomial(Polynomial P,Polynomial Q,Polynomial Sum) 
  24. { 
  25.     Polynomial PIndex,QIndex,SumIndex; 
  26.     PIndex = P->Next; 
  27.     QIndex = Q->Next; 
  28.     SumIndex = Sum; 
  29.     while(!(PIndex == NULL && QIndex == NULL)) 
  30.     { 
  31.         if(PIndex==NULL) 
  32.         { 
  33.             SumIndex->Next = QIndex; 
  34.             QIndex = QIndex->Next; 
  35.             SumIndex = SumIndex->Next; 
  36.         } 
  37.         else if(QIndex == NULL) 
  38.         { 
  39.             SumIndex->Next = PIndex; 
  40.             PIndex = PIndex->Next; 
  41.             SumIndex = SumIndex->Next; 
  42.         } 
  43.         else 
  44.         { 
  45.             if(PIndex->Exponent > QIndex->Exponent) 
  46.             { 
  47.                 SumIndex->Next = PIndex; 
  48.                 PIndex = PIndex->Next; 
  49.                 SumIndex = SumIndex->Next; 
  50.                 //continue在判断下面if条件时会有异常，类似Java 
  51.                 //的空引用异常 
  52.                 continue; 
  53.             } 
  54.             if(PIndex->Exponent == QIndex->Exponent) 
  55.             { 
  56.                 Polynomial PP = malloc(sizeof(struct PolyNode)); 
  57.                 PP->Exponent = PIndex->Exponent; 
  58.                 PP->Coeff = PIndex->Coeff + QIndex->Coeff; 
  59.                 SumIndex->Next = PP; 
  60.                 PIndex = PIndex->Next; 
  61.                 QIndex = QIndex->Next; 
  62.                 SumIndex = SumIndex->Next; 
  63.                 continue; 
  64.             } 
  65.             if(PIndex->Exponent < QIndex->Exponent) 
  66.             { 
  67.                 SumIndex->Next = QIndex; 
  68.                 QIndex = QIndex->Next; 
  69.                 SumIndex = SumIndex->Next; 
  70.                 continue; 
  71.             } 
  72.         } 
  73.     } 
  74.     SumIndex->Next = NULL; 
  75. } 
  76.  
  77. /************************************************************ 
  78. *遍历单链表(含头结点)函数: 
  79. *P：待遍历的链表 
  80. *************************************************************/ 
  81. void TraversePolynomial(Polynomial P) 
  82. { 
  83.     Polynomial Tmp = P->Next; 
  84.     while(Tmp != NULL) 
  85.     { 
  86.         printf("Coeff is %d and Exponent is %d\n",Tmp->Coeff,Tmp->Exponent); 
  87.         Tmp = Tmp->Next; 
  88.     } 
  89. } 
  90.  
  91.  
  92.  
  93. int main(void) 
  94. { 
  95.     Polynomial Poly1,Poly2,Poly3,Poly11,Poly22; 
  96.     int i,j; 
  97.     Poly1 = malloc(sizeof(struct PolyNode)); 
  98.     Poly2 = malloc(sizeof(struct PolyNode)); 
  99.     Poly3 = malloc(sizeof(struct PolyNode)); 
  100.     Poly11 = Poly1; 
  101.     Poly22 = Poly2; 
  102.  
  103.     //创建两个链表时，需要保证是按照指数递减的方式构造的 
  104.     for(i = 5;i >= 1;i--) 
  105.     { 
  106.         Polynomial Tmp  = malloc(sizeof(struct PolyNode)); 
  107.         Tmp->Coeff = i; 
  108.         Tmp->Exponent = i; 
  109.         Poly11->Next = Tmp; 
  110.         Poly11 = Poly11->Next; 
  111.     } 
  112.     Poly11->Next = NULL; 
  113.     for(j = 11;j >= 3;j--) 
  114.     { 
  115.         Polynomial Tmp  = malloc(sizeof(struct PolyNode)); 
  116.         Tmp->Coeff = j; 
  117.         Tmp->Exponent = j; 
  118.         Poly22->Next = Tmp; 
  119.         Poly22 = Poly22->Next; 
  120.     } 
  121.     Poly22->Next = NULL; 
  122.     TraversePolynomial(Poly1); 
  123.     printf("*****************************************\n"); 
  124.     TraversePolynomial(Poly2); 
  125.     AddPolynomial(Poly1,Poly2,Poly3); 
  126.     printf("*****************************************\n"); 
  127.     TraversePolynomial(Poly3); 
  128.     return 0; 
  129. } 

 

wawlian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ 链表实现两个一元多项式相加
09-15
c++，算法链表实现一元多项式相加，通过链表实现，非常好的一个程序
单链表应用之一元多项式相加(C语言)
Hackeryuan的博客
03-29 2432
实际上一元多项式的数据结构仍然是一条单链表，不过是此时的每个结点代表多项式的每一项，结点的数据域被细分成了系数域和指数域。而多项式相加的操作就相当于有序单链表的归并操作。 代码： #include <stdio.h> #include <stdlib.h> typedef struct{//项的类型(数据域) float coef;//系数 int expn;//指数 } Data; typedef struct node {//链表(一元多项式)类型 Data data;
一元多项式的表示及相加
赵满刚的博客
11-15 2750
问题描述 实现一元稀疏多项式的表示及基本操作（建立、销毁、输出、加法、减法等操作） 算法设计   实现要定义的一元多项式应采用链式存储结构。根据一元多项式相加的运算法则，对于两个多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成新多项式的一项;对于两个多项式中所有指数不同的项，分别复制到新多项式中。新多项式不必另外生成，而是在原来的两个多项式中摘取结点即可。     采用顺序存储...
数据结构——有序链表的合并，链表实现一元多项式相加
Acc222222的博客
08-05 1729
1.有序链表的合并 void Connect(LinkList a, LinkList b, LinkList& c) { LNode* pa, * pb, * pc; pa = a->next; pb = b->next; c = a; pc = c; while (pa && pb) { if (pa->data <= pb->data) {
基于C++的一元多项式相加.zip
07-10
结合书上第41页的例子，采用链式存储结构，将两个线性链表表示的一元多项式相加，并输出。此一元多项式遵循多项式相加运算规则：对于两个一元多项式中存在指数相同的项时，其对应系数相加。合并后系数和为零时，删除...
顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现。.docx
11-05
...
c++数据结构实验：多项式相加
07-11
实现了A=7+3x+9x^8+5x^17与B=8x+22x^7+(-9)x^8相加的和，内含算法详细讲解，运行结果与源代码
数据结构_两个链表的合并一元多项式相加
06-03
数据结构_两个链表的合并,一元多项式相加
C语言链表应用：一元多项式加法运算
ColdMoon_Rain的博客
11-01 2236
C语言链表应用：一元多项式加法运算 首先科普一下线性表的相关知识。线性表，即由n个性质相同的数据元素组成的有序序列。线性表是最基础的线性结构，也是最基本的数据结构形式。因此学好线性表，也是学习其余数据结构的基础。 而线性表分为两类：顺序表和链表。 顺序表的最大特点，既存储该表数据元素的存储单元是连续的（话说这为什么算“顺序”啊……）。而链表则与之相反，是一种靠指针链接的，用任意存储单元存储数据元素的表，指针，就是该类表的“链”。而两表当中，链表的使用居多（至少凭我目前短浅的阅历是没怎么用过顺序表的）。 所以
重学数据结构001——链表基本操作与一元多项式相加(C语言)
wawlian说
11-10 211
        大一的时候我们专业开了一门C语言限选课，老师觉得指针太难，所以不讲指针。大三的时候学数据结构，考虑到数据结构比较难，老师不要求代码实现。就这样，两门比较重要的课就这样浑浑噩噩的过去了。后来学Java，算是学的还行，也独立的做过一些导师的项目。只是在找工作的时候，才发现笔试题、面试题到处都是C、C++和数据结构的题。多多少少也因此碰了不少壁。不管怎么样，自己还年轻，以前没学好，现在学...
数据结构之一元多项式相加
技术是用来解决问题的
03-06 2万+
问题 采用链式存储结构，将两个线性链表表示的一元多项式相加，并输出。 算法设计 1、程序结构设计 1）数据结构 typedef struct node { floatcoef; //序数 intexpn; //指数 struct node *next; //指向下一个结点的指针 }......
数据结构——一元n次多项式加法
君陌的博客
11-20 1169
此为本人在学习数据结构时所写的，各个功能能够实现，有main.cpp，link.h，list.h，list.cpp四个文件 使用说明： 请按照输入提示输入多项式的次数和各项系数，； 输入请按照提示要求！ 请不要输入数字之外的其他文字 例： 3 3 2 2 3 1 1 0 0 表示最高级数为3的多项式：2x3+3x2+1*x1+0x0 5 5 1 0 0 表示最高级数为5的多项式：1x^5 main...
数据结构—— 一元多项式的加法运算
热门推荐
forest_one的博客
09-24 3万+
一、 需求分析 0.问题描述 在数学上，一个一元n次多项式 可按降序写成： 它由n+1个系数唯一确定，因此，在计算机里他可以用一个线性表表示： 设Pn(x)和Qn(x)分别为两个一元多项式，请求出两个一元多项式的加法运算的结果，要求元素按照多项式的次数递减的次序排列。 1.问题分析 需求：实现两个一元多项式的加法运算。 实现功能：①通过键盘接收输入的整数（浮点数） ②以系数和指数对应的形式，储...
数据结构的应用——一元N次多项式的加法
山顶冻人的专栏
03-23 1999
<br /><br /><br /> <br />采用ArrayList来实现多项式，为免要求输入时按升幂输入，可以调用Collections的sort方法。<br />建立每个项的类PolyItem，实现Comparable接口以便ArrayList的排序，代码如下：<br />/** * 多项式的项，并实现了项的大小比较 * @author Bao Yiming */ class PolyItem implements Comparable<PolyItem> { Integer
【数据结构】一元多项式
qq_25218219的博客
10-12 4377
实验报告格式规范，包括以下内容：（正文 宋体五号 ） 一、问题描述（标题黑体小四） 对简单的一元多项式相加、相减、求导运算。 二、实验目的 实现对简单的一元多项式相加、相减、求导运算。 三、实验设计 1.逻辑结构 逻辑结构是指数据元素之间的逻辑关系，即从逻辑关系上描述数据。它与数据的存储无关，是独立于计算机的。数据的逻辑结构分为线性结构和非线性结构，线性表是典型的线性结构；集合、树和图是典型的非线性结构。数据的逻辑结构分类见图1-1。 集合结构中的数据元素之间除了 “同属于一个集合”的关系外，别无其他关
郑州轻工业大学2020年数据结构练习集
weixin_43906149的博客
07-02 780
郑州轻工业大学2020年数据结构练习集 按顺序： 函数题 1 List MakeEmpty() { List list; list = (List)malloc(sizeof(struct LNode)); list->Last = -1; return list; } Position Find( List L, ElementType X ) { int i; for(i = 0; i < MAXSIZE; i++) {
单链表操作之一元多项式的合并
weixin_43260290的博客
09-26 1689
多项式就是单项式的加减法，对于单项式可以用一组数表示，例如2X^3，可以表示为（2，3）。我们可以使用单链表来进行多项式的合并操作。 一：首先我们先建立新的数据类型multi typedef struct multi{ int coef; int index; struct multi *next; }multi; 二：建立链表。我这里建立的为带有头结点的链表，这样方便之后的合并操作...
数据结构怎么用链表实现一元多项式相加
最新发布
04-11
可以将多项式的每一项作为链表节点的数据域，并根据指数大小进行插入排序，最后将指数相同的项的系数相加即可。具体实现可以参考以下代码： ```python class Node: def __init__(self, coef=0, exp=0): self.coef...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值