재 학 데이터 구조 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.     ElementType Element; 
  8.     Position Next; 
  9. }; 

        링크 의 조작 이 그리 많 지 않 습 니 다. 다음은 자주 사용 하 는 조작 입 니 다.
 

  
  
  
  
  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.     ElementType Element; 
  11.     Position Next; 
  12. }; 
  13.  
  14. //  
  15. List CreateList(); 
  16. //  
  17. void TraverseList(List L); 
  18. //  
  19. List MakeEmpty(List L); 
  20. //  
  21. int IsEmpty(List L); 
  22. //  
  23. int IsLast(Position P, List L); 
  24. // 。 
  25. // , NULL 
  26. Position Find(ElementType X, List L); 
  27. //  
  28. void Delete(ElementType X, List L); 
  29. //  
  30. Position FindPrevious(ElementType X, List L); 
  31. //  
  32. void Insert(ElementType X, List L, Position P); 
  33. //  
  34. void DeleteList(List L); 
  35. //  
  36. Position Header(List L); 
  37. //  
  38. Position First(List L); 
  39. //  
  40. Position Advance(Position P); 
  41. //  
  42. ElementType Retrive(Position P); 
  43.  
  44. int IsEmpty(List L) 
  45.      
  46.     return L->Next == NULL; 
  47.  
  48. int IsLast(Position P, List L) 
  49.     return P->Next == NULL; 
  50.  
  51. Position Find(ElementType X, List L) 
  52.     Position P = L->Next; 
  53.     while(P != NULL && P->Element != X) 
  54.     { 
  55.         P = P->Next; 
  56.     } 
  57.     return P; 
  58.  
  59. void Delete(ElementType X, List L) 
  60.     Position P,TmpCell; 
  61.     P = FindPrevious(X,L);   
  62.     if(!IsLast(P,L)) 
  63.     { 
  64.         TmpCell = P->Next; 
  65.         P->Next = TmpCell->Next; 
  66.         free(TmpCell); 
  67.     } 
  68.  
  69. Position FindPrevious(ElementType X, List L) 
  70.     Position P = L; 
  71.     while(P->Next != NULL && P->Next->Element != X) 
  72.     { 
  73.         P = P->Next; 
  74.     } 
  75.     return P; 
  76.  
  77. void Insert(ElementType X, List L, Position P) 
  78.     Position TmpCell; 
  79.     TmpCell = malloc(sizeof(struct Node)); 
  80.     if(TmpCell == NULL) 
  81.     { 
  82.         printf("Out of space!
    "
    ); 
  83.         return
  84.     } 
  85.     TmpCell->Element = X; 
  86.     TmpCell->Next = P->Next; 
  87.     P->Next = TmpCell; 
  88.  
  89. void DeleteList(List L) 
  90.     Position P,Tmp; 
  91.     P = L->Next; 
  92.     L->Next = NULL; 
  93.     while(P != NULL) 
  94.     { 
  95.         Tmp = P->Next; 
  96.         free(P); 
  97.         P = Tmp; 
  98.     } 
  99.  
  100. Position Header(List L) 
  101.     return L; 
  102.  
  103. Position First(List L) 
  104.     return L->Next; 
  105.  
  106. Position Advance(Position P) 
  107.     return P->Next; 
  108.  
  109. ElementType Retrive(Position P) 
  110.     return P->Element; 
  111.  
  112. List CreateList() 
  113.     int i; 
  114.     Position P,Tmp; 
  115.     List L = malloc(sizeof(struct Node)); 
  116.     P = L; 
  117.     for(i = 0; i < 5; i++) 
  118.     { 
  119.         Tmp = malloc(sizeof(struct Node)); 
  120.         Tmp->Element = i; 
  121.         P->Next = Tmp; 
  122.         P = Tmp;         
  123.     } 
  124.     P->Next = NULL; 
  125.     return L; 
  126.  
  127. void TraverseList(List L) 
  128.     Position P; 
  129.     P = L->Next; 
  130.     while(P != NULL) 
  131.     { 
  132.         printf("%d
    "
    ,P->Element);   
  133.         P = P->Next; 
  134.     } 
  135.  
  136. int main(void
  137.     //  
  138.     List L = CreateList(); 
  139.     // 1  
  140.     Position P = Find(1,L); 
  141.     // 1 8 
  142.     Insert(8,L,P); 
  143.     // 8  
  144.     P = FindPrevious(8,L); 
  145.     //  
  146.     TraverseList(L); 
  147.     return 0; 

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

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

구현 코드:
 

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

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

  
  
  
  
  1. typedef struct PolyNode *PtrToNode; 
  2.  
  3. // , ; 
  4. typedef struct PolyNode 
  5.     int Coeff; 
  6.     int Exponent; 
  7.     PtrToNode Next; 
  8. } PolyNode; 

