Từ 1 tới 9 trên tổng số 9 kết quả

Đề tài: Stack, ngăn xếp - Thiết lập và ứng dụng stack trong C

  1. #1
    Ngày gia nhập
    10 2006
    Nơi ở
    Hà Nội
    Bài viết
    146

    Mặc định Stack, ngăn xếp - Thiết lập và ứng dụng stack trong C

    Ngăn xếp là một kiểu danh sách tuyến đặc biệt mà phép bổ sung hoặc loại bỏ phần tử luôn thực hiện tại một đầu, gọi là đỉnh(top).
    Ta có thể hình dung stack như việc xếp chồng đĩa: ta chồng thêm 1 đĩa ở trên cùng, và lấy ra 1 đĩa cũng ở trên cùng.
    Stack thuộc và loại danh sách hoạt động dựa trên nguyên tắc LIFO (Last- in- First- Out).

    Các thao tác trên stack :(dựa trên stack để lưu trữ số nguyên- còn stack tổng quát tôi sẽ post lên sau.)
    1.Khai báo stack :
    C Code:
    1. #define TRUE    1
    2. #define FALSE   0
    3. #define MAX     100
    4. typedef struct  {
    5.         int     top;
    6.         int nodes[MAX];
    7. } stack;

    2. Thao tác Empty: kiểm tra tính rỗng của stack:
    C Code:
    1. int Empty(stack *ps) {
    2.         if (ps ->top == -1)
    3.             return(TRUE);
    4.         return(FALSE);
    5. }

    3.Thêm nút mới vào đỉnh stack : Push
    C Code:
    1. void    Push (stack *ps, int x) {
    2.         if ( ps ->top == -1) {
    3.             printf(“\n stack full”);
    4.             return;
    5.         }
    6.         ps -> top = ps ->top + 1;
    7.         ps -> nodes[ps->top] = x;
    8. }

    4.Thao tác kiểm tra tính đầy của stack :Full
    C Code:
    1. int Full(stack *s){
    2.    if(s->top == MAX-1) return 1;
    3.     else return 0;

    5.Thao tác lấy 1 phần tử từ đỉnh stack: POP
    C Code:
    1. int Pop( stack *s){
    2.       if(Empty(s)){
    3.             printf("\n Stack rong");
    4.             return NULL;
    5.             }
    6.        return(s->info[s->top--]);
    7.   }


    Ứng dụng của stack
    Có rất nhiều ứng dụng của stack, sau đây ta chỉ xét một số ứng dụng nhỏ:

    1.Đảo ngược xâu.
    Ta sẽ nhập xâu vào stack, sau đó lấy lần lượt các phần tử của stack ra tại đỉnh của nó. Và do đó ta có xâu đã đảo ngược.

    2.Đổi một số n từ hệ cơ số thập phân sang hệ nhị phân.
    Ta sẽ lấy số dư n%2 lưu vào stack, và gán n=n/2.
    Đến khi nào n=1 thì cũng lưu vào stack.
    Ta lại lấy lần lượt các phần tử của stack -> xâu biểu diễn nhị phân của n.

    3.Thao tác trên stack tổng quát cùng với các thao tác duyệt stack , tìm kiếm trên stack có rất nhiều ứng dụng.

    hôm nay đến đây thôi!

  2. #2
    Ngày gia nhập
    02 2008
    Nơi ở
    Việt Nam
    Bài viết
    577

    Mặc định Đổi cơ số sử dụng stack

    Update thêm một vài mẫu code trước từ làm để thành viên mới học tham khảo:

    Đổi cơ số
    C Code:
    1. /** Info: Convert number using stack
    2.   **/
    3. #include<stdio.h>
    4. #include<stdlib.h>
    5. /*
    6. */
    7. struct node
    8. {
    9.     int data;
    10.     struct node* next;
    11. };
    12. typedef struct node* NODEPTR;
    13.  
    14. void Init(NODEPTR *head)
    15. {
    16.     (*head) = NULL;
    17. }
    18.  
    19. int Empty(NODEPTR head)
    20. {
    21.     if (head==NULL) return 1;
    22.     return 0;
    23. }
    24.  
    25. void Push(NODEPTR *head, int x)
    26. {
    27.     NODEPTR p = (NODEPTR) malloc (sizeof(struct node));
    28.     p->data = x;
    29.  
    30.     if (Empty(*head))
    31.     {
    32.         (*head) = p;
    33.         (*head)->next = NULL;
    34.     }
    35.     else
    36.     {
    37.         p->next = (*head);
    38.         (*head) = p;
    39.     }
    40. }
    41.  
    42. void Pop(NODEPTR *head, int *x)
    43. {
    44.     if (!Empty(*head))
    45.     {
    46.         *x = (*head)->data;
    47.         NODEPTR p = (*head);
    48.         (*head) = (*head)->next;
    49.         free(p);
    50.     }
    51. }
    52.  
    53. /*Conver decimal number to binary number*/
    54. void Convert(int num)
    55. {
    56.     NODEPTR head;
    57.     Init(&head);
    58.  
    59.     while (num)
    60.     {
    61.         Push(&head,num%2);
    62.         num /= 2;
    63.     }
    64.  
    65.     while (!Empty(head))
    66.     {
    67.         int x;
    68.         Pop(&head,&x);
    69.         printf("%d",x);
    70.     }
    71. }
    72.  
    73. int main()
    74. {
    75.     printf(" * Convert 10 to binary number is ");Convert(10);
    76.     return 0;
    77. }

  3. #3
    Ngày gia nhập
    02 2008
    Nơi ở
    Việt Nam
    Bài viết
    577

    Mặc định quản lý một dãy số nguyên bằng stack

    Cái này là cài đặt linked list

    Vd với quản lý một dãy số nguyên
    C Code:
    1. /** Author: QuangHoang
    2.   * File: Bai5.c
    3.   * Date: 20090402
    4.   * Info: Compiler gcc with Code::Block, using linked list setup.
    5.   **/
    6. #include <stdio.h>
    7. #include <stdlib.h>
    8. /*
    9. */
    10. typedef struct Number
    11. {
    12.     int number;
    13.     struct Number *next;
    14. } *NODE;
    15.  
    16.  
    17. /**All Function**/
    18. void Init(NODE *plist) {*plist = NULL;}
    19.  
    20. int Empty(NODE plist)
    21. {
    22.     if (plist == NULL) return 1;
    23.     return 0;
    24. }
    25.  
    26. void InsertTop(NODE *plist, int x)
    27. {
    28.     NODE p = (NODE) malloc (sizeof(struct Number));
    29.     p->number = x;
    30.     p->next = NULL;
    31.     if (Empty(*plist)) *plist = p;
    32.     else
    33.     {
    34.         p->next = *plist;
    35.         *plist = p;
    36.     }
    37. }
    38.  
    39. void InsertBottom(NODE *plist, int x)
    40. {
    41.     NODE p = (NODE) malloc (sizeof(struct Number));
    42.     p->number = x;
    43.     p->next = NULL;
    44.     if (Empty(*plist)) *plist = p;
    45.     else
    46.     {
    47.         NODE q = *plist;
    48.         while (q != NULL) q = q->next;
    49.         q = p;
    50.     }
    51. }
    52.  
    53. void InsertPos(NODE *plist, NODE pos, int x)
    54. {
    55.     NODE p = (NODE) malloc (sizeof(struct Number));
    56.     p->number = x;
    57.     p->next = pos->next;
    58.     pos->next = p;
    59. }
    60.  
    61. void DeleteTop(NODE *plist, int *x)
    62. {
    63.     if (!Empty(*plist))
    64.     {
    65.         NODE p = *plist;
    66.         *plist = (*plist)->next;
    67.         *x = p->number;
    68.         free(p);
    69.     }
    70. }
    71.  
    72. void DeleteBottom(NODE *plist, int *x)
    73. {
    74.     if (!Empty(*plist))
    75.     {
    76.         NODE p = *plist, q;
    77.         while (p->next != NULL)
    78.         {
    79.             q = p;
    80.             p = p->next;
    81.         }
    82.         *x = p->number;
    83.         free(p);
    84.         q->next = NULL;
    85.     }
    86. }
    87.  
    88. void DeletePos(NODE *plist, NODE pos, int *x)
    89. {
    90.     NODE p = *plist;
    91.     while (p->next != pos) p = p->next;
    92.     p->next = pos->next;
    93.     *x = pos->number;
    94.     free(pos);
    95. }
    96.  
    97. void DeleteALL(NODE *plist)
    98. {
    99.     NODE p;
    100.     while (!Empty(*plist))
    101.     {
    102.         p = *plist;
    103.         *plist = (*plist)->next;
    104.         free(p);
    105.     }
    106. }
    107.  
    108. void Display(NODE plist)
    109. {
    110.     NODE p = plist;
    111.     while (p != NULL)
    112.     {
    113.         printf("%6d",p->number);
    114.         p = p->next;
    115.     }
    116. }
    117.  
    118. int main()
    119. {
    120.     NODE plist;
    121.     Init(&plist);
    122.     int x = 5;
    123.     InsertBottom(&plist,x); x++;
    124.     InsertTop(&plist,x); x++;
    125.  
    126.     Display(plist);
    127.     return 0;
    128. }

    Bài này nhiều công việc hơn
    C Code:
    1. /** Author: QuangHoang
    2.   * File: Bai6.c
    3.   * Date: 20090418
    4.   * Info: Compiler gcc with Code::Block, using linked list setup.
    5.   **/
    6. #include <stdio.h>
    7. #include <stdlib.h>
    8. /*
    9. */
    10. /**Khai bao node cua danh sach**/
    11. typedef struct node
    12. {
    13.     int data;
    14.     struct node* next;
    15. }* NODEPTR;
    16.  
    17.  
    18. /**Cac dinh nghia ham trong chuong trinh**/
    19. void Init(NODEPTR *plist)
    20. {
    21.     *plist = NULL;
    22. }
    23.  
    24. int Empty(NODEPTR plist)
    25. {
    26.     if (plist == NULL) return 1;
    27.     else return 0;
    28. }
    29.  
    30. void InsertBottom(NODEPTR *plist, int x);
    31. void InsertAfterK(NODEPTR *plist, int x, int k);
    32.  
    33. void DeletePos(NODEPTR *plist, NODEPTR pos);
    34. void DeleteValue(NODEPTR *plist, int x);
    35. void DeleteAfterK(NODEPTR *plist, int k);
    36.  
    37. void SortLinkList(NODEPTR *plist);
    38. void DeleteCoincide(NODEPTR *plist);
    39. void ChangeValue(NODEPTR *plist, int x, int k);
    40. void DeleteOdd(NODEPTR *plist);
    41.  
    42. void CreateList();
    43. void Show(NODEPTR plist);
    44.  
    45.  
    46.  
    47. /**Chuong trinh chinh**/
    48. int main()
    49. {
    50.     NODEPTR plist;
    51.     Init(&plist);
    52.     int i;
    53.     for (i=0; i<3; i++)
    54.     {
    55.         InsertBottom(&plist,i+2);
    56.     }
    57.     InsertAfterK(&plist,7,2);
    58.     Show(plist);
    59.     DeletePos(&plist,plist->next);
    60.     DeleteValue(&plist,4);
    61.     DeleteAfterK(&plist,2);
    62.     Show(plist);
    63.     return 0;
    64. }
    65.  
    66.  
    67.  
    68.  
    69. /**Noi dung tat ca cac ham**/
    70.  
    71. /*Chen mot node vao cuoi list, nham khoi tao list*/
    72. void InsertBottom(NODEPTR *plist, int x)
    73. {
    74.     NODEPTR p = (NODEPTR) malloc (sizeof(struct node));
    75.     p->data = x;
    76.     p->next = NULL;
    77.     if (Empty(*plist)) (*plist) = p;
    78.     else
    79.     {
    80.         NODEPTR q = (*plist);
    81.         while (q->next != NULL) q = q->next;
    82.         q->next = p;
    83.     }
    84. }
    85.  
    86. void InsertAfterK(NODEPTR *plist, int x, int k)
    87. {
    88.     NODEPTR q = *plist;
    89.     int i=1;
    90.     while (q->next != NULL && i<k) {q = q->next; i++;}
    91.     if (i<k) {printf(" Insert false! \n"); return;}
    92.  
    93.     NODEPTR p = (NODEPTR) malloc (sizeof(struct node));
    94.     p->data = x;
    95.     p->next = q;
    96.     q = *plist;
    97.     while (q->next != p->next) q = q->next;
    98.     q->next = p;
    99. }
    100.  
    101. void DeletePos(NODEPTR *plist, NODEPTR pos)
    102. {
    103.     if (*plist==pos)
    104.     {
    105.         (*plist) = (*plist)->next;
    106.         free(pos);
    107.         return;
    108.     }
    109.  
    110.     NODEPTR q = (*plist);
    111.     while (q->next != pos) q = q->next;
    112.     q->next = pos->next;
    113.     free(pos);
    114. }
    115.  
    116. void DeleteValue(NODEPTR *plist, int x)
    117. {
    118.     NODEPTR q = (*plist);
    119.     while (q != NULL)
    120.     {
    121.         if (q->data==x)
    122.         {
    123.             NODEPTR p = q;
    124.             DeletePos(plist,p);
    125.         }
    126.         q = q->next;
    127.     }
    128. }
    129.  
    130. void DeleteAfterK(NODEPTR *plist, int k)
    131. {
    132.     NODEPTR q = *plist;
    133.     int i=1;
    134.     while (q != NULL && i<k) {q = q->next; i++;}
    135.     if (q!=NULL) DeletePos(plist,q);
    136. }
    137.  
    138. void Show(NODEPTR plist)
    139. {
    140.     NODEPTR q = plist;
    141.     while (q != NULL)
    142.     {
    143.         printf("%6d",q->data);
    144.         q = q->next;
    145.     }
    146.     printf ("\n");
    147. }
    148.  
    149. void DeleteCoincide(NODEPTR *plist)
    150. {
    151.     NODEPTR q = (*plist)->next;
    152.     while (q != NULL)
    153.     {
    154.         NODEPTR p = (*plist);
    155.         while (p->next != q)
    156.         {
    157.             if (q->data==p->data)
    158.             {
    159.                 NODEPTR _q = q;
    160.                 DeletePos(plist,_q);
    161.             }
    162.             p = p->next;
    163.         }
    164.         q = q->next;
    165.     }
    166. }
    167.  
    168. void ChangeValue(NODEPTR *plist, int x, int k)
    169. {
    170.     NODEPTR q = *plist;
    171.     int i=1;
    172.     while (q != NULL && i<k) {q = q->next; i++;}
    173.     if (q!=NULL) q->data = x;
    174. }
    175.  
    176. void DeleteOdd(NODEPTR *plist)
    177. {
    178.     NODEPTR q = *plist;
    179.     while (q != NULL)
    180.     {
    181.         if (q->data%2 == 1)
    182.         {
    183.             NODEPTR p = q;
    184.             DeletePos(plist,p);
    185.         }
    186.         q = q->next;
    187.     }
    188. }
    189.  
    190. void SortLinkList(NODEPTR *plist)
    191. {
    192.     NODEPTR q = (*plist);
    193.     while (q->next != NULL)
    194.     {
    195.         NODEPTR p = q->next;
    196.         while (p != NULL)
    197.         {
    198.             if (q->data<p->data)
    199.             {
    200.                 int tmp = q->data;
    201.                 q->data = p->data;
    202.                 p->data = tmp;
    203.             }
    204.             p = p->next;
    205.         }
    206.         q = q->next;
    207.     }
    208. }

  4. #4
    Ngày gia nhập
    02 2008
    Nơi ở
    Việt Nam
    Bài viết
    577

    Mặc định Đảo ngược chuỗi bằng sử dụng stack

    Đảo ngược chuỗi
    C Code:
    1. /** Author: QuangHoang
    2.   * File: Bai8.c
    3.   * Date: 20090401
    4.   * Info:
    5.   **/
    6. #include <stdio.h>
    7. /*
    8. */
    9. /* Node of stack*/
    10. struct node
    11. {
    12.     char ch;
    13.     struct node *next;
    14. };
    15.  
    16. typedef struct node* NODEPTR;
    17.  
    18. void Init(NODEPTR *plist) {*plist = NULL;}
    19.  
    20. int Empty(NODEPTR plist)
    21. {
    22.     if (plist == NULL) return 1;
    23.     return 0;
    24. }
    25.  
    26. void Push(NODEPTR *plist, char chr)
    27. {
    28.     NODEPTR p = (NODEPTR) malloc(sizeof(struct node));
    29.     p->ch = chr;
    30.     p->next = NULL;
    31.     if (Empty(*plist)) *plist = p;
    32.     else
    33.     {
    34.         p->next = *plist;
    35.         *plist = p;
    36.     }
    37. }
    38.  
    39. void Pop(NODEPTR *plist, char *chr)
    40. {
    41.     if (!Empty(*plist))
    42.     {
    43.         NODEPTR p = *plist;
    44.         *plist = (*plist)->next;
    45.         *chr = p->ch;
    46.         free(p);
    47.     }
    48. }
    49.  
    50. int main()
    51. {
    52.     NODEPTR p;
    53.     Init(&p);
    54.     char st[100];
    55.     printf(" - Enter string: ");gets(st);
    56.     int i, n = strlen(st);
    57.  
    58.     for (i=0; i<n; i++) Push(&p,st[i]);
    59.     for (i=0; i<n; i++) Pop(&p,&st[i]);
    60.  
    61.     st[n] = '\0';
    62.  
    63.     printf(" - New string: %s",st);
    64.     return 0;
    65. }

  5. #5
    Ngày gia nhập
    02 2008
    Nơi ở
    Việt Nam
    Bài viết
    577

    Demo sử dụng OOP
    C++ Code:
    1. /** Author: QuangHoang
    2.   * File: Stack(oop).cpp
    3.   * Date: 20090129
    4.   * Info: Stack data structure implementing link lists sample. Using oriented object programming.
    5.   **/
    6. #include <iostream>
    7. using namespace std;
    8. /*
    9. */
    10. /*Node data of stack*/
    11. struct node
    12. {
    13.     int data;
    14.     node* next;
    15. };
    16. typedef node* NODE;
    17.  
    18. /*Stack by link list*/
    19. class Stack
    20. {
    21.     private:
    22.         NODE plist;
    23.     public:
    24.         Stack()
    25.         {
    26.             cout << " - Initalization..." << endl;
    27.             plist=NULL;
    28.         }
    29.         ~Stack()
    30.         {
    31.             while (plist!=NULL)
    32.             {
    33.                 NODE p = plist;
    34.                 plist = plist->next;
    35.                 delete p;
    36.             }
    37.             cout << " - Destroy..." << endl;
    38.         }
    39.         bool Empty()
    40.         {
    41.             if (plist==NULL) return true;
    42.             return false;
    43.         }
    44.         void Push(int _data);
    45.         void Pop(int &_data);
    46.         void ShowData();
    47. };
    48.  
    49. /*Function of class*/
    50. void Stack::Push(int _data)
    51. {
    52.     NODE p = new node;
    53.     p->data = _data;
    54.  
    55.     if (Empty())
    56.     {
    57.         plist = p;
    58.         plist->next = NULL;
    59.         return;
    60.     }
    61.  
    62.     p->next = plist;
    63.     plist = p;
    64. }
    65.  
    66. void Stack::Pop(int &_data)
    67. {
    68.     if (!Empty())
    69.     {
    70.         NODE p = plist;
    71.         plist = plist->next;
    72.         _data = p->data;
    73.         delete p;
    74.     }
    75. }
    76.  
    77. void Stack::ShowData()
    78. {
    79.     NODE p=plist;
    80.     while (p != NULL)
    81.     {
    82.         cout << p->data << "  ";
    83.         p=p->next;
    84.     }
    85.     cout << endl;
    86. }
    87.  
    88. /**Main function**/
    89. int main()
    90. {
    91.     Stack pl;
    92.     for (int i=0; i<6; ++i)
    93.     {
    94.         pl.Push(i*2);
    95.     }
    96.     pl.ShowData();
    97.     int x;
    98.     pl.Pop(x);
    99.     pl.ShowData();
    100.     return EXIT_SUCCESS;
    101. }
    102.  
    103. /* Stack form
    104.         NULL <- node 1 <- node 2 <- ... <- plist
    105. */

  6. #6
    Ngày gia nhập
    09 2009
    Bài viết
    3

    Mặc định Stack, ngăn xếp - Thiết lập và ứng dụng stack trong C

    Ối. Sao không thấy bàn về ứng dụng.

    Mình cũng mới học nên lý thuyết cũng biết sơ sơ. Còn về ứng dụng thực tế thì chưa tưởng tưởng ra được

    Mong được sư huynh chỉ giáo

  7. #7
    Ngày gia nhập
    12 2009
    Nơi ở
    Đà Lạt
    Bài viết
    34

    ứng dụng stack + queue trong doi số thực
    C Code:
    1. #include <stdio.h>
    2. #include <conio.h>
    3.  
    4. typedef int ele;
    5. struct Node
    6. {
    7.     ele data;
    8.     Node*next;
    9.  
    10. };
    11. typedef Node*Stack;
    12. typedef Node*Queue;
    13.  
    14.  
    15.  
    16. /////////////////////////////////////////////////////////////
    17. //Khai Bao ham co ban cua Stack
    18. ////////////////////////////////////////////////////////////
    19. void CreateStack(Stack &S)
    20. {
    21.     S=NULL;
    22. }
    23. //kiem tra rong
    24. bool EmptyStack(Stack S)
    25. {
    26.     return (S==NULL);
    27. }
    28.  
    29.  
    30.  
    31. //taoj node
    32. Stack CreateNode(ele x)
    33. {
    34.     Stack p = new(Node);
    35.     if(!p)
    36.     {
    37.         printf("\nNo Memory.....");
    38.         return NULL;
    39.     }
    40.     p->data = x;
    41.     p->next = NULL;
    42.  
    43. }
    44. //chen
    45.  
    46. void Push(Stack &S,ele x)
    47. {
    48.     Stack p = CreateNode(x);
    49.     if(!EmptyStack(S))
    50.         p->next =S;
    51.     S=p;
    52.  
    53.  
    54. }
    55.  
    56. //lay xoa
    57. void  Pop(Stack &S,ele &x)
    58. {
    59.     if(EmptyStack(S))
    60.     {
    61.         printf("Stack roong.");
    62.         return;
    63.     }
    64.     Node* p = S;
    65.     x= p->data;
    66.     S=S->next;
    67.     p->next=NULL;
    68.     delete p ;
    69. }
    70.  
    71. //nhap
    72. //ele Data()
    73. //{
    74. //  ele x;
    75. //  printf("Nhap X:");
    76. //  scanf("%f",&x);
    77. //  return x;
    78. //}
    79. //voi lay gia tri
    80. void Top(Stack S,ele &x)
    81. {
    82.     if(EmptyStack(S))
    83.     {
    84.         printf("Stack rong.");
    85.         return;
    86.     }
    87.     x = S->data;
    88.  
    89. }
    90.  
    91.  
    92. //void InputStack(Stack &S)
    93. //{
    94. //  printf("\nNhap Stack.\n");
    95. //  ele x;
    96. //  CreateStack(S);
    97. //  while(x = Data())
    98. //      Push(S,x);
    99. //     
    100. //
    101. //}
    102. //void OutPutStack(Stack S)
    103. //{
    104. //  if(EmptyStack(S))
    105. //  {
    106. //      printf("\nRong.");
    107. //      return;
    108. //
    109. //  }
    110. // 
    111. //  printf("\nStack: ");
    112. //  Node* p =S;
    113. //  while(p)
    114. //  {
    115. //     
    116. //      printf("-->%0.1f",p->data);
    117. //      p=p->next;
    118. //     
    119. //
    120. //  }
    121. //}
    122.  
    123.  
    124.  
    125.  
    126.  
    127. //////////////////////////////////////////////////////
    128. //khai bao hang doi queue
    129. /////////////////////////////////////////////////////
    130.  
    131. void CreateQueue(Queue &Q)
    132. {
    133.     Q = NULL;
    134. }
    135.  
    136. bool EmptyQueue(Queue Q)
    137. {
    138.     return (Q==NULL);
    139. }
    140.  
    141. Queue CreateQueue(ele x)
    142. {
    143.     Queue p = new(Node);
    144.     if(!p)
    145.     {
    146.         printf("\n No Memory");
    147.         return NULL;
    148.     }
    149.     p->data =x;
    150.     p->next = NULL;
    151. }
    152. //chen sau
    153. void EnQueue(Queue &Q,ele x)
    154. {
    155.     Queue p = CreateNode(x);
    156.     if(EmptyQueue(Q))
    157.         Q = p;
    158.     else
    159.     {
    160.         Queue q =Q;
    161.         while(q->next !=NULL)
    162.             q =q->next;
    163.         q->next = p;
    164.     }
    165.  
    166. }
    167. // lay phan tu dau
    168. void DeQueue(Queue &Q, ele x)
    169. {
    170.     if(EmptyQueue(Q))
    171.     {
    172.         printf("\n Queue Rong. ");
    173.         return;
    174.     }
    175.     Queue p = Q;
    176.     Q = Q->next;
    177.     p -> next = NULL;
    178.     x = p -> data;
    179.     delete p ;
    180.  
    181.  
    182. }
    183.  
    184. ///ham ho tro khac
    185. // lay gia tri dau hang doi
    186.  
    187. ele Font(Queue Q)
    188. {
    189.     if(EmptyQueue(Q))
    190.     {
    191.         printf("\n Queue Rong. ");
    192.         return NULL;
    193.     }
    194.     return (Q->data);
    195.  
    196.  
    197.  
    198. }
    199.  
    200.  
    201. //void InputQueue(Queue &Q)
    202. //{
    203. //  printf("\n Nhap Queue.\n");
    204. //  ele x;
    205. //  CreateQueue(Q);
    206. //  while(x = Data())
    207. //      EnQueue(Q,x);
    208. //
    209. //}
    210. //
    211. //void OutPutQueue(Queue Q)
    212. //{
    213. //  if(EmptyQueue(Q))
    214. //  {
    215. //      printf("\nRong.");
    216. //      return;
    217. //
    218. //  }
    219. // 
    220. //  printf("\nQueue: ");
    221. //  Node* p =Q;
    222. //  while(p)
    223. //  {
    224. //     
    225. //      printf("-->%0.1f",p->data);
    226. //      p=p->next;
    227. //     
    228. //
    229. //  }
    230. //}
    231. //
    232. //
    233.  
    234.  
    235. void Doicoso(Stack &S,Queue &Q,float so,int coso)
    236. {
    237.     int a =so;
    238.     float b = so - a;
    239.    
    240.     //doi so nguyen
    241.     CreateStack(S);
    242.     while(a>0)
    243.     {
    244.         int du =a%coso;
    245.         Push(S,du);
    246.         a=a/coso;
    247.        
    248.     }
    249.  
    250.     //doi so thuc
    251.     CreateQueue(Q);
    252.     int dem = 0;
    253.     while(b>0&&dem<10)
    254.     {
    255.         b = b * coso;
    256.         int c = b;
    257.         EnQueue(Q,c);
    258.         b = b - c;
    259.         dem++;
    260.    
    261.     }
    262.    
    263. }
    264.  
    265.  
    266.  
    267. void OutPut(Stack S,Queue Q)
    268. {
    269.     if(S==NULL)
    270.     {
    271.         printf("DS rong ");
    272.         return;
    273.     }
    274.    
    275.     Stack p = S;
    276.  
    277.     while(p!= NULL)
    278.     {
    279.         if(p->data <10) printf(" %d ", p->data);
    280.  
    281.         else
    282.             printf("%c",'A' + p->data - 10);
    283.        
    284.         p=p->next;
    285.     }
    286.  
    287. printf(".");
    288.  
    289.  
    290.     if(Q==NULL)
    291.     {
    292.        
    293.         return;
    294.     }
    295.    
    296.     Queue q = Q;
    297.  
    298.     while(q!= NULL)
    299.     {
    300.         if(q->data<10)
    301.        
    302.        
    303.         printf("%d",q->data );
    304.  
    305.         else
    306.             printf("%c",'A' + q->data - 10);
    307.    
    308.         q=q->next;
    309.     }
    310.  
    311. }
    TVT
    TNK32
    Khoa Toán -Tin
    University Of Da Lat


    http://tnk32.come.vn

  8. #8
    Ngày gia nhập
    01 2010
    Nơi ở
    DH-CNTT
    Bài viết
    66

    nếu nói về thao tác stack thì code này cũng khá chuẩn ,của robert sedgewick
    // đây là ứng dụng biểu thức hậu tố trong kí pháp balan , nhưng còn lỗi không nhỏ chưa khắc phục đc , mong các bạn sửa giúp!
    C Code:
    1. #include <iostream>
    2. #include <cstdlib>
    3. #include <cmath>
    4. #include <fstream>
    5. #include<stdio.h>
    6. #include<conio.h>
    7. typedef int itemtype;
    8. class Stack
    9. {
    10.     private:
    11.     itemtype *stack;
    12.     int p;
    13.     public:
    14.     Stack(int max=100)
    15.     {
    16.         stack=new itemtype[max];p=0;
    17.     }
    18.     ~Stack()
    19.     {
    20.         delete stack;
    21.     }
    22.     inline void push(itemtype v)
    23.     {
    24.         stack[p++]=v;
    25.     }
    26.     inline itemtype pop()
    27.     {
    28.         return stack[--p];
    29.     }
    30.     inline int empty()
    31.     {
    32.         return !p;
    33.     }
    34. };
    35. void main()
    36. {
    37.     char c;
    38.     Stack acc;
    39.     int x;
    40.              printf(" nhap vào biểu thức hậu tố");
    41.     while(1)
    42.     {
    43.         x=0;
    44.     //    fflush(stdin);
    45.         cin.get(c);
    46.    
    47.         while(c=='_')
    48.         {
    49.             //fflush(stdin);
    50.             cin.get(c);
    51.         }
    52.             if(c=='.') break;
    53.     //cout<<"nhap vao ";
    54.     //fflush(stdin);
    55.    
    56.  
    57.         if(c=='+')
    58.         x=acc.pop()+acc.pop();
    59.         if(c=='*')
    60.         x=acc.pop()*acc.pop();
    61.         while(c>='0'&&c<='9')
    62.         {
    63.             x=10*x+(c-'0');
    64.             cin.get(c);
    65.         //    cout<<x;  
    66.         }
    67.         acc.push(x);
    68.     }
    69.     cout<<acc.pop()<<'\n';
    70.     getch();
    71. }
    vidụ nhập vào : 2_4_5_+*.=
    kết quả là 18, kí tự _ là dấu cách
    nhưng mà nếu gõ 2_4_5_+_*.
    thì sai đó , nên nếu bạn nào cần giao diện đẹp thì sửa lại code!
    -----------------------
    nếu bạn nào sửa lại đc rồi thì pót lên luôn chớ mình fix nãy giờ mà chưa đc

  9. #9
    Ngày gia nhập
    08 2010
    Bài viết
    1

    Mặc định Template Stack động

    Mình cũng xin mạo muội post stack dynamic sử dụng khuôn hình lớp:
    C++ Code:
    1. #ifndef STACK_DONG_H_INCLUDED
    2. #define STACK_DONG_H_INCLUDED
    3. template < class T >
    4. class STACK_DONG
    5. {
    6. private:
    7.    // Cau truc cho moi nut cua stack
    8.    struct StackNode
    9.    {
    10.       T value;        // Gia tri trong mot nut
    11.       StackNode *next;  // Con tro, tro toi nut ke tiep
    12.    };
    13.  
    14.    StackNode *top;      // Con tro, tro toi dinh cua stack
    15.  
    16. public:
    17.    // Ham khoi tao
    18.    STACK_DONG()
    19.       {  top = 0; }
    20.  
    21.    // Ham huy
    22.    ~STACK_DONG();
    23.  
    24.    // Stack operations
    25.    void push( T );
    26.    void pop( T & );
    27.    bool isEmpty();
    28. };
    29.  
    30.  
    31. #endif // STACK_DONG_H_INCLUDED
    C++ Code:
    1. #include <iostream>
    2. #include "STACK_DONG.h"
    3. using namespace std;
    4.  
    5. //**************************************************
    6. // Ham huy                                     *
    7. // Ham nay dung de xoa moi nut trong danh sach lien ket*
    8. //**************************************************
    9.  
    10. template < class T >
    11. STACK_DONG<T>::~STACK_DONG()
    12. {
    13.    StackNode *nodePtr, *nextNode;
    14.  
    15.    // Dat con tro o dinh cua stack.
    16.    nodePtr = top;
    17.  
    18.    // Duyet qua danh sach va xoa tung nut mot.
    19.    while (nodePtr != 0)
    20.    {
    21.       nextNode = nodePtr->next;
    22.       delete nodePtr;
    23.       nodePtr = nextNode;
    24.    }
    25. }
    26.  
    27. //************************************************
    28. // Phuong thuc Push day doi so vao stack         *
    29. //************************************************
    30. template < class T >
    31. void STACK_DONG<T>::push( T num )
    32. {
    33.    StackNode *newNode; // Tro toi nut moi
    34.  
    35.    // Cap phat cho nut moi.
    36.    newNode = new StackNode;
    37.    newNode->value = num;
    38.  
    39.    // Neu khong co nut nao trong danh sach thi cho nut moi dinh stack.
    40.    if (isEmpty())
    41.    {
    42.       top = newNode;
    43.       newNode->next = 0;
    44.    }
    45.    else  // Nguoc lai, chen nut moi len truoc dinh stack.
    46.    {
    47.       newNode->next = top;
    48.       top = newNode;
    49.    }
    50. }
    51.  
    52. //****************************************************
    53. // Phuong thuc pop lay gia tri ra khoi dinh stack    *
    54. // va gan gia tri cho bien                           *
    55. //****************************************************
    56. template < class T >
    57. void STACK_DONG<T>::pop( T &num )
    58. {
    59.    StackNode *temp; // Con tro trung gian
    60.  
    61.    // Dau tien chac chan stack la rong.
    62.    if (isEmpty())
    63.    {
    64.       cout << "The stack is empty.\n";
    65.    }
    66.    else  // lay gia tri ra khoi dinh stack
    67.    {
    68.       num = top->value;
    69.       temp = top->next;
    70.       delete top;
    71.       top = temp;
    72.    }
    73. }
    74.  
    75. //****************************************************
    76. // Phuong thuc isEmpty tra gia tri true  neu stack   *
    77. // rong , hoac false neu nguoc lai                   *
    78. //****************************************************
    79. template < class T >
    80. bool STACK_DONG<T>::isEmpty()
    81. {
    82.    bool status;
    83.  
    84.    if (!top)
    85.       status = true;
    86.    else
    87.       status = false;
    88.  
    89.    return status;
    90. }

Các đề tài tương tự

  1. Xây dựng lớp stack cho ngăn xếp kiểu int
    Gửi bởi hoaxuyenchi trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 10
    Bài viết cuối: 03-10-2013, 11:12 AM
  2. Bài tập đảo chuỗi bằng phương pháp ngăn xếp Stack
    Gửi bởi sieuthi trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 3
    Bài viết cuối: 19-02-2011, 05:07 PM
  3. Nhược điểm của ngăn xếp stack trên C?
    Gửi bởi gianghien1404 trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 26
    Bài viết cuối: 24-07-2010, 12:45 PM
  4. Stack trên C | Lỗi khó hiểu trong Stack
    Gửi bởi tom3cang trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 1
    Bài viết cuối: 22-05-2009, 11:09 PM
  5. Stack, công dụng và cách sử dụng ngăn xếp như thế nào???
    Gửi bởi toingheo trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 10
    Bài viết cuối: 21-05-2009, 11:09 PM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn