各种基本算法总结——堆栈

 

转载地址：http://blog.youkuaiyun.com/sunboy_2050/article/details/5645812

 

 

各种基本算法实现小结（二）—— 堆 栈

（均已测试通过）

==============================================================

栈——数组实现

测试环境：Win - TC

[cpp:showcolumns] view plain copy print ?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

1. #include <stdio.h> 
2. char stack[512]; 
3. int top=0; 
4. void push(char c) 
5. { 
6.     stack[top]=c; 
7.     top++; 
8. } 
9. char pop() 
10. { 
11.     top--; 
12.     return stack[top]; 
13. } 
14. int is_empty() 
15. { 
16.     return 0==top; 
17. } 
18. void main() 
19. { 
20.     push('1'); 
21.     push('2'); 
22.     push('3'); 
23.     push('4'); 
24.     push('5'); 
25.     while(!is_empty()) 
26.         putchar(pop()); 
27.     putchar('/n'); 
28.     getch(); 
29. } 

#include <stdio.h> char stack[512]; int top=0; void push(char c) { stack[top]=c; top++; } char pop() { top--; return stack[top]; } int is_empty() { return 0==top; } void main() { push('1'); push('2'); push('3'); push('4'); push('5'); while(!is_empty()) putchar(pop()); putchar('/n'); getch(); }

运行结果：

====================================================

栈——数组实现2

测试环境：Win - TC

[cpp:showcolumns] view plain copy print ?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

1. #include <stdio.h> 
2. #include <malloc.h> 
3. /* typedef int DataType; */ 
4. #define DataType int 
5. #define MAX 1024 
6. typedef struct 
7. { 
8.     DataType data[MAX]; 
9.     int top; 
10. }stack, *pstack; 
11. pstack *init_stack() 
12. { 
13.     pstack ps; 
14.     ps=(pstack)malloc(sizeof(stack)); 
15.     if(!ps) 
16.     { 
17.         printf("Error. fail malloc.../n"); 
18.         return NULL; 
19.     } 
20.     ps->top=-1; 
21.     return ps; 
22. } 
23. int empty_stack(pstack ps) 
24. { 
25.     if(-1 == ps->top) 
26.         return 1; 
27.     else 
28.         return 0; 
29. } 
30. int push(pstack ps, DataType data) 
31. { 
32.     if(ps->top == MAX-1) 
33.     { 
34.         printf("Stack is full.../n"); 
35.         return 0; 
36.     } 
37.     ps->top++; 
38.     ps->data[ps->top]=data; 
39.     return 1; 
40. } 
41. int pop(pstack ps, DataType *data) 
42. { 
43.     if(empty_stack(ps)) 
44.     { 
45.         printf("Stack is empty.../n"); 
46.         return 0; 
47.     } 
48.     *data=ps->data[ps->top]; 
49.     ps->top--; 
50.     return 1; 
51. } 
52. DataType top_stack(pstack ps) 
53. { 
54.     if(empty_stack(ps)) 
55.     { 
56.         printf("Stack is empty.../n"); 
57.         return 0; 
58.     } 
59.     return ps->data[ps->top]; 
60. } 
61. void display(pstack ps) 
62. { 
63.     int i; 
64.     if(empty_stack(ps)) 
65.     { 
66.         printf("Stack is empty.../n"); 
67.         return; 
68.     } 
69.     printf("printf the items of stack.../n"); 
70.     for(i=ps->top;i>-1;i--) 
71.         printf("%4d", ps->data[i]); 
72.     printf("/n/n"); 
73. } 
74. void main() 
75. { 
76.     int i, num, data, *pdata; 
77.     pstack ps; 
78.     ps=init_stack(); 
79.     printf("Enter stack num:"); 
80.     scanf("%d", &num); 
81.     for(i=0;i<num;i++) 
82.     { 
83.         scanf("%d", &data); 
84.         push(ps, data); 
85.     } 
86.     display(ps); 
87.     printf("Top is %d/n/n", top_stack(ps)); 
88.     for(i=0;i<num;i++) 
89.     { 
90.         pop(ps, pdata); 
91.         printf("%3d", *pdata); 
92.     } 
93.     printf("/n/n"); 
94.     display(ps); 
95.     getch(); 
96. } 

