재 학 데이터 구조 001 ― 링크 기본 조작 과 일원 다항식 을 더 하 다.

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!
    "
    ); 
  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
    "
    ,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 원 다항식 에 대해 그들 에 게 여러 가지 조작 을 해 야 한다 면 흔히 볼 수 있 는 두 가지 사고방식 은 다음 과 같다. (1) 한 개의 다항식 에 대해 가장 높 은 횟수 인 하 이 파 우 더 를 보존 하고 이 다항식 의 대응 횟수 는 각각 0 - 하 이 파 우 더 의 각 계수 의 수조 () 이다.(2) 다항식 중 계수 가 0 이 아 닌 모든 항목 은 그 계수 와 이 항목 의 횟수 를 보존한다.다음은 이 두 가지 사고방식 으로 일원 다항식 덧셈 조작 을 실현 한다.
사고방식 1:
데이터 구조 정의:
 

  
  
  
  
  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
    "
    ,Sum->HighPower); 
  57.     for(k = 0; k <= 10; k++) 
  58.     { 
  59.         printf("The Coeff of power %d is %d
    "
    ,k,Sum->CoeffArray[k]); 
  60.     } 
  61.  
  62.     return 0; 
  63. } 

사고방식 2:
데이터 구조:
 

  
  
  
  
  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
    "
    ,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("*****************************************
    "
    ); 
  124.     TraversePolynomial(Poly2); 
  125.     AddPolynomial(Poly1,Poly2,Poly3); 
  126.     printf("*****************************************
    "
    ); 
  127.     TraversePolynomial(Poly3); 
  128.     return 0; 
  129. } 

좋은 웹페이지 즐겨찾기