구현 코드:
 

  
  
  
  
  1. #include <stdio.h> 
  2. #include <stdlib.h> 
  3.  
  4. typedef struct PolyNode *PtrToNode; 
  5.  
  6. // , ; 
  7. typedef struct PolyNode 
  8.     int Coeff; 
  9.     int Exponent; 
  10.     PtrToNode Next; 
  11. } PolyNode; 
  12.  
  13.  
  14. typedef PtrToNode Polynomial; 
  15.  
  16. /************************************************************ 
  17. * : 
  18. *P、Q ( ) 
  19. *Sum  
  20. * 
  21. ************************************************************/ 
  22. void AddPolynomial(Polynomial P,Polynomial Q,Polynomial Sum) 
  23.     Polynomial PIndex,QIndex,SumIndex; 
  24.     PIndex = P->Next; 
  25.     QIndex = Q->Next; 
  26.     SumIndex = Sum; 
  27.     while(!(PIndex == NULL && QIndex == NULL)) 
  28.     { 
  29.         if(PIndex==NULL) 
  30.         { 
  31.             SumIndex->Next = QIndex; 
  32.             QIndex = QIndex->Next; 
  33.             SumIndex = SumIndex->Next; 
  34.         } 
  35.         else if(QIndex == NULL) 
  36.         { 
  37.             SumIndex->Next = PIndex; 
  38.             PIndex = PIndex->Next; 
  39.             SumIndex = SumIndex->Next; 
  40.         } 
  41.         else 
  42.         { 
  43.             if(PIndex->Exponent > QIndex->Exponent) 
  44.             { 
  45.                 SumIndex->Next = PIndex; 
  46.                 PIndex = PIndex->Next; 
  47.                 SumIndex = SumIndex->Next; 
  48.                 //continue if , Java 
  49.                 //  
  50.                 continue
  51.             } 
  52.             if(PIndex->Exponent == QIndex->Exponent) 
  53.             { 
  54.                 Polynomial PP = malloc(sizeof(struct PolyNode)); 
  55.                 PP->Exponent = PIndex->Exponent; 
  56.                 PP->Coeff = PIndex->Coeff + QIndex->Coeff; 
  57.                 SumIndex->Next = PP; 
  58.                 PIndex = PIndex->Next; 
  59.                 QIndex = QIndex->Next; 
  60.                 SumIndex = SumIndex->Next; 
  61.                 continue
  62.             } 
  63.             if(PIndex->Exponent < QIndex->Exponent) 
  64.             { 
  65.                 SumIndex->Next = QIndex; 
  66.                 QIndex = QIndex->Next; 
  67.                 SumIndex = SumIndex->Next; 
  68.                 continue
  69.             } 
  70.         } 
  71.     } 
  72.     SumIndex->Next = NULL; 
  73.  
  74. /************************************************************ 
  75. * ( ) : 
  76. *P:  
  77. *************************************************************/ 
  78. void TraversePolynomial(Polynomial P) 
  79.     Polynomial Tmp = P->Next; 
  80.     while(Tmp != NULL) 
  81.     { 
  82.         printf("Coeff is %d and Exponent is %d
    "
    ,Tmp->Coeff,Tmp->Exponent); 
  83.         Tmp = Tmp->Next; 
  84.     } 
  85.  
  86.  
  87.  
  88. int main(void
  89.     Polynomial Poly1,Poly2,Poly3,Poly11,Poly22; 
  90.     int i,j; 
  91.     Poly1 = malloc(sizeof(struct PolyNode)); 
  92.     Poly2 = malloc(sizeof(struct PolyNode)); 
  93.     Poly3 = malloc(sizeof(struct PolyNode)); 
  94.     Poly11 = Poly1; 
  95.     Poly22 = Poly2; 
  96.  
  97.     // ,  
  98.     for(i = 5;i >= 1;i--) 
  99.     { 
  100.         Polynomial Tmp  = malloc(sizeof(struct PolyNode)); 
  101.         Tmp->Coeff = i; 
  102.         Tmp->Exponent = i; 
  103.         Poly11->Next = Tmp; 
  104.         Poly11 = Poly11->Next; 
  105.     } 
  106.     Poly11->Next = NULL; 
  107.     for(j = 11;j >= 3;j--) 
  108.     { 
  109.         Polynomial Tmp  = malloc(sizeof(struct PolyNode)); 
  110.         Tmp->Coeff = j; 
  111.         Tmp->Exponent = j; 
  112.         Poly22->Next = Tmp; 
  113.         Poly22 = Poly22->Next; 
  114.     } 
  115.     Poly22->Next = NULL; 
  116.     TraversePolynomial(Poly1); 
  117.     printf("*****************************************
    "
    ); 
  118.     TraversePolynomial(Poly2); 
  119.     AddPolynomial(Poly1,Poly2,Poly3); 
  120.     printf("*****************************************
    "
    ); 
  121.     TraversePolynomial(Poly3); 
  122.     return 0; 

좋은 웹페이지 즐겨찾기