#include <stdio.h> #include <malloc.h> /* typedef int DataType; */ #define DataType int #define MAX 1024 typedef struct { DataType data[MAX]; int top; }stack, *pstack; pstack *init_stack() { pstack ps; ps=(pstack)malloc(sizeof(stack)); if(!ps) { printf("Error. fail malloc.../n"); return NULL; } ps->top=-1; return ps; } int empty_stack(pstack ps) { if(-1 == ps->top) return 1; else return 0; } int push(pstack ps, DataType data) { if(ps->top == MAX-1) { printf("Stack is full.../n"); return 0; } ps->top++; ps->data[ps->top]=data; return 1; } int pop(pstack ps, DataType *data) { if(empty_stack(ps)) { printf("Stack is empty.../n"); return 0; } *data=ps->data[ps->top]; ps->top--; return 1; } DataType top_stack(pstack ps) { if(empty_stack(ps)) { printf("Stack is empty.../n"); return 0; } return ps->data[ps->top]; } void display(pstack ps) { int i; if(empty_stack(ps)) { printf("Stack is empty.../n"); return; } printf("printf the items of stack.../n"); for(i=ps->top;i>-1;i--) printf("%4d", ps->data[i]); printf("/n/n"); } void main() { int i, num, data, *pdata; pstack ps; ps=init_stack(); printf("Enter stack num:"); scanf("%d", &num); for(i=0;i<num;i++) { scanf("%d", &data); push(ps, data); } display(ps); printf("Top is %d/n/n", top_stack(ps)); for(i=0;i<num;i++) { pop(ps, pdata); printf("%3d", *pdata); } printf("/n/n"); display(ps); getch(); }

运行结果：

====================================================

栈——链表实现

测试环境：Win - TC

[cpp:showcolumns] view plain copy print ?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

1. #include <stdio.h> 
2. #include <malloc.h> 
3. typedef char DataType; 
4. struct _node 
5. { 
6.     DataType data; 
7.     struct _node *next; 
8. }; 
9. typedef struct _node node, *pstack; 
10. pstack init_stack() 
11. { 
12.     pstack ps; 
13.     ps=(pstack)malloc(sizeof(node)); 
14.     if(NULL == ps) 
15.     { 
16.         printf("Error. malloc is fail.../n"); 
17.         return NULL; 
18.     } 
19.     ps->data=-1;  /* base of stack: data=-1 and next=NULL */ 
20.     ps->next=NULL; 
21.     return ps; 
22. } 
23. pstack push(pstack ps, DataType data) 
24. { 
25.     pstack ptop; 
26.     ptop=(pstack)malloc(sizeof(node)); 
27.     if(NULL == ptop) 
28.     { 
29.         printf("Error. malloc is fail.../n"); 
30.         return NULL; 
31.     } 
32.     ptop->data=data; 
33.     ptop->next=ps;   /* insert new item */ 
34.     ps=ptop;         /* move top */ 
35.     return ps; 
36. } 
37. pstack pop(pstack ps, DataType *data) 
38. { 
39.     if(ps->next == NULL) 
40.     { 
41.         printf("stack is empty.../n"); 
42.         return NULL;             
43.     } 
44.     *data=ps->data; 
45.     ps=ps->next; 
46.     return ps; 
47. } 
48. DataType top_stack(pstack ps) 
49. { 
50.     if(ps->next == NULL)  /* if empty */ 
51.     { 
52.         printf("stack is empty.../n"); 
53.         return -1; 
54.     } 
55.     return ps->data; 
56. } 
57. int len_stack(pstack ps) 
58. { 
59.     int len=0; 
60.     pstack ptop=ps; 
61.     while(ptop->next) 
62.     { 
63.         len++; 
64.         ptop=ptop->next; 
65.     } 
66.     return len; 
67. } 
68. void display(pstack ps) 
69. { 
70.     pstack ptop; 
71.     ptop=ps; 
72.     while(ptop->next != NULL) 
73.     { 
74.         printf("%4c", ptop->data); 
75.         ptop=ptop->next; 
76.     } 
77.     printf("/n/n"); 
78. } 
79. void main() 
80. { 
81.     pstack ps; 
82.     DataType *data=(DataType *)malloc(sizeof(DataType)); 
83.     ps=init_stack(); 
84.     ps=push(ps, 'a'); 
85.     ps=push(ps, 'b'); 
86.     ps=push(ps, 'c'); 
87.     ps=push(ps, 'd'); 
88.     ps=push(ps, 'e'); 
89.     display(ps); 
90.     printf("len of stack is: %d/n/n", len_stack(ps)); 
91.     printf("top of stack is: %c/n/n", top_stack(ps)); 
92.     ps=pop(ps, data); 
93.     printf("pop %c/n",*data); 
94.     display(ps); 
95.     ps=pop(ps, data); 
96.     printf("pop %c/n",*data); 
97.     display(ps); 
98.     getch(); 
99. } 

#include <stdio.h> #include <malloc.h> typedef char DataType; struct _node { DataType data; struct _node *next; }; typedef struct _node node, *pstack; pstack init_stack() { pstack ps; ps=(pstack)malloc(sizeof(node)); if(NULL == ps) { printf("Error. malloc is fail.../n"); return NULL; } ps->data=-1; /* base of stack: data=-1 and next=NULL */ ps->next=NULL; return ps; } pstack push(pstack ps, DataType data) { pstack ptop; ptop=(pstack)malloc(sizeof(node)); if(NULL == ptop) { printf("Error. malloc is fail.../n"); return NULL; } ptop->data=data; ptop->next=ps; /* insert new item */ ps=ptop; /* move top */ return ps; } pstack pop(pstack ps, DataType *data) { if(ps->next == NULL) { printf("stack is empty.../n"); return NULL; } *data=ps->data; ps=ps->next; return ps; } DataType top_stack(pstack ps) { if(ps->next == NULL) /* if empty */ { printf("stack is empty.../n"); return -1; } return ps->data; } int len_stack(pstack ps) { int len=0; pstack ptop=ps; while(ptop->next) { len++; ptop=ptop->next; } return len; } void display(pstack ps) { pstack ptop; ptop=ps; while(ptop->next != NULL) { printf("%4c", ptop->data); ptop=ptop->next; } printf("/n/n"); } void main() { pstack ps; DataType *data=(DataType *)malloc(sizeof(DataType)); ps=init_stack(); ps=push(ps, 'a'); ps=push(ps, 'b'); ps=push(ps, 'c'); ps=push(ps, 'd'); ps=push(ps, 'e'); display(ps); printf("len of stack is: %d/n/n", len_stack(ps)); printf("top of stack is: %c/n/n", top_stack(ps)); ps=pop(ps, data); printf("pop %c/n",*data); display(ps); ps=pop(ps, data); printf("pop %c/n",*data); display(ps); getch(); }

运行结果：

========================================================

堆 ——链表实现

测试环境：Win - TC

[cpp:showcolumns] view plain copy print ?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

1. #include <stdio.h> 
2. #include <malloc.h> 
3. #include <stdlib.h> 
4. struct _node 
5. { 
6.     int data; 
7.     struct _node *next; 
8. }; 
9. typedef struct _node node, *pnode; 
10. struct _linkqueue 
11. { 
12.     pnode front; 
13.     pnode rear;     
14. }; 
15. typedef struct _linkqueue linkqueue, *plinkqueue; 
16. linkqueue init_queue() 
17. { 
18.     linkqueue lq; 
19.     lq.front=lq.rear=(pnode)malloc(sizeof(node)); 
20.     if(NULL == lq.front) 
21.     { 
22.         printf("Error. malloc is fail.../n"); 
23.         exit(1); 
24.     } 
25.     lq.rear->data=lq.front->data=-1; 
26.     lq.rear->next=lq.front->next=NULL; 
27.     return lq; 
28. } 
29. int empty_queue(linkqueue lq) 
30. { 
31.     if(lq.front == lq.rear) 
32.         return 1; 
33.      else 
34.         return 0; 
35. } 
36. linkqueue insert_item(linkqueue lq, int data) 
37. { 
38.     pnode pq; 
39.     pq=(pnode)malloc(sizeof(node)); 
40.     if(pq == NULL) 
41.     { 
42.         printf("Error. malloc is fail.../n"); 
43.         exit(1); 
44.     } 
45.     pq->data=data; 
46.     pq->next=lq.rear->next; 
47.     lq.rear->next=pq; 
48.     lq.rear=lq.rear->next; 
49.     return lq; 
50. } 
51. linkqueue delete_item(linkqueue lq, int *data) 
52. { 
53.     if(empty_queue(lq)) 
54.     { 
55.         printf("queue is empty.../n"); 
56.         exit(1); 
57.     } 
58.     *data=lq.front->data; 
59.     lq.front=lq.front->next; 
60.     return lq; 
61. } 
62. int len_queue(linkqueue lq) 
63. { 
64.     int len=0; 
65.     while(lq.front) 
66.     { 
67.         len++; 
68.         lq.front=lq.front->next; 
69.     } 
70.     return len; 
71. } 
72. void display(linkqueue lq) 
73. { 
74.     linkqueue p; 
75.     p=lq; 
76.     if(empty_queue(lq)) 
77.     { 
78.         printf("queue is empty.../n"); 
79.         return; 
80.     } 
81.     while(p.front->next) 
82.     { 
83.         printf("%4d", p.front->data); 
84.         p.front=p.front->next; 
85.     } 
86.     printf("%4d/n/n", p.front->data); 
87. } 
88. void main() 
89. { 
90.     int *data = (int *)malloc(sizeof(int)); 
91.     linkqueue lq; 
92.     lq=init_queue(); 
93.     lq=insert_item(lq, 1); 
94.     lq=insert_item(lq, 2); 
95.     lq=insert_item(lq, 3); 
96.     lq=insert_item(lq, 4); 
97.     lq=insert_item(lq, 5); 
98.     display(lq); 
99.     printf("len of queue is: %d/n/n", len_queue(lq)); 
100.     lq=delete_item(lq, data); 
101.     printf("delete %d/n", *data); 
102.     display(lq); 
103.     lq=delete_item(lq, data); 
104.     printf("delete %d/n", *data); 
105.     display(lq); 
106.     getch(); 
107. } 

#include <stdio.h> #include <malloc.h> #include <stdlib.h> struct _node { int data; struct _node *next; }; typedef struct _node node, *pnode; struct _linkqueue { pnode front; pnode rear; }; typedef struct _linkqueue linkqueue, *plinkqueue; linkqueue init_queue() { linkqueue lq; lq.front=lq.rear=(pnode)malloc(sizeof(node)); if(NULL == lq.front) { printf("Error. malloc is fail.../n"); exit(1); } lq.rear->data=lq.front->data=-1; lq.rear->next=lq.front->next=NULL; return lq; } int empty_queue(linkqueue lq) { if(lq.front == lq.rear) return 1; else return 0; } linkqueue insert_item(linkqueue lq, int data) { pnode pq; pq=(pnode)malloc(sizeof(node)); if(pq == NULL) { printf("Error. malloc is fail.../n"); exit(1); } pq->data=data; pq->next=lq.rear->next; lq.rear->next=pq; lq.rear=lq.rear->next; return lq; } linkqueue delete_item(linkqueue lq, int *data) { if(empty_queue(lq)) { printf("queue is empty.../n"); exit(1); } *data=lq.front->data; lq.front=lq.front->next; return lq; } int len_queue(linkqueue lq) { int len=0; while(lq.front) { len++; lq.front=lq.front->next; } return len; } void display(linkqueue lq) { linkqueue p; p=lq; if(empty_queue(lq)) { printf("queue is empty.../n"); return; } while(p.front->next) { printf("%4d", p.front->data); p.front=p.front->next; } printf("%4d/n/n", p.front->data); } void main() { int *data = (int *)malloc(sizeof(int)); linkqueue lq; lq=init_queue(); lq=insert_item(lq, 1); lq=insert_item(lq, 2); lq=insert_item(lq, 3); lq=insert_item(lq, 4); lq=insert_item(lq, 5); display(lq); printf("len of queue is: %d/n/n", len_queue(lq)); lq=delete_item(lq, data); printf("delete %d/n", *data); display(lq); lq=delete_item(lq, data); printf("delete %d/n", *data); display(lq); getch(); }

运行结果：